From 167743c99337834ebd473cb71d6bfa1fca3984c9 Mon Sep 17 00:00:00 2001 From: BossZou <40255591+BossZou@users.noreply.github.com> Date: Tue, 2 Jun 2020 14:34:19 +0800 Subject: [PATCH] read_only node detect delete vector operation using mishards #2368 (#2473) * Add new request ReLoadSegments Signed-off-by: yhz <413554850@qq.com> * Finish load segments functionality Signed-off-by: yhz <413554850@qq.com> * Add api in grpc Signed-off-by: yhz <413554850@qq.com> * update Reloadsegments Signed-off-by: yhz <413554850@qq.com> * . Signed-off-by: yhz <413554850@qq.com> * create new blacklist if not exists Signed-off-by: Yhz * update api names Signed-off-by: Yhz * Finish mishard for support api reloadsegments Signed-off-by: Yhz * update changlog Signed-off-by: Yhz * Add more details when failed in search task Signed-off-by: Yhz * Fix compile issue Signed-off-by: Yhz * update mishards requirements Signed-off-by: Yhz * Code format Signed-off-by: Yhz * modify docker images in mysql all_in_one Signed-off-by: Yhz * update shards code Signed-off-by: Yhz * Move updatedeldocs function to dbimpl Signed-off-by: yhz <413554850@qq.com> * Move reload segment del docs function to dbimpl Signed-off-by: yhz <413554850@qq.com> * [skip ci] correct shards requirements Signed-off-by: yhz <413554850@qq.com> --- CHANGELOG.md | 1 + core/src/db/DB.h | 3 + core/src/db/DBImpl.cpp | 57 ++ core/src/db/DBImpl.h | 3 + core/src/grpc/gen-milvus/milvus.grpc.pb.cc | 104 ++- core/src/grpc/gen-milvus/milvus.grpc.pb.h | 475 +++++++---- core/src/grpc/gen-milvus/milvus.pb.cc | 794 +++++++++++++----- core/src/grpc/gen-milvus/milvus.pb.h | 356 +++++++- core/src/grpc/milvus.proto | 17 + core/src/scheduler/task/SearchTask.cpp | 4 +- core/src/server/delivery/RequestHandler.cpp | 10 + core/src/server/delivery/RequestHandler.h | 4 + .../server/delivery/request/BaseRequest.cpp | 1 + .../src/server/delivery/request/BaseRequest.h | 1 + .../request/ReLoadSegmentsRequest.cpp | 74 ++ .../delivery/request/ReLoadSegmentsRequest.h | 42 + .../server/grpc_impl/GrpcRequestHandler.cpp | 19 + .../src/server/grpc_impl/GrpcRequestHandler.h | 5 + sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc | 104 ++- sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h | 475 +++++++---- sdk/grpc-gen/gen-milvus/milvus.pb.cc | 794 +++++++++++++----- sdk/grpc-gen/gen-milvus/milvus.pb.h | 356 +++++++- .../plugins/file_based_hash_ring_router.py | 34 +- shards/mishards/service_handler.py | 13 +- shards/mishards/settings.py | 2 +- shards/requirements.txt | 4 +- 26 files changed, 2878 insertions(+), 874 deletions(-) create mode 100644 core/src/server/delivery/request/ReLoadSegmentsRequest.cpp create mode 100644 core/src/server/delivery/request/ReLoadSegmentsRequest.h diff --git a/CHANGELOG.md b/CHANGELOG.md index 141536e3c4..75b014b3bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ Please mark all change in change log and use the issue from GitHub ## Bug - \#2367 Fix inconsistent reading and writing when using mishards +- \#2368 Make read node detect delete behavior - \#2373 Build index for small segment waste time on waiting background index thread finish - \#2394 Drop collection timeout if too many partitions created on collection diff --git a/core/src/db/DB.h b/core/src/db/DB.h index ef458b59ea..d5bca1f7b2 100644 --- a/core/src/db/DB.h +++ b/core/src/db/DB.h @@ -74,6 +74,9 @@ class DB { PreloadCollection(const std::shared_ptr& context, const std::string& collection_id, bool force = false) = 0; + virtual Status + ReLoadSegmentsDeletedDocs(const std::string& collection_id, const std::vector& segment_ids) = 0; + virtual Status UpdateCollectionFlag(const std::string& collection_id, int64_t flag) = 0; diff --git a/core/src/db/DBImpl.cpp b/core/src/db/DBImpl.cpp index 314423f70e..5d547ad4b9 100644 --- a/core/src/db/DBImpl.cpp +++ b/core/src/db/DBImpl.cpp @@ -528,6 +528,63 @@ DBImpl::PreloadCollection(const std::shared_ptr& context, const return Status::OK(); } +Status +DBImpl::ReLoadSegmentsDeletedDocs(const std::string& collection_id, const std::vector& segment_ids) { + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + meta::FilesHolder files_holder; + std::vector file_ids; + for (auto& id : segment_ids) { + file_ids.emplace_back(id); + } + + auto status = meta_ptr_->FilesByID(file_ids, files_holder); + if (!status.ok()) { + std::string err_msg = "Failed get file holders by ids: " + status.ToString(); + LOG_ENGINE_ERROR_ << err_msg; + return Status(DB_ERROR, err_msg); + } + + milvus::engine::meta::SegmentsSchema hold_files = files_holder.HoldFiles(); + + for (auto& file : hold_files) { + std::string segment_dir; + utils::GetParentPath(file.location_, segment_dir); + + auto data_obj_ptr = cache::CpuCacheMgr::GetInstance()->GetIndex(file.location_); + auto index = std::static_pointer_cast(data_obj_ptr); + if (nullptr == index) { + LOG_ENGINE_WARNING_ << "Index " << file.location_ << " not found"; + continue; + } + + segment::SegmentReader segment_reader(segment_dir); + + segment::DeletedDocsPtr delete_docs = std::make_shared(); + segment_reader.LoadDeletedDocs(delete_docs); + auto& docs_offsets = delete_docs->GetDeletedDocs(); + + faiss::ConcurrentBitsetPtr blacklist = index->GetBlacklist(); + if (nullptr == blacklist) { + LOG_ENGINE_WARNING_ << "Index " << file.location_ << " is empty"; + faiss::ConcurrentBitsetPtr concurrent_bitset_ptr = + std::make_shared(index->Count()); + index->SetBlacklist(concurrent_bitset_ptr); + blacklist = concurrent_bitset_ptr; + } + + for (auto& i : docs_offsets) { + if (!blacklist->test(i)) { + blacklist->set(i); + } + } + } + + return Status::OK(); +} + Status DBImpl::UpdateCollectionFlag(const std::string& collection_id, int64_t flag) { if (!initialized_.load(std::memory_order_acquire)) { diff --git a/core/src/db/DBImpl.h b/core/src/db/DBImpl.h index f81df01d86..ca268d847d 100644 --- a/core/src/db/DBImpl.h +++ b/core/src/db/DBImpl.h @@ -81,6 +81,9 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi PreloadCollection(const std::shared_ptr& context, const std::string& collection_id, bool force = false) override; + Status + ReLoadSegmentsDeletedDocs(const std::string& collection_id, const std::vector& segment_ids) override; + Status UpdateCollectionFlag(const std::string& collection_id, int64_t flag) override; diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc index 297564670f..81b5a99b98 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc @@ -43,6 +43,7 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/Cmd", "/milvus.grpc.MilvusService/DeleteByID", "/milvus.grpc.MilvusService/PreloadCollection", + "/milvus.grpc.MilvusService/ReloadSegments", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", "/milvus.grpc.MilvusService/CreateHybridCollection", @@ -91,22 +92,23 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_Cmd_(MilvusService_method_names[20], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DeleteByID_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PreloadCollection_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_Flush_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_Compact_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CreateHybridCollection_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HasHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DropHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CountHybridCollection_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowHybridCollections_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_InsertEntity_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HybridSearch_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_GetEntityByID_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_GetEntityIDs_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ReloadSegments_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Flush_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Compact_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CreateHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountHybridCollection_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollections_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_InsertEntity_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearch_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityByID_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityIDs_(MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[39], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { @@ -753,6 +755,34 @@ void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientCo return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, false); } +::grpc::Status MilvusService::Stub::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ReloadSegments_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_ReloadSegments_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_ReloadSegments_, context, request, false); +} + ::grpc::Status MilvusService::Stub::Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Flush_, context, request, response); } @@ -1320,80 +1350,85 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::ReloadSegments), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[24], + ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::FlushParam, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Flush), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[24], + MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[25], + MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Mapping, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::CreateHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[26], + MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( std::mem_fn(&MilvusService::Service::HasHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[27], + MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DropHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[28], + MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( std::mem_fn(&MilvusService::Service::DescribeHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[29], + MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( std::mem_fn(&MilvusService::Service::CountHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[30], + MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::MappingList>( std::mem_fn(&MilvusService::Service::ShowHybridCollections), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[31], + MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( std::mem_fn(&MilvusService::Service::ShowHybridCollectionInfo), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[32], + MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::PreloadHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[33], + MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( std::mem_fn(&MilvusService::Service::InsertEntity), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[34], + MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearch), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[35], + MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearchInSegments), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[36], + MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( std::mem_fn(&MilvusService::Service::GetEntityByID), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[37], + MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( std::mem_fn(&MilvusService::Service::GetEntityIDs), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[38], + MilvusService_method_names[39], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DeleteEntitiesByID), this))); @@ -1563,6 +1598,13 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } +::grpc::Status MilvusService::Service::ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + ::grpc::Status MilvusService::Service::Flush(::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response) { (void) context; (void) request; diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.h b/core/src/grpc/gen-milvus/milvus.grpc.pb.h index 969758d750..96bc956102 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.h +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.h @@ -347,6 +347,19 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual ::grpc::Status ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncReloadSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncReloadSegmentsRaw(context, request, cq)); + } + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -717,6 +730,16 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -854,6 +877,8 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; @@ -1051,6 +1076,13 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } + ::grpc::Status ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncReloadSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncReloadSegmentsRaw(context, request, cq)); + } ::grpc::Status Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncFlushRaw(context, request, cq)); @@ -1258,6 +1290,10 @@ class MilvusService final { void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function) override; + void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; @@ -1379,6 +1415,8 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; @@ -1434,6 +1472,7 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_Cmd_; const ::grpc::internal::RpcMethod rpcmethod_DeleteByID_; const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ReloadSegments_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; const ::grpc::internal::RpcMethod rpcmethod_CreateHybridCollection_; @@ -1619,6 +1658,13 @@ class MilvusService final { // @return Status virtual ::grpc::Status PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual ::grpc::Status ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response); + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -2121,12 +2167,32 @@ class MilvusService final { } }; template + class WithAsyncMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ReloadSegments() { + ::grpc::Service::MarkMethodAsync(23); + } + ~WithAsyncMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReloadSegments(::grpc::ServerContext* context, ::milvus::grpc::ReLoadSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class WithAsyncMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Flush() { - ::grpc::Service::MarkMethodAsync(23); + ::grpc::Service::MarkMethodAsync(24); } ~WithAsyncMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -2137,7 +2203,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFlush(::grpc::ServerContext* context, ::milvus::grpc::FlushParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2146,7 +2212,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Compact() { - ::grpc::Service::MarkMethodAsync(24); + ::grpc::Service::MarkMethodAsync(25); } ~WithAsyncMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -2157,7 +2223,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2166,7 +2232,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodAsync(25); + ::grpc::Service::MarkMethodAsync(26); } ~WithAsyncMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2177,7 +2243,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCreateHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::Mapping* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2186,7 +2252,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodAsync(26); + ::grpc::Service::MarkMethodAsync(27); } ~WithAsyncMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2197,7 +2263,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2206,7 +2272,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodAsync(27); + ::grpc::Service::MarkMethodAsync(28); } ~WithAsyncMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2217,7 +2283,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDropHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2226,7 +2292,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodAsync(28); + ::grpc::Service::MarkMethodAsync(29); } ~WithAsyncMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2237,7 +2303,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Mapping>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2246,7 +2312,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodAsync(29); + ::grpc::Service::MarkMethodAsync(30); } ~WithAsyncMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2257,7 +2323,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCountHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2266,7 +2332,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodAsync(30); + ::grpc::Service::MarkMethodAsync(31); } ~WithAsyncMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -2277,7 +2343,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::MappingList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2286,7 +2352,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodAsync(31); + ::grpc::Service::MarkMethodAsync(32); } ~WithAsyncMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -2297,7 +2363,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2306,7 +2372,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodAsync(32); + ::grpc::Service::MarkMethodAsync(33); } ~WithAsyncMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2317,7 +2383,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2326,7 +2392,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_InsertEntity() { - ::grpc::Service::MarkMethodAsync(33); + ::grpc::Service::MarkMethodAsync(34); } ~WithAsyncMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -2337,7 +2403,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertEntity(::grpc::ServerContext* context, ::milvus::grpc::HInsertParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2346,7 +2412,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HybridSearch() { - ::grpc::Service::MarkMethodAsync(34); + ::grpc::Service::MarkMethodAsync(35); } ~WithAsyncMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -2357,7 +2423,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2366,7 +2432,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodAsync(35); + ::grpc::Service::MarkMethodAsync(36); } ~WithAsyncMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -2377,7 +2443,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::milvus::grpc::HSearchInSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2386,7 +2452,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetEntityByID() { - ::grpc::Service::MarkMethodAsync(36); + ::grpc::Service::MarkMethodAsync(37); } ~WithAsyncMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -2397,7 +2463,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::HEntityIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2406,7 +2472,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodAsync(37); + ::grpc::Service::MarkMethodAsync(38); } ~WithAsyncMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -2417,7 +2483,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityIDs(::grpc::ServerContext* context, ::milvus::grpc::HGetEntityIDsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2426,7 +2492,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodAsync(38); + ::grpc::Service::MarkMethodAsync(39); } ~WithAsyncMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -2437,10 +2503,10 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::milvus::grpc::HDeleteByIDParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(39, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: @@ -3155,12 +3221,43 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithCallbackMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ReloadSegments() { + ::grpc::Service::experimental().MarkMethodCallback(23, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::ReLoadSegmentsParam* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ReloadSegments(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ReloadSegments( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(23)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class ExperimentalWithCallbackMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_Flush() { - ::grpc::Service::experimental().MarkMethodCallback(23, + ::grpc::Service::experimental().MarkMethodCallback(24, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, @@ -3172,7 +3269,7 @@ class MilvusService final { void SetMessageAllocatorFor_Flush( ::grpc::experimental::MessageAllocator< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(23)) + ::grpc::Service::experimental().GetHandler(24)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_Flush() override { @@ -3191,7 +3288,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_Compact() { - ::grpc::Service::experimental().MarkMethodCallback(24, + ::grpc::Service::experimental().MarkMethodCallback(25, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3203,7 +3300,7 @@ class MilvusService final { void SetMessageAllocatorFor_Compact( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(24)) + ::grpc::Service::experimental().GetHandler(25)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_Compact() override { @@ -3222,7 +3319,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_CreateHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(25, + ::grpc::Service::experimental().MarkMethodCallback(26, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, @@ -3234,7 +3331,7 @@ class MilvusService final { void SetMessageAllocatorFor_CreateHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::Mapping, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(25)) + ::grpc::Service::experimental().GetHandler(26)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_CreateHybridCollection() override { @@ -3253,7 +3350,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HasHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(26, + ::grpc::Service::experimental().MarkMethodCallback(27, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3265,7 +3362,7 @@ class MilvusService final { void SetMessageAllocatorFor_HasHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( - ::grpc::Service::experimental().GetHandler(26)) + ::grpc::Service::experimental().GetHandler(27)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HasHybridCollection() override { @@ -3284,7 +3381,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DropHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(27, + ::grpc::Service::experimental().MarkMethodCallback(28, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3296,7 +3393,7 @@ class MilvusService final { void SetMessageAllocatorFor_DropHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(27)) + ::grpc::Service::experimental().GetHandler(28)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DropHybridCollection() override { @@ -3315,7 +3412,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DescribeHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(28, + ::grpc::Service::experimental().MarkMethodCallback(29, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3327,7 +3424,7 @@ class MilvusService final { void SetMessageAllocatorFor_DescribeHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>*>( - ::grpc::Service::experimental().GetHandler(28)) + ::grpc::Service::experimental().GetHandler(29)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DescribeHybridCollection() override { @@ -3346,7 +3443,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_CountHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(29, + ::grpc::Service::experimental().MarkMethodCallback(30, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3358,7 +3455,7 @@ class MilvusService final { void SetMessageAllocatorFor_CountHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( - ::grpc::Service::experimental().GetHandler(29)) + ::grpc::Service::experimental().GetHandler(30)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_CountHybridCollection() override { @@ -3377,7 +3474,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_ShowHybridCollections() { - ::grpc::Service::experimental().MarkMethodCallback(30, + ::grpc::Service::experimental().MarkMethodCallback(31, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Command* request, @@ -3389,7 +3486,7 @@ class MilvusService final { void SetMessageAllocatorFor_ShowHybridCollections( ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::MappingList>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>*>( - ::grpc::Service::experimental().GetHandler(30)) + ::grpc::Service::experimental().GetHandler(31)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_ShowHybridCollections() override { @@ -3408,7 +3505,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() { - ::grpc::Service::experimental().MarkMethodCallback(31, + ::grpc::Service::experimental().MarkMethodCallback(32, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3420,7 +3517,7 @@ class MilvusService final { void SetMessageAllocatorFor_ShowHybridCollectionInfo( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( - ::grpc::Service::experimental().GetHandler(31)) + ::grpc::Service::experimental().GetHandler(32)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() override { @@ -3439,7 +3536,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_PreloadHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(32, + ::grpc::Service::experimental().MarkMethodCallback(33, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3451,7 +3548,7 @@ class MilvusService final { void SetMessageAllocatorFor_PreloadHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(32)) + ::grpc::Service::experimental().GetHandler(33)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_PreloadHybridCollection() override { @@ -3470,7 +3567,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_InsertEntity() { - ::grpc::Service::experimental().MarkMethodCallback(33, + ::grpc::Service::experimental().MarkMethodCallback(34, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, @@ -3482,7 +3579,7 @@ class MilvusService final { void SetMessageAllocatorFor_InsertEntity( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>*>( - ::grpc::Service::experimental().GetHandler(33)) + ::grpc::Service::experimental().GetHandler(34)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_InsertEntity() override { @@ -3501,7 +3598,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HybridSearch() { - ::grpc::Service::experimental().MarkMethodCallback(34, + ::grpc::Service::experimental().MarkMethodCallback(35, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, @@ -3513,7 +3610,7 @@ class MilvusService final { void SetMessageAllocatorFor_HybridSearch( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>*>( - ::grpc::Service::experimental().GetHandler(34)) + ::grpc::Service::experimental().GetHandler(35)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HybridSearch() override { @@ -3532,7 +3629,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HybridSearchInSegments() { - ::grpc::Service::experimental().MarkMethodCallback(35, + ::grpc::Service::experimental().MarkMethodCallback(36, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, @@ -3544,7 +3641,7 @@ class MilvusService final { void SetMessageAllocatorFor_HybridSearchInSegments( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>*>( - ::grpc::Service::experimental().GetHandler(35)) + ::grpc::Service::experimental().GetHandler(36)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HybridSearchInSegments() override { @@ -3563,7 +3660,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_GetEntityByID() { - ::grpc::Service::experimental().MarkMethodCallback(36, + ::grpc::Service::experimental().MarkMethodCallback(37, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, @@ -3575,7 +3672,7 @@ class MilvusService final { void SetMessageAllocatorFor_GetEntityByID( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>*>( - ::grpc::Service::experimental().GetHandler(36)) + ::grpc::Service::experimental().GetHandler(37)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_GetEntityByID() override { @@ -3594,7 +3691,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_GetEntityIDs() { - ::grpc::Service::experimental().MarkMethodCallback(37, + ::grpc::Service::experimental().MarkMethodCallback(38, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, @@ -3606,7 +3703,7 @@ class MilvusService final { void SetMessageAllocatorFor_GetEntityIDs( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>*>( - ::grpc::Service::experimental().GetHandler(37)) + ::grpc::Service::experimental().GetHandler(38)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_GetEntityIDs() override { @@ -3625,7 +3722,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DeleteEntitiesByID() { - ::grpc::Service::experimental().MarkMethodCallback(38, + ::grpc::Service::experimental().MarkMethodCallback(39, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, @@ -3637,7 +3734,7 @@ class MilvusService final { void SetMessageAllocatorFor_DeleteEntitiesByID( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(38)) + ::grpc::Service::experimental().GetHandler(39)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DeleteEntitiesByID() override { @@ -3650,7 +3747,7 @@ class MilvusService final { } virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template class WithGenericMethod_CreateCollection : public BaseClass { private: @@ -4043,12 +4140,29 @@ class MilvusService final { } }; template + class WithGenericMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ReloadSegments() { + ::grpc::Service::MarkMethodGeneric(23); + } + ~WithGenericMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template class WithGenericMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Flush() { - ::grpc::Service::MarkMethodGeneric(23); + ::grpc::Service::MarkMethodGeneric(24); } ~WithGenericMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -4065,7 +4179,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Compact() { - ::grpc::Service::MarkMethodGeneric(24); + ::grpc::Service::MarkMethodGeneric(25); } ~WithGenericMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -4082,7 +4196,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodGeneric(25); + ::grpc::Service::MarkMethodGeneric(26); } ~WithGenericMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4099,7 +4213,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodGeneric(26); + ::grpc::Service::MarkMethodGeneric(27); } ~WithGenericMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4116,7 +4230,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodGeneric(27); + ::grpc::Service::MarkMethodGeneric(28); } ~WithGenericMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4133,7 +4247,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodGeneric(28); + ::grpc::Service::MarkMethodGeneric(29); } ~WithGenericMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4150,7 +4264,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodGeneric(29); + ::grpc::Service::MarkMethodGeneric(30); } ~WithGenericMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4167,7 +4281,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodGeneric(30); + ::grpc::Service::MarkMethodGeneric(31); } ~WithGenericMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -4184,7 +4298,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodGeneric(31); + ::grpc::Service::MarkMethodGeneric(32); } ~WithGenericMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -4201,7 +4315,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodGeneric(32); + ::grpc::Service::MarkMethodGeneric(33); } ~WithGenericMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4218,7 +4332,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_InsertEntity() { - ::grpc::Service::MarkMethodGeneric(33); + ::grpc::Service::MarkMethodGeneric(34); } ~WithGenericMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -4235,7 +4349,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HybridSearch() { - ::grpc::Service::MarkMethodGeneric(34); + ::grpc::Service::MarkMethodGeneric(35); } ~WithGenericMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -4252,7 +4366,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodGeneric(35); + ::grpc::Service::MarkMethodGeneric(36); } ~WithGenericMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -4269,7 +4383,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetEntityByID() { - ::grpc::Service::MarkMethodGeneric(36); + ::grpc::Service::MarkMethodGeneric(37); } ~WithGenericMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -4286,7 +4400,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodGeneric(37); + ::grpc::Service::MarkMethodGeneric(38); } ~WithGenericMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -4303,7 +4417,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodGeneric(38); + ::grpc::Service::MarkMethodGeneric(39); } ~WithGenericMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -4775,12 +4889,32 @@ class MilvusService final { } }; template + class WithRawMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ReloadSegments() { + ::grpc::Service::MarkMethodRaw(23); + } + ~WithRawMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReloadSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class WithRawMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Flush() { - ::grpc::Service::MarkMethodRaw(23); + ::grpc::Service::MarkMethodRaw(24); } ~WithRawMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -4791,7 +4925,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFlush(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4800,7 +4934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Compact() { - ::grpc::Service::MarkMethodRaw(24); + ::grpc::Service::MarkMethodRaw(25); } ~WithRawMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -4811,7 +4945,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCompact(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4820,7 +4954,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodRaw(25); + ::grpc::Service::MarkMethodRaw(26); } ~WithRawMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4831,7 +4965,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4840,7 +4974,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodRaw(26); + ::grpc::Service::MarkMethodRaw(27); } ~WithRawMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4851,7 +4985,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4860,7 +4994,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodRaw(27); + ::grpc::Service::MarkMethodRaw(28); } ~WithRawMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4871,7 +5005,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDropHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4880,7 +5014,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodRaw(28); + ::grpc::Service::MarkMethodRaw(29); } ~WithRawMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4891,7 +5025,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4900,7 +5034,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodRaw(29); + ::grpc::Service::MarkMethodRaw(30); } ~WithRawMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4911,7 +5045,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCountHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4920,7 +5054,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodRaw(30); + ::grpc::Service::MarkMethodRaw(31); } ~WithRawMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -4931,7 +5065,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4940,7 +5074,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodRaw(31); + ::grpc::Service::MarkMethodRaw(32); } ~WithRawMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -4951,7 +5085,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4960,7 +5094,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodRaw(32); + ::grpc::Service::MarkMethodRaw(33); } ~WithRawMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4971,7 +5105,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4980,7 +5114,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_InsertEntity() { - ::grpc::Service::MarkMethodRaw(33); + ::grpc::Service::MarkMethodRaw(34); } ~WithRawMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -4991,7 +5125,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5000,7 +5134,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HybridSearch() { - ::grpc::Service::MarkMethodRaw(34); + ::grpc::Service::MarkMethodRaw(35); } ~WithRawMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -5011,7 +5145,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearch(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5020,7 +5154,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodRaw(35); + ::grpc::Service::MarkMethodRaw(36); } ~WithRawMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -5031,7 +5165,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5040,7 +5174,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetEntityByID() { - ::grpc::Service::MarkMethodRaw(36); + ::grpc::Service::MarkMethodRaw(37); } ~WithRawMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -5051,7 +5185,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5060,7 +5194,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodRaw(37); + ::grpc::Service::MarkMethodRaw(38); } ~WithRawMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -5071,7 +5205,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityIDs(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5080,7 +5214,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodRaw(38); + ::grpc::Service::MarkMethodRaw(39); } ~WithRawMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -5091,7 +5225,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(39, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5670,12 +5804,37 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithRawCallbackMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ReloadSegments() { + ::grpc::Service::experimental().MarkMethodRawCallback(23, + new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this](::grpc::ServerContext* context, + const ::grpc::ByteBuffer* request, + ::grpc::ByteBuffer* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + this->ReloadSegments(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReloadSegments(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class ExperimentalWithRawCallbackMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_Flush() { - ::grpc::Service::experimental().MarkMethodRawCallback(23, + ::grpc::Service::experimental().MarkMethodRawCallback(24, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5700,7 +5859,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_Compact() { - ::grpc::Service::experimental().MarkMethodRawCallback(24, + ::grpc::Service::experimental().MarkMethodRawCallback(25, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5725,7 +5884,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_CreateHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(25, + ::grpc::Service::experimental().MarkMethodRawCallback(26, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5750,7 +5909,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HasHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(26, + ::grpc::Service::experimental().MarkMethodRawCallback(27, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5775,7 +5934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DropHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(27, + ::grpc::Service::experimental().MarkMethodRawCallback(28, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5800,7 +5959,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DescribeHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(28, + ::grpc::Service::experimental().MarkMethodRawCallback(29, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5825,7 +5984,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_CountHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(29, + ::grpc::Service::experimental().MarkMethodRawCallback(30, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5850,7 +6009,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_ShowHybridCollections() { - ::grpc::Service::experimental().MarkMethodRawCallback(30, + ::grpc::Service::experimental().MarkMethodRawCallback(31, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5875,7 +6034,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() { - ::grpc::Service::experimental().MarkMethodRawCallback(31, + ::grpc::Service::experimental().MarkMethodRawCallback(32, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5900,7 +6059,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_PreloadHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(32, + ::grpc::Service::experimental().MarkMethodRawCallback(33, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5925,7 +6084,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_InsertEntity() { - ::grpc::Service::experimental().MarkMethodRawCallback(33, + ::grpc::Service::experimental().MarkMethodRawCallback(34, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5950,7 +6109,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HybridSearch() { - ::grpc::Service::experimental().MarkMethodRawCallback(34, + ::grpc::Service::experimental().MarkMethodRawCallback(35, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5975,7 +6134,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HybridSearchInSegments() { - ::grpc::Service::experimental().MarkMethodRawCallback(35, + ::grpc::Service::experimental().MarkMethodRawCallback(36, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6000,7 +6159,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_GetEntityByID() { - ::grpc::Service::experimental().MarkMethodRawCallback(36, + ::grpc::Service::experimental().MarkMethodRawCallback(37, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6025,7 +6184,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_GetEntityIDs() { - ::grpc::Service::experimental().MarkMethodRawCallback(37, + ::grpc::Service::experimental().MarkMethodRawCallback(38, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6050,7 +6209,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() { - ::grpc::Service::experimental().MarkMethodRawCallback(38, + ::grpc::Service::experimental().MarkMethodRawCallback(39, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6530,12 +6689,32 @@ class MilvusService final { virtual ::grpc::Status StreamedPreloadCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template + class WithStreamedUnaryMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ReloadSegments() { + ::grpc::Service::MarkMethodStreamed(23, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_ReloadSegments::StreamedReloadSegments, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedReloadSegments(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::ReLoadSegmentsParam,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template class WithStreamedUnaryMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Flush() { - ::grpc::Service::MarkMethodStreamed(23, + ::grpc::Service::MarkMethodStreamed(24, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Flush::StreamedFlush, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Flush() override { @@ -6555,7 +6734,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Compact() { - ::grpc::Service::MarkMethodStreamed(24, + ::grpc::Service::MarkMethodStreamed(25, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Compact() override { @@ -6575,7 +6754,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodStreamed(25, + ::grpc::Service::MarkMethodStreamed(26, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateHybridCollection::StreamedCreateHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_CreateHybridCollection() override { @@ -6595,7 +6774,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodStreamed(26, + ::grpc::Service::MarkMethodStreamed(27, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasHybridCollection::StreamedHasHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HasHybridCollection() override { @@ -6615,7 +6794,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodStreamed(27, + ::grpc::Service::MarkMethodStreamed(28, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropHybridCollection::StreamedDropHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DropHybridCollection() override { @@ -6635,7 +6814,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodStreamed(28, + ::grpc::Service::MarkMethodStreamed(29, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>(std::bind(&WithStreamedUnaryMethod_DescribeHybridCollection::StreamedDescribeHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DescribeHybridCollection() override { @@ -6655,7 +6834,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodStreamed(29, + ::grpc::Service::MarkMethodStreamed(30, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountHybridCollection::StreamedCountHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_CountHybridCollection() override { @@ -6675,7 +6854,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodStreamed(30, + ::grpc::Service::MarkMethodStreamed(31, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollections::StreamedShowHybridCollections, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowHybridCollections() override { @@ -6695,7 +6874,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodStreamed(31, + ::grpc::Service::MarkMethodStreamed(32, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollectionInfo::StreamedShowHybridCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowHybridCollectionInfo() override { @@ -6715,7 +6894,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodStreamed(32, + ::grpc::Service::MarkMethodStreamed(33, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadHybridCollection::StreamedPreloadHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_PreloadHybridCollection() override { @@ -6735,7 +6914,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_InsertEntity() { - ::grpc::Service::MarkMethodStreamed(33, + ::grpc::Service::MarkMethodStreamed(34, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_InsertEntity::StreamedInsertEntity, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_InsertEntity() override { @@ -6755,7 +6934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HybridSearch() { - ::grpc::Service::MarkMethodStreamed(34, + ::grpc::Service::MarkMethodStreamed(35, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HybridSearch() override { @@ -6775,7 +6954,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodStreamed(35, + ::grpc::Service::MarkMethodStreamed(36, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearchInSegments::StreamedHybridSearchInSegments, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HybridSearchInSegments() override { @@ -6795,7 +6974,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetEntityByID() { - ::grpc::Service::MarkMethodStreamed(36, + ::grpc::Service::MarkMethodStreamed(37, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_GetEntityByID() override { @@ -6815,7 +6994,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodStreamed(37, + ::grpc::Service::MarkMethodStreamed(38, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_GetEntityIDs::StreamedGetEntityIDs, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_GetEntityIDs() override { @@ -6835,7 +7014,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodStreamed(38, + ::grpc::Service::MarkMethodStreamed(39, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DeleteEntitiesByID::StreamedDeleteEntitiesByID, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DeleteEntitiesByID() override { @@ -6849,9 +7028,9 @@ class MilvusService final { // replace default version of method with streamed unary virtual ::grpc::Status StreamedDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HDeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/core/src/grpc/gen-milvus/milvus.pb.cc b/core/src/grpc/gen-milvus/milvus.pb.cc index 289aea93bf..2339336b86 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.pb.cc @@ -82,6 +82,10 @@ class SearchByIDParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _SearchByIDParam_default_instance_; +class ReLoadSegmentsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ReLoadSegmentsParam_default_instance_; class TopKQueryResultDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -759,6 +763,20 @@ static void InitDefaultsscc_info_RangeQuery_milvus_2eproto() { &scc_info_CompareExpr_milvus_2eproto.base, &scc_info_KeyValuePair_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_ReLoadSegmentsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_ReLoadSegmentsParam_default_instance_; + new (ptr) ::milvus::grpc::ReLoadSegmentsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::ReLoadSegmentsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ReLoadSegmentsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_ReLoadSegmentsParam_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_RowRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -954,7 +972,7 @@ static void InitDefaultsscc_info_VectorsIdentity_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorsIdentity_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorsIdentity_milvus_2eproto}, {}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[48]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[49]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; @@ -1056,6 +1074,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, topk_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, extra_params_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, segment_id_array_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResult, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -1356,42 +1381,43 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 69, -1, sizeof(::milvus::grpc::SearchParam)}, { 79, -1, sizeof(::milvus::grpc::SearchInFilesParam)}, { 86, -1, sizeof(::milvus::grpc::SearchByIDParam)}, - { 96, -1, sizeof(::milvus::grpc::TopKQueryResult)}, - { 105, -1, sizeof(::milvus::grpc::StringReply)}, - { 112, -1, sizeof(::milvus::grpc::BoolReply)}, - { 119, -1, sizeof(::milvus::grpc::CollectionRowCount)}, - { 126, -1, sizeof(::milvus::grpc::Command)}, - { 132, -1, sizeof(::milvus::grpc::IndexParam)}, - { 141, -1, sizeof(::milvus::grpc::FlushParam)}, - { 147, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, - { 154, -1, sizeof(::milvus::grpc::CollectionInfo)}, - { 161, -1, sizeof(::milvus::grpc::VectorsIdentity)}, - { 168, -1, sizeof(::milvus::grpc::VectorsData)}, - { 175, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, - { 182, -1, sizeof(::milvus::grpc::VectorFieldParam)}, - { 188, -1, sizeof(::milvus::grpc::FieldType)}, - { 196, -1, sizeof(::milvus::grpc::FieldParam)}, - { 205, -1, sizeof(::milvus::grpc::VectorFieldValue)}, - { 211, -1, sizeof(::milvus::grpc::FieldValue)}, - { 224, -1, sizeof(::milvus::grpc::Mapping)}, - { 233, -1, sizeof(::milvus::grpc::MappingList)}, - { 240, -1, sizeof(::milvus::grpc::TermQuery)}, - { 250, -1, sizeof(::milvus::grpc::CompareExpr)}, - { 257, -1, sizeof(::milvus::grpc::RangeQuery)}, - { 266, -1, sizeof(::milvus::grpc::VectorQuery)}, - { 276, -1, sizeof(::milvus::grpc::BooleanQuery)}, - { 283, -1, sizeof(::milvus::grpc::GeneralQuery)}, - { 293, -1, sizeof(::milvus::grpc::HSearchParam)}, - { 302, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, - { 309, -1, sizeof(::milvus::grpc::AttrRecord)}, - { 315, -1, sizeof(::milvus::grpc::HEntity)}, - { 326, -1, sizeof(::milvus::grpc::HQueryResult)}, - { 336, -1, sizeof(::milvus::grpc::HInsertParam)}, - { 346, -1, sizeof(::milvus::grpc::HEntityIdentity)}, - { 353, -1, sizeof(::milvus::grpc::HEntityIDs)}, - { 360, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, - { 367, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, - { 374, -1, sizeof(::milvus::grpc::HIndexParam)}, + { 96, -1, sizeof(::milvus::grpc::ReLoadSegmentsParam)}, + { 103, -1, sizeof(::milvus::grpc::TopKQueryResult)}, + { 112, -1, sizeof(::milvus::grpc::StringReply)}, + { 119, -1, sizeof(::milvus::grpc::BoolReply)}, + { 126, -1, sizeof(::milvus::grpc::CollectionRowCount)}, + { 133, -1, sizeof(::milvus::grpc::Command)}, + { 139, -1, sizeof(::milvus::grpc::IndexParam)}, + { 148, -1, sizeof(::milvus::grpc::FlushParam)}, + { 154, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, + { 161, -1, sizeof(::milvus::grpc::CollectionInfo)}, + { 168, -1, sizeof(::milvus::grpc::VectorsIdentity)}, + { 175, -1, sizeof(::milvus::grpc::VectorsData)}, + { 182, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, + { 189, -1, sizeof(::milvus::grpc::VectorFieldParam)}, + { 195, -1, sizeof(::milvus::grpc::FieldType)}, + { 203, -1, sizeof(::milvus::grpc::FieldParam)}, + { 212, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 218, -1, sizeof(::milvus::grpc::FieldValue)}, + { 231, -1, sizeof(::milvus::grpc::Mapping)}, + { 240, -1, sizeof(::milvus::grpc::MappingList)}, + { 247, -1, sizeof(::milvus::grpc::TermQuery)}, + { 257, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 264, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 273, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 283, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 290, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 300, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 309, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 316, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 322, -1, sizeof(::milvus::grpc::HEntity)}, + { 333, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 343, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 353, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 360, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 367, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 374, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 381, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1407,6 +1433,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_SearchParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SearchInFilesParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SearchByIDParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_ReLoadSegmentsParam_default_instance_), reinterpret_cast(&::milvus::grpc::_TopKQueryResult_default_instance_), reinterpret_cast(&::milvus::grpc::_StringReply_default_instance_), reinterpret_cast(&::milvus::grpc::_BoolReply_default_instance_), @@ -1478,185 +1505,189 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "m\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_" "tag_array\030\002 \003(\t\022\020\n\010id_array\030\003 \003(\003\022\014\n\004top" "k\030\004 \001(\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.g" - "rpc.KeyValuePair\"g\n\017TopKQueryResult\022#\n\006s" - "tatus\030\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_" - "num\030\002 \001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(" - "\002\"H\n\013StringReply\022#\n\006status\030\001 \001(\0132\023.milvu" - "s.grpc.Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tB" - "oolReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.S" - "tatus\022\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionR" - "owCount\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" - "atus\022\034\n\024collection_row_count\030\002 \001(\003\"\026\n\007Co" - "mmand\022\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006sta" - "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017collec" - "tion_name\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014e" - "xtra_params\030\004 \003(\0132\031.milvus.grpc.KeyValue" - "Pair\"+\n\nFlushParam\022\035\n\025collection_name_ar" - "ray\030\001 \003(\t\"<\n\017DeleteByIDParam\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"H\n\016Colle" - "ctionInfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\021\n\tjson_info\030\002 \001(\t\"<\n\017VectorsIden" - "tity\022\027\n\017collection_name\030\001 \001(\t\022\020\n\010id_arra" - "y\030\002 \003(\003\"`\n\013VectorsData\022#\n\006status\030\001 \001(\0132\023" - ".milvus.grpc.Status\022,\n\014vectors_data\030\002 \003(" - "\0132\026.milvus.grpc.RowRecord\"B\n\021GetVectorID" - "sParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segme" - "nt_name\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n\tdim" - "ension\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_type\030\001" - " \001(\0162\025.milvus.grpc.DataTypeH\000\0225\n\014vector_" - "param\030\002 \001(\0132\035.milvus.grpc.VectorFieldPar" - "amH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022" - "\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grp" - "c.FieldType\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"9\n\020VectorFieldValue" - "\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord\"" - "\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n" - "\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(" - "\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014string_va" - "lue\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vec" - "tor_value\030\007 \001(\0132\035.milvus.grpc.VectorFiel" - "dValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030" - "\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollection" - "_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fi" - "elds\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013M" - "appingList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" - ".Status\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.g" - "rpc.Mapping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030" - "\001 \001(\t\022\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003" - "\022\r\n\005boost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031." - "milvus.grpc.KeyValuePair\"N\n\013CompareExpr\022" - ".\n\010operator\030\001 \001(\0162\034.milvus.grpc.CompareO" - "perator\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022" - "\022\n\nfield_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.m" - "ilvus.grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n" - "\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyVal" - "uePair\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001" - "(\t\022\023\n\013query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\013" - "2\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/" - "\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyVa" - "luePair\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022" - ".milvus.grpc.Occur\0220\n\rgeneral_query\030\002 \003(" - "\0132\031.milvus.grpc.GeneralQuery\"\333\001\n\014General" - "Query\0222\n\rboolean_query\030\001 \001(\0132\031.milvus.gr" - "pc.BooleanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026." - "milvus.grpc.TermQueryH\000\022.\n\013range_query\030\003" - " \001(\0132\027.milvus.grpc.RangeQueryH\000\0220\n\014vecto" - "r_query\030\004 \001(\0132\030.milvus.grpc.VectorQueryH" - "\000B\007\n\005query\"\247\001\n\014HSearchParam\022\027\n\017collectio" - "n_name\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(" - "\t\0220\n\rgeneral_query\030\003 \001(\0132\031.milvus.grpc.G" - "eneralQuery\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"c\n\026HSearchInSegment" - "sParam\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014sear" - "ch_param\030\002 \001(\0132\031.milvus.grpc.HSearchPara" - "m\"\033\n\nAttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEnti" - "ty\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\021\n\tentity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022" - "\024\n\014attr_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022." - "\n\rresult_values\030\006 \003(\0132\027.milvus.grpc.Fiel" - "dValue\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132" - "\023.milvus.grpc.Status\022&\n\010entities\030\002 \003(\0132\024" - ".milvus.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n" - "\005score\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInse" - "rtParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpart" - "ition_tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milv" - "us.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003(\003" - "\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Key" - "ValuePair\"6\n\017HEntityIdentity\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022" - "#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017" - "entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsPa" - "ram\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_" - "name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collec" - "tion_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HI" - "ndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex" - "_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004NUL" - "L\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005I" - "NT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022" - "\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n" - "\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020" - "\002\022\006\n\002GT\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007I" - "NVALID\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_N" - "OT\020\0032\324\026\n\rMilvusService\022H\n\020CreateCollecti" - "on\022\035.milvus.grpc.CollectionSchema\032\023.milv" - "us.grpc.Status\"\000\022F\n\rHasCollection\022\033.milv" - "us.grpc.CollectionName\032\026.milvus.grpc.Boo" - "lReply\"\000\022R\n\022DescribeCollection\022\033.milvus." - "grpc.CollectionName\032\035.milvus.grpc.Collec" - "tionSchema\"\000\022Q\n\017CountCollection\022\033.milvus" - ".grpc.CollectionName\032\037.milvus.grpc.Colle" - "ctionRowCount\"\000\022J\n\017ShowCollections\022\024.mil" - "vus.grpc.Command\032\037.milvus.grpc.Collectio" - "nNameList\"\000\022P\n\022ShowCollectionInfo\022\033.milv" - "us.grpc.CollectionName\032\033.milvus.grpc.Col" - "lectionInfo\"\000\022D\n\016DropCollection\022\033.milvus" - ".grpc.CollectionName\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexPa" - "ram\032\023.milvus.grpc.Status\"\000\022G\n\rDescribeIn" - "dex\022\033.milvus.grpc.CollectionName\032\027.milvu" - "s.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022E\n\017CreatePartition\022\033.milvus.grpc.Pa" - "rtitionParam\032\023.milvus.grpc.Status\"\000\022E\n\014H" - "asPartition\022\033.milvus.grpc.PartitionParam" - "\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPartit" - "ions\022\033.milvus.grpc.CollectionName\032\032.milv" - "us.grpc.PartitionList\"\000\022C\n\rDropPartition" - "\022\033.milvus.grpc.PartitionParam\032\023.milvus.g" - "rpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.Ins" - "ertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016Ge" - "tVectorsByID\022\034.milvus.grpc.VectorsIdenti" - "ty\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetVec" - "torIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026" - ".milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.mil" - "vus.grpc.SearchParam\032\034.milvus.grpc.TopKQ" - "ueryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc" - ".SearchByIDParam\032\034.milvus.grpc.TopKQuery" - "Result\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc." - "SearchInFilesParam\032\034.milvus.grpc.TopKQue" - "ryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032" - "\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteByI" - "D\022\034.milvus.grpc.DeleteByIDParam\032\023.milvus" - ".grpc.Status\"\000\022G\n\021PreloadCollection\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPara" - "m\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\022E\n\026CreateHybridCollection\022\024.milv" - "us.grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L" - "\n\023HasHybridCollection\022\033.milvus.grpc.Coll" - "ectionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024" - "DropHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\023.milvus.grpc.Status\"\000\022O\n\030Desc" - "ribeHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Cou" - "ntHybridCollection\022\033.milvus.grpc.Collect" - "ionName\032\037.milvus.grpc.CollectionRowCount" - "\"\000\022I\n\025ShowHybridCollections\022\024.milvus.grp" - "c.Command\032\030.milvus.grpc.MappingList\"\000\022V\n" - "\030ShowHybridCollectionInfo\022\033.milvus.grpc." - "CollectionName\032\033.milvus.grpc.CollectionI" - "nfo\"\000\022M\n\027PreloadHybridCollection\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInse" - "rtParam\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hy" - "bridSearch\022\031.milvus.grpc.HSearchParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\022]\n\026HybridS" - "earchInSegments\022#.milvus.grpc.HSearchInS" - "egmentsParam\032\034.milvus.grpc.TopKQueryResu" - "lt\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEnt" - "ityIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014G" - "etEntityIDs\022\037.milvus.grpc.HGetEntityIDsP" - "aram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delet" - "eEntitiesByID\022\035.milvus.grpc.HDeleteByIDP" - "aram\032\023.milvus.grpc.Status\"\000b\006proto3" + "rpc.KeyValuePair\"H\n\023ReLoadSegmentsParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\030\n\020segment_id_a" + "rray\030\002 \003(\t\"g\n\017TopKQueryResult\022#\n\006status\030" + "\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_num\030\002 " + "\001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013S" + "tringReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" + ".Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoolRep" + "ly\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" + "\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionRowCoun" + "t\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\034" + "\n\024collection_row_count\030\002 \001(\003\"\026\n\007Command\022" + "\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022\027\n\017collection_n" + "ame\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014extra_p" + "arams\030\004 \003(\0132\031.milvus.grpc.KeyValuePair\"+" + "\n\nFlushParam\022\035\n\025collection_name_array\030\001 " + "\003(\t\"<\n\017DeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"H\n\016CollectionI" + "nfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\021\n\tjson_info\030\002 \001(\t\"<\n\017VectorsIdentity\022\027" + "\n\017collection_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(" + "\003\"`\n\013VectorsData\022#\n\006status\030\001 \001(\0132\023.milvu" + "s.grpc.Status\022,\n\014vectors_data\030\002 \003(\0132\026.mi" + "lvus.grpc.RowRecord\"B\n\021GetVectorIDsParam" + "\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_nam" + "e\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n\tdimension" + "\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_type\030\001 \001(\0162\025" + ".milvus.grpc.DataTypeH\000\0225\n\014vector_param\030" + "\002 \001(\0132\035.milvus.grpc.VectorFieldParamH\000B\007" + "\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022\014\n\004nam" + "e\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grpc.Fiel" + "dType\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair\"9\n\020VectorFieldValue\022%\n\005va" + "lue\030\001 \003(\0132\026.milvus.grpc.RowRecord\"\327\001\n\nFi" + "eldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n\013int64" + "_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(\002H\000\022\026\n" + "\014double_value\030\004 \001(\001H\000\022\026\n\014string_value\030\005 " + "\001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vector_va" + "lue\030\007 \001(\0132\035.milvus.grpc.VectorFieldValue" + "H\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030\001 \001(\0132" + "\023.milvus.grpc.Status\022\025\n\rcollection_id\030\002 " + "\001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fields\030\004" + " \003(\0132\027.milvus.grpc.FieldParam\"^\n\013Mapping" + "List\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Statu" + "s\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.grpc.Ma" + "pping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030\001 \001(\t\022" + "\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003\022\r\n\005bo" + "ost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031.milvus" + ".grpc.KeyValuePair\"N\n\013CompareExpr\022.\n\010ope" + "rator\030\001 \001(\0162\034.milvus.grpc.CompareOperato" + "r\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfie" + "ld_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.milvus." + "grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra" + "_params\030\004 \003(\0132\031.milvus.grpc.KeyValuePair" + "\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013" + "query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\0132\026.mil" + "vus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extr" + "a_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022.milvu" + "s.grpc.Occur\0220\n\rgeneral_query\030\002 \003(\0132\031.mi" + "lvus.grpc.GeneralQuery\"\333\001\n\014GeneralQuery\022" + "2\n\rboolean_query\030\001 \001(\0132\031.milvus.grpc.Boo" + "leanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026.milvus" + ".grpc.TermQueryH\000\022.\n\013range_query\030\003 \001(\0132\027" + ".milvus.grpc.RangeQueryH\000\0220\n\014vector_quer" + "y\030\004 \001(\0132\030.milvus.grpc.VectorQueryH\000B\007\n\005q" + "uery\"\247\001\n\014HSearchParam\022\027\n\017collection_name" + "\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(\t\0220\n\rg" + "eneral_query\030\003 \001(\0132\031.milvus.grpc.General" + "Query\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair\"c\n\026HSearchInSegmentsParam" + "\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014search_par" + "am\030\002 \001(\0132\031.milvus.grpc.HSearchParam\"\033\n\nA" + "ttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEntity\022#\n\006" + "status\030\001 \001(\0132\023.milvus.grpc.Status\022\021\n\tent" + "ity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022\024\n\014att" + "r_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022.\n\rresu" + "lt_values\030\006 \003(\0132\027.milvus.grpc.FieldValue" + "\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.milv" + "us.grpc.Status\022&\n\010entities\030\002 \003(\0132\024.milvu" + "s.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005score" + "\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInsertPara" + "m\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpartition_" + "tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milvus.grp" + "c.HEntity\022\027\n\017entity_id_array\030\004 \003(\003\022/\n\014ex" + "tra_params\030\005 \003(\0132\031.milvus.grpc.KeyValueP" + "air\"6\n\017HEntityIdentity\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022#\n\006sta" + "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017entity" + "_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsParam\022\027\n" + "\017collection_name\030\001 \001(\t\022\024\n\014segment_name\030\002" + " \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collection_n" + "ame\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HIndexPa" + "ram\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex_type\030" + "\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair*\206\001\n\010DataType\022\010\n\004NULL\020\000\022\010\n" + "\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT64\020\004" + "\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022\n\n\006DOU" + "BLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n\017Compa" + "reOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002G" + "T\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID" + "\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\0032\237" + "\027\n\rMilvusService\022H\n\020CreateCollection\022\035.m" + "ilvus.grpc.CollectionSchema\032\023.milvus.grp" + "c.Status\"\000\022F\n\rHasCollection\022\033.milvus.grp" + "c.CollectionName\032\026.milvus.grpc.BoolReply" + "\"\000\022R\n\022DescribeCollection\022\033.milvus.grpc.C" + "ollectionName\032\035.milvus.grpc.CollectionSc" + "hema\"\000\022Q\n\017CountCollection\022\033.milvus.grpc." + "CollectionName\032\037.milvus.grpc.CollectionR" + "owCount\"\000\022J\n\017ShowCollections\022\024.milvus.gr" + "pc.Command\032\037.milvus.grpc.CollectionNameL" + "ist\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.grp" + "c.CollectionName\032\033.milvus.grpc.Collectio" + "nInfo\"\000\022D\n\016DropCollection\022\033.milvus.grpc." + "CollectionName\032\023.milvus.grpc.Status\"\000\022=\n" + "\013CreateIndex\022\027.milvus.grpc.IndexParam\032\023." + "milvus.grpc.Status\"\000\022G\n\rDescribeIndex\022\033." + "milvus.grpc.CollectionName\032\027.milvus.grpc" + ".IndexParam\"\000\022\?\n\tDropIndex\022\033.milvus.grpc" + ".CollectionName\032\023.milvus.grpc.Status\"\000\022E" + "\n\017CreatePartition\022\033.milvus.grpc.Partitio" + "nParam\032\023.milvus.grpc.Status\"\000\022E\n\014HasPart" + "ition\022\033.milvus.grpc.PartitionParam\032\026.mil" + "vus.grpc.BoolReply\"\000\022K\n\016ShowPartitions\022\033" + ".milvus.grpc.CollectionName\032\032.milvus.grp" + "c.PartitionList\"\000\022C\n\rDropPartition\022\033.mil" + "vus.grpc.PartitionParam\032\023.milvus.grpc.St" + "atus\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertPar" + "am\032\026.milvus.grpc.VectorIds\"\000\022J\n\016GetVecto" + "rsByID\022\034.milvus.grpc.VectorsIdentity\032\030.m" + "ilvus.grpc.VectorsData\"\000\022H\n\014GetVectorIDs" + "\022\036.milvus.grpc.GetVectorIDsParam\032\026.milvu" + "s.grpc.VectorIds\"\000\022B\n\006Search\022\030.milvus.gr" + "pc.SearchParam\032\034.milvus.grpc.TopKQueryRe" + "sult\"\000\022J\n\nSearchByID\022\034.milvus.grpc.Searc" + "hByIDParam\032\034.milvus.grpc.TopKQueryResult" + "\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc.Search" + "InFilesParam\032\034.milvus.grpc.TopKQueryResu" + "lt\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032\030.milv" + "us.grpc.StringReply\"\000\022A\n\nDeleteByID\022\034.mi" + "lvus.grpc.DeleteByIDParam\032\023.milvus.grpc." + "Status\"\000\022G\n\021PreloadCollection\022\033.milvus.g" + "rpc.CollectionName\032\023.milvus.grpc.Status\"" + "\000\022I\n\016ReloadSegments\022 .milvus.grpc.ReLoad" + "SegmentsParam\032\023.milvus.grpc.Status\"\000\0227\n\005" + "Flush\022\027.milvus.grpc.FlushParam\032\023.milvus." + "grpc.Status\"\000\022=\n\007Compact\022\033.milvus.grpc.C" + "ollectionName\032\023.milvus.grpc.Status\"\000\022E\n\026" + "CreateHybridCollection\022\024.milvus.grpc.Map" + "ping\032\023.milvus.grpc.Status\"\000\022L\n\023HasHybrid" + "Collection\022\033.milvus.grpc.CollectionName\032" + "\026.milvus.grpc.BoolReply\"\000\022J\n\024DropHybridC" + "ollection\022\033.milvus.grpc.CollectionName\032\023" + ".milvus.grpc.Status\"\000\022O\n\030DescribeHybridC" + "ollection\022\033.milvus.grpc.CollectionName\032\024" + ".milvus.grpc.Mapping\"\000\022W\n\025CountHybridCol" + "lection\022\033.milvus.grpc.CollectionName\032\037.m" + "ilvus.grpc.CollectionRowCount\"\000\022I\n\025ShowH" + "ybridCollections\022\024.milvus.grpc.Command\032\030" + ".milvus.grpc.MappingList\"\000\022V\n\030ShowHybrid" + "CollectionInfo\022\033.milvus.grpc.CollectionN" + "ame\032\033.milvus.grpc.CollectionInfo\"\000\022M\n\027Pr" + "eloadHybridCollection\022\033.milvus.grpc.Coll" + "ectionName\032\023.milvus.grpc.Status\"\000\022D\n\014Ins" + "ertEntity\022\031.milvus.grpc.HInsertParam\032\027.m" + "ilvus.grpc.HEntityIDs\"\000\022I\n\014HybridSearch\022" + "\031.milvus.grpc.HSearchParam\032\034.milvus.grpc" + ".TopKQueryResult\"\000\022]\n\026HybridSearchInSegm" + "ents\022#.milvus.grpc.HSearchInSegmentsPara" + "m\032\034.milvus.grpc.TopKQueryResult\"\000\022E\n\rGet" + "EntityByID\022\034.milvus.grpc.HEntityIdentity" + "\032\024.milvus.grpc.HEntity\"\000\022J\n\014GetEntityIDs" + "\022\037.milvus.grpc.HGetEntityIDsParam\032\027.milv" + "us.grpc.HEntityIDs\"\000\022J\n\022DeleteEntitiesBy" + "ID\022\035.milvus.grpc.HDeleteByIDParam\032\023.milv" + "us.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[47] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[48] = { &scc_info_AttrRecord_milvus_2eproto.base, &scc_info_BoolReply_milvus_2eproto.base, &scc_info_BooleanQuery_milvus_2eproto.base, @@ -1691,6 +1722,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_PartitionList_milvus_2eproto.base, &scc_info_PartitionParam_milvus_2eproto.base, &scc_info_RangeQuery_milvus_2eproto.base, + &scc_info_ReLoadSegmentsParam_milvus_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base, &scc_info_SearchByIDParam_milvus_2eproto.base, &scc_info_SearchInFilesParam_milvus_2eproto.base, @@ -1708,10 +1740,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8235, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 47, 1, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8384, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 48, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 48, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 49, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -6376,6 +6408,335 @@ void SearchByIDParam::InternalSwap(SearchByIDParam* other) { } +// =================================================================== + +void ReLoadSegmentsParam::InitAsDefaultInstance() { +} +class ReLoadSegmentsParam::_Internal { + public: +}; + +ReLoadSegmentsParam::ReLoadSegmentsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.ReLoadSegmentsParam) +} +ReLoadSegmentsParam::ReLoadSegmentsParam(const ReLoadSegmentsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_id_array_(from.segment_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.ReLoadSegmentsParam) +} + +void ReLoadSegmentsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ReLoadSegmentsParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ReLoadSegmentsParam::~ReLoadSegmentsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.ReLoadSegmentsParam) + SharedDtor(); +} + +void ReLoadSegmentsParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ReLoadSegmentsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ReLoadSegmentsParam& ReLoadSegmentsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ReLoadSegmentsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void ReLoadSegmentsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_id_array_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* ReLoadSegmentsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.ReLoadSegmentsParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string segment_id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_segment_id_array(), ptr, ctx, "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool ReLoadSegmentsParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.ReLoadSegmentsParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.ReLoadSegmentsParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string segment_id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_segment_id_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(this->segment_id_array_size() - 1).data(), + static_cast(this->segment_id_array(this->segment_id_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.ReLoadSegmentsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.ReLoadSegmentsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void ReLoadSegmentsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated string segment_id_array = 2; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->segment_id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.ReLoadSegmentsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReLoadSegmentsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated string segment_id_array = 2; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->segment_id_array(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.ReLoadSegmentsParam) + return target; +} + +size_t ReLoadSegmentsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.ReLoadSegmentsParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string segment_id_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->segment_id_array_size()); + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_id_array(i)); + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReLoadSegmentsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.ReLoadSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + const ReLoadSegmentsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.ReLoadSegmentsParam) + MergeFrom(*source); + } +} + +void ReLoadSegmentsParam::MergeFrom(const ReLoadSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.ReLoadSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_id_array_.MergeFrom(from.segment_id_array_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void ReLoadSegmentsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.ReLoadSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReLoadSegmentsParam::CopyFrom(const ReLoadSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.ReLoadSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReLoadSegmentsParam::IsInitialized() const { + return true; +} + +void ReLoadSegmentsParam::InternalSwap(ReLoadSegmentsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_id_array_.InternalSwap(CastToBase(&other->segment_id_array_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReLoadSegmentsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void TopKQueryResult::InitAsDefaultInstance() { @@ -20011,6 +20372,9 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchInFilesParam* Arena::CreateMa template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchByIDParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::SearchByIDParam >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::grpc::ReLoadSegmentsParam* Arena::CreateMaybeMessage< ::milvus::grpc::ReLoadSegmentsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::ReLoadSegmentsParam >(arena); +} template<> PROTOBUF_NOINLINE ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::TopKQueryResult >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::TopKQueryResult >(arena); } diff --git a/core/src/grpc/gen-milvus/milvus.pb.h b/core/src/grpc/gen-milvus/milvus.pb.h index f9c74151a4..76ff7b9402 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.h +++ b/core/src/grpc/gen-milvus/milvus.pb.h @@ -49,7 +49,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[48] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[49] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -163,6 +163,9 @@ extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_; class RangeQuery; class RangeQueryDefaultTypeInternal; extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_; +class ReLoadSegmentsParam; +class ReLoadSegmentsParamDefaultTypeInternal; +extern ReLoadSegmentsParamDefaultTypeInternal _ReLoadSegmentsParam_default_instance_; class RowRecord; class RowRecordDefaultTypeInternal; extern RowRecordDefaultTypeInternal _RowRecord_default_instance_; @@ -240,6 +243,7 @@ template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*); template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*); template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*); +template<> ::milvus::grpc::ReLoadSegmentsParam* Arena::CreateMaybeMessage<::milvus::grpc::ReLoadSegmentsParam>(Arena*); template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*); template<> ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchByIDParam>(Arena*); template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*); @@ -2294,6 +2298,162 @@ class SearchByIDParam : }; // ------------------------------------------------------------------- +class ReLoadSegmentsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.ReLoadSegmentsParam) */ { + public: + ReLoadSegmentsParam(); + virtual ~ReLoadSegmentsParam(); + + ReLoadSegmentsParam(const ReLoadSegmentsParam& from); + ReLoadSegmentsParam(ReLoadSegmentsParam&& from) noexcept + : ReLoadSegmentsParam() { + *this = ::std::move(from); + } + + inline ReLoadSegmentsParam& operator=(const ReLoadSegmentsParam& from) { + CopyFrom(from); + return *this; + } + inline ReLoadSegmentsParam& operator=(ReLoadSegmentsParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ReLoadSegmentsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ReLoadSegmentsParam* internal_default_instance() { + return reinterpret_cast( + &_ReLoadSegmentsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ReLoadSegmentsParam& a, ReLoadSegmentsParam& b) { + a.Swap(&b); + } + inline void Swap(ReLoadSegmentsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReLoadSegmentsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReLoadSegmentsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReLoadSegmentsParam& from); + void MergeFrom(const ReLoadSegmentsParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReLoadSegmentsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.ReLoadSegmentsParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdArrayFieldNumber = 2, + kCollectionNameFieldNumber = 1, + }; + // repeated string segment_id_array = 2; + int segment_id_array_size() const; + void clear_segment_id_array(); + const std::string& segment_id_array(int index) const; + std::string* mutable_segment_id_array(int index); + void set_segment_id_array(int index, const std::string& value); + void set_segment_id_array(int index, std::string&& value); + void set_segment_id_array(int index, const char* value); + void set_segment_id_array(int index, const char* value, size_t size); + std::string* add_segment_id_array(); + void add_segment_id_array(const std::string& value); + void add_segment_id_array(std::string&& value); + void add_segment_id_array(const char* value); + void add_segment_id_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& segment_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_segment_id_array(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.ReLoadSegmentsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField segment_id_array_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + class TopKQueryResult : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResult) */ { public: @@ -2336,7 +2496,7 @@ class TopKQueryResult : &_TopKQueryResult_default_instance_); } static constexpr int kIndexInFileMessages = - 12; + 13; friend void swap(TopKQueryResult& a, TopKQueryResult& b) { a.Swap(&b); @@ -2505,7 +2665,7 @@ class StringReply : &_StringReply_default_instance_); } static constexpr int kIndexInFileMessages = - 13; + 14; friend void swap(StringReply& a, StringReply& b) { a.Swap(&b); @@ -2652,7 +2812,7 @@ class BoolReply : &_BoolReply_default_instance_); } static constexpr int kIndexInFileMessages = - 14; + 15; friend void swap(BoolReply& a, BoolReply& b) { a.Swap(&b); @@ -2793,7 +2953,7 @@ class CollectionRowCount : &_CollectionRowCount_default_instance_); } static constexpr int kIndexInFileMessages = - 15; + 16; friend void swap(CollectionRowCount& a, CollectionRowCount& b) { a.Swap(&b); @@ -2934,7 +3094,7 @@ class Command : &_Command_default_instance_); } static constexpr int kIndexInFileMessages = - 16; + 17; friend void swap(Command& a, Command& b) { a.Swap(&b); @@ -3071,7 +3231,7 @@ class IndexParam : &_IndexParam_default_instance_); } static constexpr int kIndexInFileMessages = - 17; + 18; friend void swap(IndexParam& a, IndexParam& b) { a.Swap(&b); @@ -3238,7 +3398,7 @@ class FlushParam : &_FlushParam_default_instance_); } static constexpr int kIndexInFileMessages = - 18; + 19; friend void swap(FlushParam& a, FlushParam& b) { a.Swap(&b); @@ -3381,7 +3541,7 @@ class DeleteByIDParam : &_DeleteByIDParam_default_instance_); } static constexpr int kIndexInFileMessages = - 19; + 20; friend void swap(DeleteByIDParam& a, DeleteByIDParam& b) { a.Swap(&b); @@ -3532,7 +3692,7 @@ class CollectionInfo : &_CollectionInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 20; + 21; friend void swap(CollectionInfo& a, CollectionInfo& b) { a.Swap(&b); @@ -3679,7 +3839,7 @@ class VectorsIdentity : &_VectorsIdentity_default_instance_); } static constexpr int kIndexInFileMessages = - 21; + 22; friend void swap(VectorsIdentity& a, VectorsIdentity& b) { a.Swap(&b); @@ -3830,7 +3990,7 @@ class VectorsData : &_VectorsData_default_instance_); } static constexpr int kIndexInFileMessages = - 22; + 23; friend void swap(VectorsData& a, VectorsData& b) { a.Swap(&b); @@ -3977,7 +4137,7 @@ class GetVectorIDsParam : &_GetVectorIDsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 24; friend void swap(GetVectorIDsParam& a, GetVectorIDsParam& b) { a.Swap(&b); @@ -4127,7 +4287,7 @@ class VectorFieldParam : &_VectorFieldParam_default_instance_); } static constexpr int kIndexInFileMessages = - 24; + 25; friend void swap(VectorFieldParam& a, VectorFieldParam& b) { a.Swap(&b); @@ -4264,7 +4424,7 @@ class FieldType : &_FieldType_default_instance_); } static constexpr int kIndexInFileMessages = - 25; + 26; friend void swap(FieldType& a, FieldType& b) { a.Swap(&b); @@ -4420,7 +4580,7 @@ class FieldParam : &_FieldParam_default_instance_); } static constexpr int kIndexInFileMessages = - 26; + 27; friend void swap(FieldParam& a, FieldParam& b) { a.Swap(&b); @@ -4587,7 +4747,7 @@ class VectorFieldValue : &_VectorFieldValue_default_instance_); } static constexpr int kIndexInFileMessages = - 27; + 28; friend void swap(VectorFieldValue& a, VectorFieldValue& b) { a.Swap(&b); @@ -4735,7 +4895,7 @@ class FieldValue : &_FieldValue_default_instance_); } static constexpr int kIndexInFileMessages = - 28; + 29; friend void swap(FieldValue& a, FieldValue& b) { a.Swap(&b); @@ -4952,7 +5112,7 @@ class Mapping : &_Mapping_default_instance_); } static constexpr int kIndexInFileMessages = - 29; + 30; friend void swap(Mapping& a, Mapping& b) { a.Swap(&b); @@ -5119,7 +5279,7 @@ class MappingList : &_MappingList_default_instance_); } static constexpr int kIndexInFileMessages = - 30; + 31; friend void swap(MappingList& a, MappingList& b) { a.Swap(&b); @@ -5266,7 +5426,7 @@ class TermQuery : &_TermQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 31; + 32; friend void swap(TermQuery& a, TermQuery& b) { a.Swap(&b); @@ -5443,7 +5603,7 @@ class CompareExpr : &_CompareExpr_default_instance_); } static constexpr int kIndexInFileMessages = - 32; + 33; friend void swap(CompareExpr& a, CompareExpr& b) { a.Swap(&b); @@ -5587,7 +5747,7 @@ class RangeQuery : &_RangeQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 33; + 34; friend void swap(RangeQuery& a, RangeQuery& b) { a.Swap(&b); @@ -5757,7 +5917,7 @@ class VectorQuery : &_VectorQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 34; + 35; friend void swap(VectorQuery& a, VectorQuery& b) { a.Swap(&b); @@ -5934,7 +6094,7 @@ class BooleanQuery : &_BooleanQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 35; + 36; friend void swap(BooleanQuery& a, BooleanQuery& b) { a.Swap(&b); @@ -6086,7 +6246,7 @@ class GeneralQuery : &_GeneralQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 36; + 37; friend void swap(GeneralQuery& a, GeneralQuery& b) { a.Swap(&b); @@ -6264,7 +6424,7 @@ class HSearchParam : &_HSearchParam_default_instance_); } static constexpr int kIndexInFileMessages = - 37; + 38; friend void swap(HSearchParam& a, HSearchParam& b) { a.Swap(&b); @@ -6443,7 +6603,7 @@ class HSearchInSegmentsParam : &_HSearchInSegmentsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 38; + 39; friend void swap(HSearchInSegmentsParam& a, HSearchInSegmentsParam& b) { a.Swap(&b); @@ -6596,7 +6756,7 @@ class AttrRecord : &_AttrRecord_default_instance_); } static constexpr int kIndexInFileMessages = - 39; + 40; friend void swap(AttrRecord& a, AttrRecord& b) { a.Swap(&b); @@ -6739,7 +6899,7 @@ class HEntity : &_HEntity_default_instance_); } static constexpr int kIndexInFileMessages = - 40; + 41; friend void swap(HEntity& a, HEntity& b) { a.Swap(&b); @@ -6932,7 +7092,7 @@ class HQueryResult : &_HQueryResult_default_instance_); } static constexpr int kIndexInFileMessages = - 41; + 42; friend void swap(HQueryResult& a, HQueryResult& b) { a.Swap(&b); @@ -7114,7 +7274,7 @@ class HInsertParam : &_HInsertParam_default_instance_); } static constexpr int kIndexInFileMessages = - 42; + 43; friend void swap(HInsertParam& a, HInsertParam& b) { a.Swap(&b); @@ -7301,7 +7461,7 @@ class HEntityIdentity : &_HEntityIdentity_default_instance_); } static constexpr int kIndexInFileMessages = - 43; + 44; friend void swap(HEntityIdentity& a, HEntityIdentity& b) { a.Swap(&b); @@ -7445,7 +7605,7 @@ class HEntityIDs : &_HEntityIDs_default_instance_); } static constexpr int kIndexInFileMessages = - 44; + 45; friend void swap(HEntityIDs& a, HEntityIDs& b) { a.Swap(&b); @@ -7593,7 +7753,7 @@ class HGetEntityIDsParam : &_HGetEntityIDsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 45; + 46; friend void swap(HGetEntityIDsParam& a, HGetEntityIDsParam& b) { a.Swap(&b); @@ -7743,7 +7903,7 @@ class HDeleteByIDParam : &_HDeleteByIDParam_default_instance_); } static constexpr int kIndexInFileMessages = - 46; + 47; friend void swap(HDeleteByIDParam& a, HDeleteByIDParam& b) { a.Swap(&b); @@ -7894,7 +8054,7 @@ class HIndexParam : &_HIndexParam_default_instance_); } static constexpr int kIndexInFileMessages = - 47; + 48; friend void swap(HIndexParam& a, HIndexParam& b) { a.Swap(&b); @@ -9561,6 +9721,126 @@ SearchByIDParam::extra_params() const { // ------------------------------------------------------------------- +// ReLoadSegmentsParam + +// string collection_name = 1; +inline void ReLoadSegmentsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& ReLoadSegmentsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.ReLoadSegmentsParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void ReLoadSegmentsParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline std::string* ReLoadSegmentsParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.ReLoadSegmentsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ReLoadSegmentsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.ReLoadSegmentsParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReLoadSegmentsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.ReLoadSegmentsParam.collection_name) +} + +// repeated string segment_id_array = 2; +inline int ReLoadSegmentsParam::segment_id_array_size() const { + return segment_id_array_.size(); +} +inline void ReLoadSegmentsParam::clear_segment_id_array() { + segment_id_array_.Clear(); +} +inline const std::string& ReLoadSegmentsParam::segment_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Get(index); +} +inline std::string* ReLoadSegmentsParam::mutable_segment_id_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Mutable(index); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(value); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(std::move(value)); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const char* value, size_t size) { + segment_id_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline std::string* ReLoadSegmentsParam::add_segment_id_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Add(); +} +inline void ReLoadSegmentsParam::add_segment_id_array(const std::string& value) { + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(std::string&& value) { + segment_id_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(const char* value, size_t size) { + segment_id_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ReLoadSegmentsParam::segment_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ReLoadSegmentsParam::mutable_segment_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return &segment_id_array_; +} + +// ------------------------------------------------------------------- + // TopKQueryResult // .milvus.grpc.Status status = 1; @@ -13721,6 +14001,8 @@ HIndexParam::extra_params() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/core/src/grpc/milvus.proto b/core/src/grpc/milvus.proto index 12630803d8..b818171096 100644 --- a/core/src/grpc/milvus.proto +++ b/core/src/grpc/milvus.proto @@ -113,6 +113,14 @@ message SearchByIDParam { repeated KeyValuePair extra_params = 5; } +/** + * @brief Params for reloading segments + */ +message ReLoadSegmentsParam { + string collection_name = 1; + repeated string segment_id_array = 2; +} + /** * @brief Query result params */ @@ -624,6 +632,15 @@ service MilvusService { */ rpc PreloadCollection(CollectionName) returns (Status) {} + /** + * @brief This method is used to reload collection segments + * + * @param ReLoadSegmentsParam, target segments information. + * + * @return Status + */ + rpc ReloadSegments(ReLoadSegmentsParam) returns (Status) {} + /** * @brief This method is used to flush buffer into storage. * diff --git a/core/src/scheduler/task/SearchTask.cpp b/core/src/scheduler/task/SearchTask.cpp index 595dca40ae..f70fd65dff 100644 --- a/core/src/scheduler/task/SearchTask.cpp +++ b/core/src/scheduler/task/SearchTask.cpp @@ -183,10 +183,10 @@ XSearchTask::Load(LoadType type, uint8_t device_id) { if (!stat.ok()) { Status s; if (stat.ToString().find("out of memory") != std::string::npos) { - error_msg = "out of memory: " + type_str; + error_msg = "out of memory: " + type_str + " : " + stat.message(); s = Status(SERVER_OUT_OF_MEMORY, error_msg); } else { - error_msg = "Failed to load index file: " + type_str; + error_msg = "Failed to load index file: " + type_str + " : " + stat.message(); s = Status(SERVER_UNEXPECTED_ERROR, error_msg); } diff --git a/core/src/server/delivery/RequestHandler.cpp b/core/src/server/delivery/RequestHandler.cpp index 9086c66c95..5a69148391 100644 --- a/core/src/server/delivery/RequestHandler.cpp +++ b/core/src/server/delivery/RequestHandler.cpp @@ -34,6 +34,7 @@ #include "server/delivery/request/HasPartitionRequest.h" #include "server/delivery/request/InsertRequest.h" #include "server/delivery/request/PreloadCollectionRequest.h" +#include "server/delivery/request/ReLoadSegmentsRequest.h" #include "server/delivery/request/SearchByIDRequest.h" #include "server/delivery/request/SearchRequest.h" #include "server/delivery/request/ShowCollectionInfoRequest.h" @@ -194,6 +195,15 @@ RequestHandler::PreloadCollection(const std::shared_ptr& context, const return request_ptr->status(); } +Status +RequestHandler::ReLoadSegments(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& segment_ids) { + BaseRequestPtr request_ptr = ReLoadSegmentsRequest::Create(context, collection_name, segment_ids); + RequestScheduler::ExecRequest(request_ptr); + + return request_ptr->status(); +} + Status RequestHandler::DescribeIndex(const std::shared_ptr& context, const std::string& collection_name, IndexParam& param) { diff --git a/core/src/server/delivery/RequestHandler.h b/core/src/server/delivery/RequestHandler.h index 8024189dc5..d1795b2aa6 100644 --- a/core/src/server/delivery/RequestHandler.h +++ b/core/src/server/delivery/RequestHandler.h @@ -90,6 +90,10 @@ class RequestHandler { Status PreloadCollection(const std::shared_ptr& context, const std::string& collection_name); + Status + ReLoadSegments(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& segment_ids); + Status DescribeIndex(const std::shared_ptr& context, const std::string& collection_name, IndexParam& param); diff --git a/core/src/server/delivery/request/BaseRequest.cpp b/core/src/server/delivery/request/BaseRequest.cpp index 558d8e3049..65ebc05502 100644 --- a/core/src/server/delivery/request/BaseRequest.cpp +++ b/core/src/server/delivery/request/BaseRequest.cpp @@ -52,6 +52,7 @@ RequestGroup(BaseRequest::RequestType type) { {BaseRequest::kPreloadCollection, DQL_REQUEST_GROUP}, {BaseRequest::kCreateHybridCollection, DDL_DML_REQUEST_GROUP}, {BaseRequest::kDescribeHybridCollection, INFO_REQUEST_GROUP}, + {BaseRequest::kReloadSegments, DQL_REQUEST_GROUP}, // partition operations {BaseRequest::kCreatePartition, DDL_DML_REQUEST_GROUP}, diff --git a/core/src/server/delivery/request/BaseRequest.h b/core/src/server/delivery/request/BaseRequest.h index 8a629942e3..7def31950e 100644 --- a/core/src/server/delivery/request/BaseRequest.h +++ b/core/src/server/delivery/request/BaseRequest.h @@ -131,6 +131,7 @@ class BaseRequest { kCreateHybridCollection, kHasHybridCollection, kDescribeHybridCollection, + kReloadSegments, // partition operations kCreatePartition = 400, diff --git a/core/src/server/delivery/request/ReLoadSegmentsRequest.cpp b/core/src/server/delivery/request/ReLoadSegmentsRequest.cpp new file mode 100644 index 0000000000..fe3250c7a7 --- /dev/null +++ b/core/src/server/delivery/request/ReLoadSegmentsRequest.cpp @@ -0,0 +1,74 @@ +// 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/ReLoadSegmentsRequest.h" + +#include "config/Config.h" +#include "server/DBWrapper.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +namespace milvus { +namespace server { + +ReLoadSegmentsRequest::ReLoadSegmentsRequest(const std::shared_ptr& context, + const std::string& collection_name, + const std::vector& segment_ids) + : BaseRequest(context, BaseRequest::kReloadSegments), collection_name_(collection_name), segment_ids_(segment_ids) { +} + +BaseRequestPtr +ReLoadSegmentsRequest::Create(const std::shared_ptr& context, + const std::string& collection_name, const std::vector& segment_ids) { + return std::shared_ptr(new ReLoadSegmentsRequest(context, collection_name, segment_ids)); +} + +Status +ReLoadSegmentsRequest::OnExecute() { + auto& config = Config::GetInstance(); + + std::string deploy_mode; + auto status = config.GetServerConfigDeployMode(deploy_mode); + if (!status.ok()) { + return status; + } + + if (deploy_mode == "single" || deploy_mode == "cluster_writable") { + // TODO: No need to reload segment files + return Status(SERVER_SUCCESS, ""); + } + + try { + std::string hdr = "ReloadSegmentsRequest(collection=" + collection_name_ + ")"; + TimeRecorderAuto rc(hdr); + + // step 1: check arguments + auto status = ValidationUtil::ValidateCollectionName(collection_name_); + if (!status.ok()) { + return status; + } + + std::vector segment_ids; + for (auto& id : segment_ids_) { + std::string::size_type sz; + segment_ids.push_back(std::stoul(id, &sz)); + } + + return DBWrapper::DB()->ReLoadSegmentsDeletedDocs(collection_name_, segment_ids); + } catch (std::exception& exp) { + return Status(SERVER_UNEXPECTED_ERROR, exp.what()); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/request/ReLoadSegmentsRequest.h b/core/src/server/delivery/request/ReLoadSegmentsRequest.h new file mode 100644 index 0000000000..77a18a2393 --- /dev/null +++ b/core/src/server/delivery/request/ReLoadSegmentsRequest.h @@ -0,0 +1,42 @@ +// 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 +#include +#include + +#include "server/delivery/request/BaseRequest.h" + +namespace milvus { +namespace server { + +class ReLoadSegmentsRequest : public BaseRequest { + public: + static BaseRequestPtr + Create(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& segment_ids); + + protected: + ReLoadSegmentsRequest(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& segment_ids); + + Status + OnExecute() override; + + private: + const std::string collection_name_; + const std::vector segment_ids_; +}; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.cpp b/core/src/server/grpc_impl/GrpcRequestHandler.cpp index 580087ae0d..d8a019c0d5 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/core/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -757,6 +757,25 @@ GrpcRequestHandler::PreloadCollection(::grpc::ServerContext* context, const ::mi return ::grpc::Status::OK; } +::grpc::Status +GrpcRequestHandler::ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, + ::milvus::grpc::Status* response) { + CHECK_NULLPTR_RETURN(request); + LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->RequestID().c_str(), __func__); + + std::vector file_ids; + for (size_t i = 0; i < request->segment_id_array_size(); i++) { + file_ids.push_back(request->segment_id_array(i)); + } + + Status status = request_handler_.ReLoadSegments(GetContext(context), request->collection_name(), file_ids); + + LOG_SERVER_INFO_ << LogOut("Request [%s] %s end.", GetContext(context)->RequestID().c_str(), __func__); + SET_RESPONSE(response, status, context); + + return ::grpc::Status::OK; +} + ::grpc::Status GrpcRequestHandler::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response) { diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.h b/core/src/server/grpc_impl/GrpcRequestHandler.h index 5f47a3d72a..2b8364d73c 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.h +++ b/core/src/server/grpc_impl/GrpcRequestHandler.h @@ -297,6 +297,11 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) override; + // * + ::grpc::Status + ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, + ::milvus::grpc::Status* response) override; + // * // @brief This method is used to flush buffer into storage. // diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc index 297564670f..81b5a99b98 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc @@ -43,6 +43,7 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/Cmd", "/milvus.grpc.MilvusService/DeleteByID", "/milvus.grpc.MilvusService/PreloadCollection", + "/milvus.grpc.MilvusService/ReloadSegments", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", "/milvus.grpc.MilvusService/CreateHybridCollection", @@ -91,22 +92,23 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_Cmd_(MilvusService_method_names[20], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DeleteByID_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_PreloadCollection_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_Flush_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_Compact_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CreateHybridCollection_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HasHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DropHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CountHybridCollection_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowHybridCollections_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_InsertEntity_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HybridSearch_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_GetEntityByID_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_GetEntityIDs_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ReloadSegments_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Flush_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Compact_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CreateHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountHybridCollection_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollections_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_InsertEntity_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearch_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityByID_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityIDs_(MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[39], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { @@ -753,6 +755,34 @@ void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientCo return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, false); } +::grpc::Status MilvusService::Stub::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ReloadSegments_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ReloadSegments_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_ReloadSegments_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_ReloadSegments_, context, request, false); +} + ::grpc::Status MilvusService::Stub::Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Flush_, context, request, response); } @@ -1320,80 +1350,85 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::ReloadSegments), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[24], + ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::FlushParam, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Flush), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[24], + MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[25], + MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Mapping, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::CreateHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[26], + MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( std::mem_fn(&MilvusService::Service::HasHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[27], + MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DropHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[28], + MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( std::mem_fn(&MilvusService::Service::DescribeHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[29], + MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( std::mem_fn(&MilvusService::Service::CountHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[30], + MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::MappingList>( std::mem_fn(&MilvusService::Service::ShowHybridCollections), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[31], + MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( std::mem_fn(&MilvusService::Service::ShowHybridCollectionInfo), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[32], + MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::PreloadHybridCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[33], + MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( std::mem_fn(&MilvusService::Service::InsertEntity), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[34], + MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearch), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[35], + MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearchInSegments), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[36], + MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( std::mem_fn(&MilvusService::Service::GetEntityByID), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[37], + MilvusService_method_names[38], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( std::mem_fn(&MilvusService::Service::GetEntityIDs), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( - MilvusService_method_names[38], + MilvusService_method_names[39], ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DeleteEntitiesByID), this))); @@ -1563,6 +1598,13 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } +::grpc::Status MilvusService::Service::ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + ::grpc::Status MilvusService::Service::Flush(::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response) { (void) context; (void) request; diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h index 969758d750..96bc956102 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h @@ -347,6 +347,19 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual ::grpc::Status ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncReloadSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncReloadSegmentsRaw(context, request, cq)); + } + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -717,6 +730,16 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -854,6 +877,8 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; @@ -1051,6 +1076,13 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } + ::grpc::Status ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncReloadSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncReloadSegmentsRaw(context, request, cq)); + } ::grpc::Status Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncFlushRaw(context, request, cq)); @@ -1258,6 +1290,10 @@ class MilvusService final { void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, std::function) override; + void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void ReloadSegments(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ReloadSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; @@ -1379,6 +1415,8 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncReloadSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::ReLoadSegmentsParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; @@ -1434,6 +1472,7 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_Cmd_; const ::grpc::internal::RpcMethod rpcmethod_DeleteByID_; const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ReloadSegments_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; const ::grpc::internal::RpcMethod rpcmethod_CreateHybridCollection_; @@ -1619,6 +1658,13 @@ class MilvusService final { // @return Status virtual ::grpc::Status PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * + // @brief This method is used to reload collection segments + // + // @param ReLoadSegmentsParam, target segments information. + // + // @return Status + virtual ::grpc::Status ReloadSegments(::grpc::ServerContext* context, const ::milvus::grpc::ReLoadSegmentsParam* request, ::milvus::grpc::Status* response); + // * // @brief This method is used to flush buffer into storage. // // @param FlushParam, flush parameters @@ -2121,12 +2167,32 @@ class MilvusService final { } }; template + class WithAsyncMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ReloadSegments() { + ::grpc::Service::MarkMethodAsync(23); + } + ~WithAsyncMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReloadSegments(::grpc::ServerContext* context, ::milvus::grpc::ReLoadSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class WithAsyncMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Flush() { - ::grpc::Service::MarkMethodAsync(23); + ::grpc::Service::MarkMethodAsync(24); } ~WithAsyncMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -2137,7 +2203,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFlush(::grpc::ServerContext* context, ::milvus::grpc::FlushParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2146,7 +2212,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_Compact() { - ::grpc::Service::MarkMethodAsync(24); + ::grpc::Service::MarkMethodAsync(25); } ~WithAsyncMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -2157,7 +2223,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2166,7 +2232,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodAsync(25); + ::grpc::Service::MarkMethodAsync(26); } ~WithAsyncMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2177,7 +2243,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCreateHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::Mapping* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2186,7 +2252,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodAsync(26); + ::grpc::Service::MarkMethodAsync(27); } ~WithAsyncMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2197,7 +2263,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2206,7 +2272,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodAsync(27); + ::grpc::Service::MarkMethodAsync(28); } ~WithAsyncMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2217,7 +2283,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDropHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2226,7 +2292,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodAsync(28); + ::grpc::Service::MarkMethodAsync(29); } ~WithAsyncMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2237,7 +2303,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Mapping>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2246,7 +2312,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodAsync(29); + ::grpc::Service::MarkMethodAsync(30); } ~WithAsyncMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2257,7 +2323,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCountHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2266,7 +2332,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodAsync(30); + ::grpc::Service::MarkMethodAsync(31); } ~WithAsyncMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -2277,7 +2343,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::MappingList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2286,7 +2352,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodAsync(31); + ::grpc::Service::MarkMethodAsync(32); } ~WithAsyncMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -2297,7 +2363,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2306,7 +2372,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodAsync(32); + ::grpc::Service::MarkMethodAsync(33); } ~WithAsyncMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -2317,7 +2383,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2326,7 +2392,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_InsertEntity() { - ::grpc::Service::MarkMethodAsync(33); + ::grpc::Service::MarkMethodAsync(34); } ~WithAsyncMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -2337,7 +2403,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertEntity(::grpc::ServerContext* context, ::milvus::grpc::HInsertParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2346,7 +2412,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HybridSearch() { - ::grpc::Service::MarkMethodAsync(34); + ::grpc::Service::MarkMethodAsync(35); } ~WithAsyncMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -2357,7 +2423,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2366,7 +2432,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodAsync(35); + ::grpc::Service::MarkMethodAsync(36); } ~WithAsyncMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -2377,7 +2443,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::milvus::grpc::HSearchInSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2386,7 +2452,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetEntityByID() { - ::grpc::Service::MarkMethodAsync(36); + ::grpc::Service::MarkMethodAsync(37); } ~WithAsyncMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -2397,7 +2463,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::HEntityIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2406,7 +2472,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodAsync(37); + ::grpc::Service::MarkMethodAsync(38); } ~WithAsyncMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -2417,7 +2483,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityIDs(::grpc::ServerContext* context, ::milvus::grpc::HGetEntityIDsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -2426,7 +2492,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithAsyncMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodAsync(38); + ::grpc::Service::MarkMethodAsync(39); } ~WithAsyncMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -2437,10 +2503,10 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::milvus::grpc::HDeleteByIDParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(39, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: @@ -3155,12 +3221,43 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithCallbackMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ReloadSegments() { + ::grpc::Service::experimental().MarkMethodCallback(23, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::ReLoadSegmentsParam* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ReloadSegments(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ReloadSegments( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(23)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class ExperimentalWithCallbackMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_Flush() { - ::grpc::Service::experimental().MarkMethodCallback(23, + ::grpc::Service::experimental().MarkMethodCallback(24, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, @@ -3172,7 +3269,7 @@ class MilvusService final { void SetMessageAllocatorFor_Flush( ::grpc::experimental::MessageAllocator< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(23)) + ::grpc::Service::experimental().GetHandler(24)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_Flush() override { @@ -3191,7 +3288,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_Compact() { - ::grpc::Service::experimental().MarkMethodCallback(24, + ::grpc::Service::experimental().MarkMethodCallback(25, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3203,7 +3300,7 @@ class MilvusService final { void SetMessageAllocatorFor_Compact( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(24)) + ::grpc::Service::experimental().GetHandler(25)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_Compact() override { @@ -3222,7 +3319,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_CreateHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(25, + ::grpc::Service::experimental().MarkMethodCallback(26, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, @@ -3234,7 +3331,7 @@ class MilvusService final { void SetMessageAllocatorFor_CreateHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::Mapping, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(25)) + ::grpc::Service::experimental().GetHandler(26)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_CreateHybridCollection() override { @@ -3253,7 +3350,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HasHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(26, + ::grpc::Service::experimental().MarkMethodCallback(27, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3265,7 +3362,7 @@ class MilvusService final { void SetMessageAllocatorFor_HasHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( - ::grpc::Service::experimental().GetHandler(26)) + ::grpc::Service::experimental().GetHandler(27)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HasHybridCollection() override { @@ -3284,7 +3381,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DropHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(27, + ::grpc::Service::experimental().MarkMethodCallback(28, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3296,7 +3393,7 @@ class MilvusService final { void SetMessageAllocatorFor_DropHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(27)) + ::grpc::Service::experimental().GetHandler(28)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DropHybridCollection() override { @@ -3315,7 +3412,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DescribeHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(28, + ::grpc::Service::experimental().MarkMethodCallback(29, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3327,7 +3424,7 @@ class MilvusService final { void SetMessageAllocatorFor_DescribeHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>*>( - ::grpc::Service::experimental().GetHandler(28)) + ::grpc::Service::experimental().GetHandler(29)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DescribeHybridCollection() override { @@ -3346,7 +3443,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_CountHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(29, + ::grpc::Service::experimental().MarkMethodCallback(30, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3358,7 +3455,7 @@ class MilvusService final { void SetMessageAllocatorFor_CountHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( - ::grpc::Service::experimental().GetHandler(29)) + ::grpc::Service::experimental().GetHandler(30)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_CountHybridCollection() override { @@ -3377,7 +3474,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_ShowHybridCollections() { - ::grpc::Service::experimental().MarkMethodCallback(30, + ::grpc::Service::experimental().MarkMethodCallback(31, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Command* request, @@ -3389,7 +3486,7 @@ class MilvusService final { void SetMessageAllocatorFor_ShowHybridCollections( ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::MappingList>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>*>( - ::grpc::Service::experimental().GetHandler(30)) + ::grpc::Service::experimental().GetHandler(31)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_ShowHybridCollections() override { @@ -3408,7 +3505,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() { - ::grpc::Service::experimental().MarkMethodCallback(31, + ::grpc::Service::experimental().MarkMethodCallback(32, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3420,7 +3517,7 @@ class MilvusService final { void SetMessageAllocatorFor_ShowHybridCollectionInfo( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( - ::grpc::Service::experimental().GetHandler(31)) + ::grpc::Service::experimental().GetHandler(32)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() override { @@ -3439,7 +3536,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_PreloadHybridCollection() { - ::grpc::Service::experimental().MarkMethodCallback(32, + ::grpc::Service::experimental().MarkMethodCallback(33, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, @@ -3451,7 +3548,7 @@ class MilvusService final { void SetMessageAllocatorFor_PreloadHybridCollection( ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(32)) + ::grpc::Service::experimental().GetHandler(33)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_PreloadHybridCollection() override { @@ -3470,7 +3567,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_InsertEntity() { - ::grpc::Service::experimental().MarkMethodCallback(33, + ::grpc::Service::experimental().MarkMethodCallback(34, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, @@ -3482,7 +3579,7 @@ class MilvusService final { void SetMessageAllocatorFor_InsertEntity( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>*>( - ::grpc::Service::experimental().GetHandler(33)) + ::grpc::Service::experimental().GetHandler(34)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_InsertEntity() override { @@ -3501,7 +3598,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HybridSearch() { - ::grpc::Service::experimental().MarkMethodCallback(34, + ::grpc::Service::experimental().MarkMethodCallback(35, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, @@ -3513,7 +3610,7 @@ class MilvusService final { void SetMessageAllocatorFor_HybridSearch( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>*>( - ::grpc::Service::experimental().GetHandler(34)) + ::grpc::Service::experimental().GetHandler(35)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HybridSearch() override { @@ -3532,7 +3629,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_HybridSearchInSegments() { - ::grpc::Service::experimental().MarkMethodCallback(35, + ::grpc::Service::experimental().MarkMethodCallback(36, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, @@ -3544,7 +3641,7 @@ class MilvusService final { void SetMessageAllocatorFor_HybridSearchInSegments( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>*>( - ::grpc::Service::experimental().GetHandler(35)) + ::grpc::Service::experimental().GetHandler(36)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_HybridSearchInSegments() override { @@ -3563,7 +3660,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_GetEntityByID() { - ::grpc::Service::experimental().MarkMethodCallback(36, + ::grpc::Service::experimental().MarkMethodCallback(37, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, @@ -3575,7 +3672,7 @@ class MilvusService final { void SetMessageAllocatorFor_GetEntityByID( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>*>( - ::grpc::Service::experimental().GetHandler(36)) + ::grpc::Service::experimental().GetHandler(37)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_GetEntityByID() override { @@ -3594,7 +3691,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_GetEntityIDs() { - ::grpc::Service::experimental().MarkMethodCallback(37, + ::grpc::Service::experimental().MarkMethodCallback(38, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, @@ -3606,7 +3703,7 @@ class MilvusService final { void SetMessageAllocatorFor_GetEntityIDs( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>*>( - ::grpc::Service::experimental().GetHandler(37)) + ::grpc::Service::experimental().GetHandler(38)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_GetEntityIDs() override { @@ -3625,7 +3722,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithCallbackMethod_DeleteEntitiesByID() { - ::grpc::Service::experimental().MarkMethodCallback(38, + ::grpc::Service::experimental().MarkMethodCallback(39, new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, @@ -3637,7 +3734,7 @@ class MilvusService final { void SetMessageAllocatorFor_DeleteEntitiesByID( ::grpc::experimental::MessageAllocator< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>* allocator) { static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>*>( - ::grpc::Service::experimental().GetHandler(38)) + ::grpc::Service::experimental().GetHandler(39)) ->SetMessageAllocator(allocator); } ~ExperimentalWithCallbackMethod_DeleteEntitiesByID() override { @@ -3650,7 +3747,7 @@ class MilvusService final { } virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template class WithGenericMethod_CreateCollection : public BaseClass { private: @@ -4043,12 +4140,29 @@ class MilvusService final { } }; template + class WithGenericMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ReloadSegments() { + ::grpc::Service::MarkMethodGeneric(23); + } + ~WithGenericMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template class WithGenericMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Flush() { - ::grpc::Service::MarkMethodGeneric(23); + ::grpc::Service::MarkMethodGeneric(24); } ~WithGenericMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -4065,7 +4179,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_Compact() { - ::grpc::Service::MarkMethodGeneric(24); + ::grpc::Service::MarkMethodGeneric(25); } ~WithGenericMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -4082,7 +4196,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodGeneric(25); + ::grpc::Service::MarkMethodGeneric(26); } ~WithGenericMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4099,7 +4213,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodGeneric(26); + ::grpc::Service::MarkMethodGeneric(27); } ~WithGenericMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4116,7 +4230,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodGeneric(27); + ::grpc::Service::MarkMethodGeneric(28); } ~WithGenericMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4133,7 +4247,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodGeneric(28); + ::grpc::Service::MarkMethodGeneric(29); } ~WithGenericMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4150,7 +4264,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodGeneric(29); + ::grpc::Service::MarkMethodGeneric(30); } ~WithGenericMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4167,7 +4281,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodGeneric(30); + ::grpc::Service::MarkMethodGeneric(31); } ~WithGenericMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -4184,7 +4298,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodGeneric(31); + ::grpc::Service::MarkMethodGeneric(32); } ~WithGenericMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -4201,7 +4315,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodGeneric(32); + ::grpc::Service::MarkMethodGeneric(33); } ~WithGenericMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4218,7 +4332,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_InsertEntity() { - ::grpc::Service::MarkMethodGeneric(33); + ::grpc::Service::MarkMethodGeneric(34); } ~WithGenericMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -4235,7 +4349,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HybridSearch() { - ::grpc::Service::MarkMethodGeneric(34); + ::grpc::Service::MarkMethodGeneric(35); } ~WithGenericMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -4252,7 +4366,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodGeneric(35); + ::grpc::Service::MarkMethodGeneric(36); } ~WithGenericMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -4269,7 +4383,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetEntityByID() { - ::grpc::Service::MarkMethodGeneric(36); + ::grpc::Service::MarkMethodGeneric(37); } ~WithGenericMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -4286,7 +4400,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodGeneric(37); + ::grpc::Service::MarkMethodGeneric(38); } ~WithGenericMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -4303,7 +4417,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithGenericMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodGeneric(38); + ::grpc::Service::MarkMethodGeneric(39); } ~WithGenericMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -4775,12 +4889,32 @@ class MilvusService final { } }; template + class WithRawMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ReloadSegments() { + ::grpc::Service::MarkMethodRaw(23); + } + ~WithRawMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestReloadSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class WithRawMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Flush() { - ::grpc::Service::MarkMethodRaw(23); + ::grpc::Service::MarkMethodRaw(24); } ~WithRawMethod_Flush() override { BaseClassMustBeDerivedFromService(this); @@ -4791,7 +4925,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestFlush(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4800,7 +4934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_Compact() { - ::grpc::Service::MarkMethodRaw(24); + ::grpc::Service::MarkMethodRaw(25); } ~WithRawMethod_Compact() override { BaseClassMustBeDerivedFromService(this); @@ -4811,7 +4945,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCompact(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4820,7 +4954,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodRaw(25); + ::grpc::Service::MarkMethodRaw(26); } ~WithRawMethod_CreateHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4831,7 +4965,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4840,7 +4974,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodRaw(26); + ::grpc::Service::MarkMethodRaw(27); } ~WithRawMethod_HasHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4851,7 +4985,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHasHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4860,7 +4994,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodRaw(27); + ::grpc::Service::MarkMethodRaw(28); } ~WithRawMethod_DropHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4871,7 +5005,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDropHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4880,7 +5014,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodRaw(28); + ::grpc::Service::MarkMethodRaw(29); } ~WithRawMethod_DescribeHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4891,7 +5025,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4900,7 +5034,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodRaw(29); + ::grpc::Service::MarkMethodRaw(30); } ~WithRawMethod_CountHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4911,7 +5045,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestCountHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4920,7 +5054,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodRaw(30); + ::grpc::Service::MarkMethodRaw(31); } ~WithRawMethod_ShowHybridCollections() override { BaseClassMustBeDerivedFromService(this); @@ -4931,7 +5065,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4940,7 +5074,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodRaw(31); + ::grpc::Service::MarkMethodRaw(32); } ~WithRawMethod_ShowHybridCollectionInfo() override { BaseClassMustBeDerivedFromService(this); @@ -4951,7 +5085,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4960,7 +5094,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodRaw(32); + ::grpc::Service::MarkMethodRaw(33); } ~WithRawMethod_PreloadHybridCollection() override { BaseClassMustBeDerivedFromService(this); @@ -4971,7 +5105,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -4980,7 +5114,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_InsertEntity() { - ::grpc::Service::MarkMethodRaw(33); + ::grpc::Service::MarkMethodRaw(34); } ~WithRawMethod_InsertEntity() override { BaseClassMustBeDerivedFromService(this); @@ -4991,7 +5125,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestInsertEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5000,7 +5134,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HybridSearch() { - ::grpc::Service::MarkMethodRaw(34); + ::grpc::Service::MarkMethodRaw(35); } ~WithRawMethod_HybridSearch() override { BaseClassMustBeDerivedFromService(this); @@ -5011,7 +5145,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearch(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5020,7 +5154,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodRaw(35); + ::grpc::Service::MarkMethodRaw(36); } ~WithRawMethod_HybridSearchInSegments() override { BaseClassMustBeDerivedFromService(this); @@ -5031,7 +5165,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5040,7 +5174,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetEntityByID() { - ::grpc::Service::MarkMethodRaw(36); + ::grpc::Service::MarkMethodRaw(37); } ~WithRawMethod_GetEntityByID() override { BaseClassMustBeDerivedFromService(this); @@ -5051,7 +5185,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5060,7 +5194,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodRaw(37); + ::grpc::Service::MarkMethodRaw(38); } ~WithRawMethod_GetEntityIDs() override { BaseClassMustBeDerivedFromService(this); @@ -5071,7 +5205,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestGetEntityIDs(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5080,7 +5214,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithRawMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodRaw(38); + ::grpc::Service::MarkMethodRaw(39); } ~WithRawMethod_DeleteEntitiesByID() override { BaseClassMustBeDerivedFromService(this); @@ -5091,7 +5225,7 @@ class MilvusService final { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { - ::grpc::Service::RequestAsyncUnary(38, context, request, response, new_call_cq, notification_cq, tag); + ::grpc::Service::RequestAsyncUnary(39, context, request, response, new_call_cq, notification_cq, tag); } }; template @@ -5670,12 +5804,37 @@ class MilvusService final { virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithRawCallbackMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ReloadSegments() { + ::grpc::Service::experimental().MarkMethodRawCallback(23, + new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( + [this](::grpc::ServerContext* context, + const ::grpc::ByteBuffer* request, + ::grpc::ByteBuffer* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + this->ReloadSegments(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ReloadSegments(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class ExperimentalWithRawCallbackMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_Flush() { - ::grpc::Service::experimental().MarkMethodRawCallback(23, + ::grpc::Service::experimental().MarkMethodRawCallback(24, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5700,7 +5859,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_Compact() { - ::grpc::Service::experimental().MarkMethodRawCallback(24, + ::grpc::Service::experimental().MarkMethodRawCallback(25, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5725,7 +5884,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_CreateHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(25, + ::grpc::Service::experimental().MarkMethodRawCallback(26, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5750,7 +5909,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HasHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(26, + ::grpc::Service::experimental().MarkMethodRawCallback(27, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5775,7 +5934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DropHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(27, + ::grpc::Service::experimental().MarkMethodRawCallback(28, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5800,7 +5959,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DescribeHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(28, + ::grpc::Service::experimental().MarkMethodRawCallback(29, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5825,7 +5984,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_CountHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(29, + ::grpc::Service::experimental().MarkMethodRawCallback(30, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5850,7 +6009,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_ShowHybridCollections() { - ::grpc::Service::experimental().MarkMethodRawCallback(30, + ::grpc::Service::experimental().MarkMethodRawCallback(31, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5875,7 +6034,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() { - ::grpc::Service::experimental().MarkMethodRawCallback(31, + ::grpc::Service::experimental().MarkMethodRawCallback(32, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5900,7 +6059,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_PreloadHybridCollection() { - ::grpc::Service::experimental().MarkMethodRawCallback(32, + ::grpc::Service::experimental().MarkMethodRawCallback(33, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5925,7 +6084,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_InsertEntity() { - ::grpc::Service::experimental().MarkMethodRawCallback(33, + ::grpc::Service::experimental().MarkMethodRawCallback(34, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5950,7 +6109,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HybridSearch() { - ::grpc::Service::experimental().MarkMethodRawCallback(34, + ::grpc::Service::experimental().MarkMethodRawCallback(35, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -5975,7 +6134,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_HybridSearchInSegments() { - ::grpc::Service::experimental().MarkMethodRawCallback(35, + ::grpc::Service::experimental().MarkMethodRawCallback(36, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6000,7 +6159,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_GetEntityByID() { - ::grpc::Service::experimental().MarkMethodRawCallback(36, + ::grpc::Service::experimental().MarkMethodRawCallback(37, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6025,7 +6184,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_GetEntityIDs() { - ::grpc::Service::experimental().MarkMethodRawCallback(37, + ::grpc::Service::experimental().MarkMethodRawCallback(38, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6050,7 +6209,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() { - ::grpc::Service::experimental().MarkMethodRawCallback(38, + ::grpc::Service::experimental().MarkMethodRawCallback(39, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, @@ -6530,12 +6689,32 @@ class MilvusService final { virtual ::grpc::Status StreamedPreloadCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template + class WithStreamedUnaryMethod_ReloadSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ReloadSegments() { + ::grpc::Service::MarkMethodStreamed(23, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::ReLoadSegmentsParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_ReloadSegments::StreamedReloadSegments, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ReloadSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ReloadSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::ReLoadSegmentsParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedReloadSegments(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::ReLoadSegmentsParam,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template class WithStreamedUnaryMethod_Flush : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Flush() { - ::grpc::Service::MarkMethodStreamed(23, + ::grpc::Service::MarkMethodStreamed(24, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::FlushParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Flush::StreamedFlush, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Flush() override { @@ -6555,7 +6734,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_Compact() { - ::grpc::Service::MarkMethodStreamed(24, + ::grpc::Service::MarkMethodStreamed(25, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Compact() override { @@ -6575,7 +6754,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CreateHybridCollection() { - ::grpc::Service::MarkMethodStreamed(25, + ::grpc::Service::MarkMethodStreamed(26, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateHybridCollection::StreamedCreateHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_CreateHybridCollection() override { @@ -6595,7 +6774,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HasHybridCollection() { - ::grpc::Service::MarkMethodStreamed(26, + ::grpc::Service::MarkMethodStreamed(27, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasHybridCollection::StreamedHasHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HasHybridCollection() override { @@ -6615,7 +6794,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DropHybridCollection() { - ::grpc::Service::MarkMethodStreamed(27, + ::grpc::Service::MarkMethodStreamed(28, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropHybridCollection::StreamedDropHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DropHybridCollection() override { @@ -6635,7 +6814,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DescribeHybridCollection() { - ::grpc::Service::MarkMethodStreamed(28, + ::grpc::Service::MarkMethodStreamed(29, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>(std::bind(&WithStreamedUnaryMethod_DescribeHybridCollection::StreamedDescribeHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DescribeHybridCollection() override { @@ -6655,7 +6834,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_CountHybridCollection() { - ::grpc::Service::MarkMethodStreamed(29, + ::grpc::Service::MarkMethodStreamed(30, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountHybridCollection::StreamedCountHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_CountHybridCollection() override { @@ -6675,7 +6854,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ShowHybridCollections() { - ::grpc::Service::MarkMethodStreamed(30, + ::grpc::Service::MarkMethodStreamed(31, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollections::StreamedShowHybridCollections, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowHybridCollections() override { @@ -6695,7 +6874,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_ShowHybridCollectionInfo() { - ::grpc::Service::MarkMethodStreamed(31, + ::grpc::Service::MarkMethodStreamed(32, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollectionInfo::StreamedShowHybridCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowHybridCollectionInfo() override { @@ -6715,7 +6894,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_PreloadHybridCollection() { - ::grpc::Service::MarkMethodStreamed(32, + ::grpc::Service::MarkMethodStreamed(33, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadHybridCollection::StreamedPreloadHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_PreloadHybridCollection() override { @@ -6735,7 +6914,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_InsertEntity() { - ::grpc::Service::MarkMethodStreamed(33, + ::grpc::Service::MarkMethodStreamed(34, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_InsertEntity::StreamedInsertEntity, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_InsertEntity() override { @@ -6755,7 +6934,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HybridSearch() { - ::grpc::Service::MarkMethodStreamed(34, + ::grpc::Service::MarkMethodStreamed(35, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HybridSearch() override { @@ -6775,7 +6954,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_HybridSearchInSegments() { - ::grpc::Service::MarkMethodStreamed(35, + ::grpc::Service::MarkMethodStreamed(36, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearchInSegments::StreamedHybridSearchInSegments, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_HybridSearchInSegments() override { @@ -6795,7 +6974,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetEntityByID() { - ::grpc::Service::MarkMethodStreamed(36, + ::grpc::Service::MarkMethodStreamed(37, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_GetEntityByID() override { @@ -6815,7 +6994,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_GetEntityIDs() { - ::grpc::Service::MarkMethodStreamed(37, + ::grpc::Service::MarkMethodStreamed(38, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_GetEntityIDs::StreamedGetEntityIDs, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_GetEntityIDs() override { @@ -6835,7 +7014,7 @@ class MilvusService final { void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: WithStreamedUnaryMethod_DeleteEntitiesByID() { - ::grpc::Service::MarkMethodStreamed(38, + ::grpc::Service::MarkMethodStreamed(39, new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DeleteEntitiesByID::StreamedDeleteEntitiesByID, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DeleteEntitiesByID() override { @@ -6849,9 +7028,9 @@ class MilvusService final { // replace default version of method with streamed unary virtual ::grpc::Status StreamedDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HDeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.pb.cc index 289aea93bf..2339336b86 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.cc @@ -82,6 +82,10 @@ class SearchByIDParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _SearchByIDParam_default_instance_; +class ReLoadSegmentsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _ReLoadSegmentsParam_default_instance_; class TopKQueryResultDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -759,6 +763,20 @@ static void InitDefaultsscc_info_RangeQuery_milvus_2eproto() { &scc_info_CompareExpr_milvus_2eproto.base, &scc_info_KeyValuePair_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_ReLoadSegmentsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_ReLoadSegmentsParam_default_instance_; + new (ptr) ::milvus::grpc::ReLoadSegmentsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::ReLoadSegmentsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ReLoadSegmentsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_ReLoadSegmentsParam_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_RowRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -954,7 +972,7 @@ static void InitDefaultsscc_info_VectorsIdentity_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorsIdentity_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorsIdentity_milvus_2eproto}, {}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[48]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[49]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; @@ -1056,6 +1074,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, topk_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, extra_params_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::ReLoadSegmentsParam, segment_id_array_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResult, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -1356,42 +1381,43 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 69, -1, sizeof(::milvus::grpc::SearchParam)}, { 79, -1, sizeof(::milvus::grpc::SearchInFilesParam)}, { 86, -1, sizeof(::milvus::grpc::SearchByIDParam)}, - { 96, -1, sizeof(::milvus::grpc::TopKQueryResult)}, - { 105, -1, sizeof(::milvus::grpc::StringReply)}, - { 112, -1, sizeof(::milvus::grpc::BoolReply)}, - { 119, -1, sizeof(::milvus::grpc::CollectionRowCount)}, - { 126, -1, sizeof(::milvus::grpc::Command)}, - { 132, -1, sizeof(::milvus::grpc::IndexParam)}, - { 141, -1, sizeof(::milvus::grpc::FlushParam)}, - { 147, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, - { 154, -1, sizeof(::milvus::grpc::CollectionInfo)}, - { 161, -1, sizeof(::milvus::grpc::VectorsIdentity)}, - { 168, -1, sizeof(::milvus::grpc::VectorsData)}, - { 175, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, - { 182, -1, sizeof(::milvus::grpc::VectorFieldParam)}, - { 188, -1, sizeof(::milvus::grpc::FieldType)}, - { 196, -1, sizeof(::milvus::grpc::FieldParam)}, - { 205, -1, sizeof(::milvus::grpc::VectorFieldValue)}, - { 211, -1, sizeof(::milvus::grpc::FieldValue)}, - { 224, -1, sizeof(::milvus::grpc::Mapping)}, - { 233, -1, sizeof(::milvus::grpc::MappingList)}, - { 240, -1, sizeof(::milvus::grpc::TermQuery)}, - { 250, -1, sizeof(::milvus::grpc::CompareExpr)}, - { 257, -1, sizeof(::milvus::grpc::RangeQuery)}, - { 266, -1, sizeof(::milvus::grpc::VectorQuery)}, - { 276, -1, sizeof(::milvus::grpc::BooleanQuery)}, - { 283, -1, sizeof(::milvus::grpc::GeneralQuery)}, - { 293, -1, sizeof(::milvus::grpc::HSearchParam)}, - { 302, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, - { 309, -1, sizeof(::milvus::grpc::AttrRecord)}, - { 315, -1, sizeof(::milvus::grpc::HEntity)}, - { 326, -1, sizeof(::milvus::grpc::HQueryResult)}, - { 336, -1, sizeof(::milvus::grpc::HInsertParam)}, - { 346, -1, sizeof(::milvus::grpc::HEntityIdentity)}, - { 353, -1, sizeof(::milvus::grpc::HEntityIDs)}, - { 360, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, - { 367, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, - { 374, -1, sizeof(::milvus::grpc::HIndexParam)}, + { 96, -1, sizeof(::milvus::grpc::ReLoadSegmentsParam)}, + { 103, -1, sizeof(::milvus::grpc::TopKQueryResult)}, + { 112, -1, sizeof(::milvus::grpc::StringReply)}, + { 119, -1, sizeof(::milvus::grpc::BoolReply)}, + { 126, -1, sizeof(::milvus::grpc::CollectionRowCount)}, + { 133, -1, sizeof(::milvus::grpc::Command)}, + { 139, -1, sizeof(::milvus::grpc::IndexParam)}, + { 148, -1, sizeof(::milvus::grpc::FlushParam)}, + { 154, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, + { 161, -1, sizeof(::milvus::grpc::CollectionInfo)}, + { 168, -1, sizeof(::milvus::grpc::VectorsIdentity)}, + { 175, -1, sizeof(::milvus::grpc::VectorsData)}, + { 182, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, + { 189, -1, sizeof(::milvus::grpc::VectorFieldParam)}, + { 195, -1, sizeof(::milvus::grpc::FieldType)}, + { 203, -1, sizeof(::milvus::grpc::FieldParam)}, + { 212, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 218, -1, sizeof(::milvus::grpc::FieldValue)}, + { 231, -1, sizeof(::milvus::grpc::Mapping)}, + { 240, -1, sizeof(::milvus::grpc::MappingList)}, + { 247, -1, sizeof(::milvus::grpc::TermQuery)}, + { 257, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 264, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 273, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 283, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 290, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 300, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 309, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 316, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 322, -1, sizeof(::milvus::grpc::HEntity)}, + { 333, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 343, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 353, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 360, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 367, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 374, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 381, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1407,6 +1433,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_SearchParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SearchInFilesParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SearchByIDParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_ReLoadSegmentsParam_default_instance_), reinterpret_cast(&::milvus::grpc::_TopKQueryResult_default_instance_), reinterpret_cast(&::milvus::grpc::_StringReply_default_instance_), reinterpret_cast(&::milvus::grpc::_BoolReply_default_instance_), @@ -1478,185 +1505,189 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "m\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_" "tag_array\030\002 \003(\t\022\020\n\010id_array\030\003 \003(\003\022\014\n\004top" "k\030\004 \001(\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.g" - "rpc.KeyValuePair\"g\n\017TopKQueryResult\022#\n\006s" - "tatus\030\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_" - "num\030\002 \001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(" - "\002\"H\n\013StringReply\022#\n\006status\030\001 \001(\0132\023.milvu" - "s.grpc.Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tB" - "oolReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.S" - "tatus\022\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionR" - "owCount\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" - "atus\022\034\n\024collection_row_count\030\002 \001(\003\"\026\n\007Co" - "mmand\022\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006sta" - "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017collec" - "tion_name\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014e" - "xtra_params\030\004 \003(\0132\031.milvus.grpc.KeyValue" - "Pair\"+\n\nFlushParam\022\035\n\025collection_name_ar" - "ray\030\001 \003(\t\"<\n\017DeleteByIDParam\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"H\n\016Colle" - "ctionInfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\021\n\tjson_info\030\002 \001(\t\"<\n\017VectorsIden" - "tity\022\027\n\017collection_name\030\001 \001(\t\022\020\n\010id_arra" - "y\030\002 \003(\003\"`\n\013VectorsData\022#\n\006status\030\001 \001(\0132\023" - ".milvus.grpc.Status\022,\n\014vectors_data\030\002 \003(" - "\0132\026.milvus.grpc.RowRecord\"B\n\021GetVectorID" - "sParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segme" - "nt_name\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n\tdim" - "ension\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_type\030\001" - " \001(\0162\025.milvus.grpc.DataTypeH\000\0225\n\014vector_" - "param\030\002 \001(\0132\035.milvus.grpc.VectorFieldPar" - "amH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022" - "\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grp" - "c.FieldType\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"9\n\020VectorFieldValue" - "\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord\"" - "\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n" - "\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(" - "\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014string_va" - "lue\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vec" - "tor_value\030\007 \001(\0132\035.milvus.grpc.VectorFiel" - "dValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030" - "\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollection" - "_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fi" - "elds\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013M" - "appingList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" - ".Status\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.g" - "rpc.Mapping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030" - "\001 \001(\t\022\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003" - "\022\r\n\005boost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031." - "milvus.grpc.KeyValuePair\"N\n\013CompareExpr\022" - ".\n\010operator\030\001 \001(\0162\034.milvus.grpc.CompareO" - "perator\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022" - "\022\n\nfield_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.m" - "ilvus.grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n" - "\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyVal" - "uePair\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001" - "(\t\022\023\n\013query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\013" - "2\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/" - "\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyVa" - "luePair\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022" - ".milvus.grpc.Occur\0220\n\rgeneral_query\030\002 \003(" - "\0132\031.milvus.grpc.GeneralQuery\"\333\001\n\014General" - "Query\0222\n\rboolean_query\030\001 \001(\0132\031.milvus.gr" - "pc.BooleanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026." - "milvus.grpc.TermQueryH\000\022.\n\013range_query\030\003" - " \001(\0132\027.milvus.grpc.RangeQueryH\000\0220\n\014vecto" - "r_query\030\004 \001(\0132\030.milvus.grpc.VectorQueryH" - "\000B\007\n\005query\"\247\001\n\014HSearchParam\022\027\n\017collectio" - "n_name\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(" - "\t\0220\n\rgeneral_query\030\003 \001(\0132\031.milvus.grpc.G" - "eneralQuery\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"c\n\026HSearchInSegment" - "sParam\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014sear" - "ch_param\030\002 \001(\0132\031.milvus.grpc.HSearchPara" - "m\"\033\n\nAttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEnti" - "ty\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\021\n\tentity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022" - "\024\n\014attr_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022." - "\n\rresult_values\030\006 \003(\0132\027.milvus.grpc.Fiel" - "dValue\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132" - "\023.milvus.grpc.Status\022&\n\010entities\030\002 \003(\0132\024" - ".milvus.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n" - "\005score\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInse" - "rtParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpart" - "ition_tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milv" - "us.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003(\003" - "\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Key" - "ValuePair\"6\n\017HEntityIdentity\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022" - "#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017" - "entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsPa" - "ram\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_" - "name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collec" - "tion_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HI" - "ndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex" - "_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004NUL" - "L\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005I" - "NT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022" - "\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n" - "\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020" - "\002\022\006\n\002GT\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007I" - "NVALID\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_N" - "OT\020\0032\324\026\n\rMilvusService\022H\n\020CreateCollecti" - "on\022\035.milvus.grpc.CollectionSchema\032\023.milv" - "us.grpc.Status\"\000\022F\n\rHasCollection\022\033.milv" - "us.grpc.CollectionName\032\026.milvus.grpc.Boo" - "lReply\"\000\022R\n\022DescribeCollection\022\033.milvus." - "grpc.CollectionName\032\035.milvus.grpc.Collec" - "tionSchema\"\000\022Q\n\017CountCollection\022\033.milvus" - ".grpc.CollectionName\032\037.milvus.grpc.Colle" - "ctionRowCount\"\000\022J\n\017ShowCollections\022\024.mil" - "vus.grpc.Command\032\037.milvus.grpc.Collectio" - "nNameList\"\000\022P\n\022ShowCollectionInfo\022\033.milv" - "us.grpc.CollectionName\032\033.milvus.grpc.Col" - "lectionInfo\"\000\022D\n\016DropCollection\022\033.milvus" - ".grpc.CollectionName\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexPa" - "ram\032\023.milvus.grpc.Status\"\000\022G\n\rDescribeIn" - "dex\022\033.milvus.grpc.CollectionName\032\027.milvu" - "s.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022E\n\017CreatePartition\022\033.milvus.grpc.Pa" - "rtitionParam\032\023.milvus.grpc.Status\"\000\022E\n\014H" - "asPartition\022\033.milvus.grpc.PartitionParam" - "\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPartit" - "ions\022\033.milvus.grpc.CollectionName\032\032.milv" - "us.grpc.PartitionList\"\000\022C\n\rDropPartition" - "\022\033.milvus.grpc.PartitionParam\032\023.milvus.g" - "rpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.Ins" - "ertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016Ge" - "tVectorsByID\022\034.milvus.grpc.VectorsIdenti" - "ty\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetVec" - "torIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026" - ".milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.mil" - "vus.grpc.SearchParam\032\034.milvus.grpc.TopKQ" - "ueryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc" - ".SearchByIDParam\032\034.milvus.grpc.TopKQuery" - "Result\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc." - "SearchInFilesParam\032\034.milvus.grpc.TopKQue" - "ryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032" - "\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteByI" - "D\022\034.milvus.grpc.DeleteByIDParam\032\023.milvus" - ".grpc.Status\"\000\022G\n\021PreloadCollection\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPara" - "m\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\022E\n\026CreateHybridCollection\022\024.milv" - "us.grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L" - "\n\023HasHybridCollection\022\033.milvus.grpc.Coll" - "ectionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024" - "DropHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\023.milvus.grpc.Status\"\000\022O\n\030Desc" - "ribeHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Cou" - "ntHybridCollection\022\033.milvus.grpc.Collect" - "ionName\032\037.milvus.grpc.CollectionRowCount" - "\"\000\022I\n\025ShowHybridCollections\022\024.milvus.grp" - "c.Command\032\030.milvus.grpc.MappingList\"\000\022V\n" - "\030ShowHybridCollectionInfo\022\033.milvus.grpc." - "CollectionName\032\033.milvus.grpc.CollectionI" - "nfo\"\000\022M\n\027PreloadHybridCollection\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInse" - "rtParam\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hy" - "bridSearch\022\031.milvus.grpc.HSearchParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\022]\n\026HybridS" - "earchInSegments\022#.milvus.grpc.HSearchInS" - "egmentsParam\032\034.milvus.grpc.TopKQueryResu" - "lt\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEnt" - "ityIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014G" - "etEntityIDs\022\037.milvus.grpc.HGetEntityIDsP" - "aram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delet" - "eEntitiesByID\022\035.milvus.grpc.HDeleteByIDP" - "aram\032\023.milvus.grpc.Status\"\000b\006proto3" + "rpc.KeyValuePair\"H\n\023ReLoadSegmentsParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\030\n\020segment_id_a" + "rray\030\002 \003(\t\"g\n\017TopKQueryResult\022#\n\006status\030" + "\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_num\030\002 " + "\001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013S" + "tringReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" + ".Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoolRep" + "ly\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" + "\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionRowCoun" + "t\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\034" + "\n\024collection_row_count\030\002 \001(\003\"\026\n\007Command\022" + "\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022\027\n\017collection_n" + "ame\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014extra_p" + "arams\030\004 \003(\0132\031.milvus.grpc.KeyValuePair\"+" + "\n\nFlushParam\022\035\n\025collection_name_array\030\001 " + "\003(\t\"<\n\017DeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"H\n\016CollectionI" + "nfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\021\n\tjson_info\030\002 \001(\t\"<\n\017VectorsIdentity\022\027" + "\n\017collection_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(" + "\003\"`\n\013VectorsData\022#\n\006status\030\001 \001(\0132\023.milvu" + "s.grpc.Status\022,\n\014vectors_data\030\002 \003(\0132\026.mi" + "lvus.grpc.RowRecord\"B\n\021GetVectorIDsParam" + "\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_nam" + "e\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n\tdimension" + "\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_type\030\001 \001(\0162\025" + ".milvus.grpc.DataTypeH\000\0225\n\014vector_param\030" + "\002 \001(\0132\035.milvus.grpc.VectorFieldParamH\000B\007" + "\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022\014\n\004nam" + "e\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grpc.Fiel" + "dType\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair\"9\n\020VectorFieldValue\022%\n\005va" + "lue\030\001 \003(\0132\026.milvus.grpc.RowRecord\"\327\001\n\nFi" + "eldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n\013int64" + "_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(\002H\000\022\026\n" + "\014double_value\030\004 \001(\001H\000\022\026\n\014string_value\030\005 " + "\001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vector_va" + "lue\030\007 \001(\0132\035.milvus.grpc.VectorFieldValue" + "H\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030\001 \001(\0132" + "\023.milvus.grpc.Status\022\025\n\rcollection_id\030\002 " + "\001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fields\030\004" + " \003(\0132\027.milvus.grpc.FieldParam\"^\n\013Mapping" + "List\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Statu" + "s\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.grpc.Ma" + "pping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030\001 \001(\t\022" + "\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003\022\r\n\005bo" + "ost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031.milvus" + ".grpc.KeyValuePair\"N\n\013CompareExpr\022.\n\010ope" + "rator\030\001 \001(\0162\034.milvus.grpc.CompareOperato" + "r\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfie" + "ld_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.milvus." + "grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra" + "_params\030\004 \003(\0132\031.milvus.grpc.KeyValuePair" + "\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013" + "query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\0132\026.mil" + "vus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extr" + "a_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022.milvu" + "s.grpc.Occur\0220\n\rgeneral_query\030\002 \003(\0132\031.mi" + "lvus.grpc.GeneralQuery\"\333\001\n\014GeneralQuery\022" + "2\n\rboolean_query\030\001 \001(\0132\031.milvus.grpc.Boo" + "leanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026.milvus" + ".grpc.TermQueryH\000\022.\n\013range_query\030\003 \001(\0132\027" + ".milvus.grpc.RangeQueryH\000\0220\n\014vector_quer" + "y\030\004 \001(\0132\030.milvus.grpc.VectorQueryH\000B\007\n\005q" + "uery\"\247\001\n\014HSearchParam\022\027\n\017collection_name" + "\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(\t\0220\n\rg" + "eneral_query\030\003 \001(\0132\031.milvus.grpc.General" + "Query\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair\"c\n\026HSearchInSegmentsParam" + "\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014search_par" + "am\030\002 \001(\0132\031.milvus.grpc.HSearchParam\"\033\n\nA" + "ttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEntity\022#\n\006" + "status\030\001 \001(\0132\023.milvus.grpc.Status\022\021\n\tent" + "ity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022\024\n\014att" + "r_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022.\n\rresu" + "lt_values\030\006 \003(\0132\027.milvus.grpc.FieldValue" + "\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.milv" + "us.grpc.Status\022&\n\010entities\030\002 \003(\0132\024.milvu" + "s.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005score" + "\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInsertPara" + "m\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpartition_" + "tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milvus.grp" + "c.HEntity\022\027\n\017entity_id_array\030\004 \003(\003\022/\n\014ex" + "tra_params\030\005 \003(\0132\031.milvus.grpc.KeyValueP" + "air\"6\n\017HEntityIdentity\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022#\n\006sta" + "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017entity" + "_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsParam\022\027\n" + "\017collection_name\030\001 \001(\t\022\024\n\014segment_name\030\002" + " \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collection_n" + "ame\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HIndexPa" + "ram\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex_type\030" + "\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grp" + "c.KeyValuePair*\206\001\n\010DataType\022\010\n\004NULL\020\000\022\010\n" + "\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT64\020\004" + "\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022\n\n\006DOU" + "BLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n\017Compa" + "reOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002G" + "T\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID" + "\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\0032\237" + "\027\n\rMilvusService\022H\n\020CreateCollection\022\035.m" + "ilvus.grpc.CollectionSchema\032\023.milvus.grp" + "c.Status\"\000\022F\n\rHasCollection\022\033.milvus.grp" + "c.CollectionName\032\026.milvus.grpc.BoolReply" + "\"\000\022R\n\022DescribeCollection\022\033.milvus.grpc.C" + "ollectionName\032\035.milvus.grpc.CollectionSc" + "hema\"\000\022Q\n\017CountCollection\022\033.milvus.grpc." + "CollectionName\032\037.milvus.grpc.CollectionR" + "owCount\"\000\022J\n\017ShowCollections\022\024.milvus.gr" + "pc.Command\032\037.milvus.grpc.CollectionNameL" + "ist\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.grp" + "c.CollectionName\032\033.milvus.grpc.Collectio" + "nInfo\"\000\022D\n\016DropCollection\022\033.milvus.grpc." + "CollectionName\032\023.milvus.grpc.Status\"\000\022=\n" + "\013CreateIndex\022\027.milvus.grpc.IndexParam\032\023." + "milvus.grpc.Status\"\000\022G\n\rDescribeIndex\022\033." + "milvus.grpc.CollectionName\032\027.milvus.grpc" + ".IndexParam\"\000\022\?\n\tDropIndex\022\033.milvus.grpc" + ".CollectionName\032\023.milvus.grpc.Status\"\000\022E" + "\n\017CreatePartition\022\033.milvus.grpc.Partitio" + "nParam\032\023.milvus.grpc.Status\"\000\022E\n\014HasPart" + "ition\022\033.milvus.grpc.PartitionParam\032\026.mil" + "vus.grpc.BoolReply\"\000\022K\n\016ShowPartitions\022\033" + ".milvus.grpc.CollectionName\032\032.milvus.grp" + "c.PartitionList\"\000\022C\n\rDropPartition\022\033.mil" + "vus.grpc.PartitionParam\032\023.milvus.grpc.St" + "atus\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertPar" + "am\032\026.milvus.grpc.VectorIds\"\000\022J\n\016GetVecto" + "rsByID\022\034.milvus.grpc.VectorsIdentity\032\030.m" + "ilvus.grpc.VectorsData\"\000\022H\n\014GetVectorIDs" + "\022\036.milvus.grpc.GetVectorIDsParam\032\026.milvu" + "s.grpc.VectorIds\"\000\022B\n\006Search\022\030.milvus.gr" + "pc.SearchParam\032\034.milvus.grpc.TopKQueryRe" + "sult\"\000\022J\n\nSearchByID\022\034.milvus.grpc.Searc" + "hByIDParam\032\034.milvus.grpc.TopKQueryResult" + "\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc.Search" + "InFilesParam\032\034.milvus.grpc.TopKQueryResu" + "lt\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032\030.milv" + "us.grpc.StringReply\"\000\022A\n\nDeleteByID\022\034.mi" + "lvus.grpc.DeleteByIDParam\032\023.milvus.grpc." + "Status\"\000\022G\n\021PreloadCollection\022\033.milvus.g" + "rpc.CollectionName\032\023.milvus.grpc.Status\"" + "\000\022I\n\016ReloadSegments\022 .milvus.grpc.ReLoad" + "SegmentsParam\032\023.milvus.grpc.Status\"\000\0227\n\005" + "Flush\022\027.milvus.grpc.FlushParam\032\023.milvus." + "grpc.Status\"\000\022=\n\007Compact\022\033.milvus.grpc.C" + "ollectionName\032\023.milvus.grpc.Status\"\000\022E\n\026" + "CreateHybridCollection\022\024.milvus.grpc.Map" + "ping\032\023.milvus.grpc.Status\"\000\022L\n\023HasHybrid" + "Collection\022\033.milvus.grpc.CollectionName\032" + "\026.milvus.grpc.BoolReply\"\000\022J\n\024DropHybridC" + "ollection\022\033.milvus.grpc.CollectionName\032\023" + ".milvus.grpc.Status\"\000\022O\n\030DescribeHybridC" + "ollection\022\033.milvus.grpc.CollectionName\032\024" + ".milvus.grpc.Mapping\"\000\022W\n\025CountHybridCol" + "lection\022\033.milvus.grpc.CollectionName\032\037.m" + "ilvus.grpc.CollectionRowCount\"\000\022I\n\025ShowH" + "ybridCollections\022\024.milvus.grpc.Command\032\030" + ".milvus.grpc.MappingList\"\000\022V\n\030ShowHybrid" + "CollectionInfo\022\033.milvus.grpc.CollectionN" + "ame\032\033.milvus.grpc.CollectionInfo\"\000\022M\n\027Pr" + "eloadHybridCollection\022\033.milvus.grpc.Coll" + "ectionName\032\023.milvus.grpc.Status\"\000\022D\n\014Ins" + "ertEntity\022\031.milvus.grpc.HInsertParam\032\027.m" + "ilvus.grpc.HEntityIDs\"\000\022I\n\014HybridSearch\022" + "\031.milvus.grpc.HSearchParam\032\034.milvus.grpc" + ".TopKQueryResult\"\000\022]\n\026HybridSearchInSegm" + "ents\022#.milvus.grpc.HSearchInSegmentsPara" + "m\032\034.milvus.grpc.TopKQueryResult\"\000\022E\n\rGet" + "EntityByID\022\034.milvus.grpc.HEntityIdentity" + "\032\024.milvus.grpc.HEntity\"\000\022J\n\014GetEntityIDs" + "\022\037.milvus.grpc.HGetEntityIDsParam\032\027.milv" + "us.grpc.HEntityIDs\"\000\022J\n\022DeleteEntitiesBy" + "ID\022\035.milvus.grpc.HDeleteByIDParam\032\023.milv" + "us.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[47] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[48] = { &scc_info_AttrRecord_milvus_2eproto.base, &scc_info_BoolReply_milvus_2eproto.base, &scc_info_BooleanQuery_milvus_2eproto.base, @@ -1691,6 +1722,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_PartitionList_milvus_2eproto.base, &scc_info_PartitionParam_milvus_2eproto.base, &scc_info_RangeQuery_milvus_2eproto.base, + &scc_info_ReLoadSegmentsParam_milvus_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base, &scc_info_SearchByIDParam_milvus_2eproto.base, &scc_info_SearchInFilesParam_milvus_2eproto.base, @@ -1708,10 +1740,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8235, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 47, 1, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8384, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 48, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 48, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 49, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -6376,6 +6408,335 @@ void SearchByIDParam::InternalSwap(SearchByIDParam* other) { } +// =================================================================== + +void ReLoadSegmentsParam::InitAsDefaultInstance() { +} +class ReLoadSegmentsParam::_Internal { + public: +}; + +ReLoadSegmentsParam::ReLoadSegmentsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.ReLoadSegmentsParam) +} +ReLoadSegmentsParam::ReLoadSegmentsParam(const ReLoadSegmentsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_id_array_(from.segment_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.ReLoadSegmentsParam) +} + +void ReLoadSegmentsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ReLoadSegmentsParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ReLoadSegmentsParam::~ReLoadSegmentsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.ReLoadSegmentsParam) + SharedDtor(); +} + +void ReLoadSegmentsParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ReLoadSegmentsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const ReLoadSegmentsParam& ReLoadSegmentsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_ReLoadSegmentsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void ReLoadSegmentsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_id_array_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* ReLoadSegmentsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.ReLoadSegmentsParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string segment_id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_segment_id_array(), ptr, ctx, "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool ReLoadSegmentsParam::MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + // @@protoc_insertion_point(parse_start:milvus.grpc.ReLoadSegmentsParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.ReLoadSegmentsParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string segment_id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_segment_id_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(this->segment_id_array_size() - 1).data(), + static_cast(this->segment_id_array(this->segment_id_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array")); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.ReLoadSegmentsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.ReLoadSegmentsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void ReLoadSegmentsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated string segment_id_array = 2; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->segment_id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.ReLoadSegmentsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReLoadSegmentsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated string segment_id_array = 2; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.ReLoadSegmentsParam.segment_id_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->segment_id_array(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.ReLoadSegmentsParam) + return target; +} + +size_t ReLoadSegmentsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.ReLoadSegmentsParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string segment_id_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->segment_id_array_size()); + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_id_array(i)); + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReLoadSegmentsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.ReLoadSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + const ReLoadSegmentsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.ReLoadSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.ReLoadSegmentsParam) + MergeFrom(*source); + } +} + +void ReLoadSegmentsParam::MergeFrom(const ReLoadSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.ReLoadSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_id_array_.MergeFrom(from.segment_id_array_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void ReLoadSegmentsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.ReLoadSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReLoadSegmentsParam::CopyFrom(const ReLoadSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.ReLoadSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReLoadSegmentsParam::IsInitialized() const { + return true; +} + +void ReLoadSegmentsParam::InternalSwap(ReLoadSegmentsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_id_array_.InternalSwap(CastToBase(&other->segment_id_array_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReLoadSegmentsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void TopKQueryResult::InitAsDefaultInstance() { @@ -20011,6 +20372,9 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchInFilesParam* Arena::CreateMa template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchByIDParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::SearchByIDParam >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::grpc::ReLoadSegmentsParam* Arena::CreateMaybeMessage< ::milvus::grpc::ReLoadSegmentsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::ReLoadSegmentsParam >(arena); +} template<> PROTOBUF_NOINLINE ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::TopKQueryResult >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::TopKQueryResult >(arena); } diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.h b/sdk/grpc-gen/gen-milvus/milvus.pb.h index f9c74151a4..76ff7b9402 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.h @@ -49,7 +49,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[48] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[49] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -163,6 +163,9 @@ extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_; class RangeQuery; class RangeQueryDefaultTypeInternal; extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_; +class ReLoadSegmentsParam; +class ReLoadSegmentsParamDefaultTypeInternal; +extern ReLoadSegmentsParamDefaultTypeInternal _ReLoadSegmentsParam_default_instance_; class RowRecord; class RowRecordDefaultTypeInternal; extern RowRecordDefaultTypeInternal _RowRecord_default_instance_; @@ -240,6 +243,7 @@ template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*); template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*); template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*); +template<> ::milvus::grpc::ReLoadSegmentsParam* Arena::CreateMaybeMessage<::milvus::grpc::ReLoadSegmentsParam>(Arena*); template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*); template<> ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchByIDParam>(Arena*); template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*); @@ -2294,6 +2298,162 @@ class SearchByIDParam : }; // ------------------------------------------------------------------- +class ReLoadSegmentsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.ReLoadSegmentsParam) */ { + public: + ReLoadSegmentsParam(); + virtual ~ReLoadSegmentsParam(); + + ReLoadSegmentsParam(const ReLoadSegmentsParam& from); + ReLoadSegmentsParam(ReLoadSegmentsParam&& from) noexcept + : ReLoadSegmentsParam() { + *this = ::std::move(from); + } + + inline ReLoadSegmentsParam& operator=(const ReLoadSegmentsParam& from) { + CopyFrom(from); + return *this; + } + inline ReLoadSegmentsParam& operator=(ReLoadSegmentsParam&& from) noexcept { + if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return GetMetadataStatic().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return GetMetadataStatic().reflection; + } + static const ReLoadSegmentsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const ReLoadSegmentsParam* internal_default_instance() { + return reinterpret_cast( + &_ReLoadSegmentsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ReLoadSegmentsParam& a, ReLoadSegmentsParam& b) { + a.Swap(&b); + } + inline void Swap(ReLoadSegmentsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReLoadSegmentsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReLoadSegmentsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReLoadSegmentsParam& from); + void MergeFrom(const ReLoadSegmentsParam& from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + #else + bool MergePartialFromCodedStream( + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final; + #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + void SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final; + ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReLoadSegmentsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.ReLoadSegmentsParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdArrayFieldNumber = 2, + kCollectionNameFieldNumber = 1, + }; + // repeated string segment_id_array = 2; + int segment_id_array_size() const; + void clear_segment_id_array(); + const std::string& segment_id_array(int index) const; + std::string* mutable_segment_id_array(int index); + void set_segment_id_array(int index, const std::string& value); + void set_segment_id_array(int index, std::string&& value); + void set_segment_id_array(int index, const char* value); + void set_segment_id_array(int index, const char* value, size_t size); + std::string* add_segment_id_array(); + void add_segment_id_array(const std::string& value); + void add_segment_id_array(std::string&& value); + void add_segment_id_array(const char* value); + void add_segment_id_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& segment_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_segment_id_array(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.ReLoadSegmentsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField segment_id_array_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + class TopKQueryResult : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResult) */ { public: @@ -2336,7 +2496,7 @@ class TopKQueryResult : &_TopKQueryResult_default_instance_); } static constexpr int kIndexInFileMessages = - 12; + 13; friend void swap(TopKQueryResult& a, TopKQueryResult& b) { a.Swap(&b); @@ -2505,7 +2665,7 @@ class StringReply : &_StringReply_default_instance_); } static constexpr int kIndexInFileMessages = - 13; + 14; friend void swap(StringReply& a, StringReply& b) { a.Swap(&b); @@ -2652,7 +2812,7 @@ class BoolReply : &_BoolReply_default_instance_); } static constexpr int kIndexInFileMessages = - 14; + 15; friend void swap(BoolReply& a, BoolReply& b) { a.Swap(&b); @@ -2793,7 +2953,7 @@ class CollectionRowCount : &_CollectionRowCount_default_instance_); } static constexpr int kIndexInFileMessages = - 15; + 16; friend void swap(CollectionRowCount& a, CollectionRowCount& b) { a.Swap(&b); @@ -2934,7 +3094,7 @@ class Command : &_Command_default_instance_); } static constexpr int kIndexInFileMessages = - 16; + 17; friend void swap(Command& a, Command& b) { a.Swap(&b); @@ -3071,7 +3231,7 @@ class IndexParam : &_IndexParam_default_instance_); } static constexpr int kIndexInFileMessages = - 17; + 18; friend void swap(IndexParam& a, IndexParam& b) { a.Swap(&b); @@ -3238,7 +3398,7 @@ class FlushParam : &_FlushParam_default_instance_); } static constexpr int kIndexInFileMessages = - 18; + 19; friend void swap(FlushParam& a, FlushParam& b) { a.Swap(&b); @@ -3381,7 +3541,7 @@ class DeleteByIDParam : &_DeleteByIDParam_default_instance_); } static constexpr int kIndexInFileMessages = - 19; + 20; friend void swap(DeleteByIDParam& a, DeleteByIDParam& b) { a.Swap(&b); @@ -3532,7 +3692,7 @@ class CollectionInfo : &_CollectionInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 20; + 21; friend void swap(CollectionInfo& a, CollectionInfo& b) { a.Swap(&b); @@ -3679,7 +3839,7 @@ class VectorsIdentity : &_VectorsIdentity_default_instance_); } static constexpr int kIndexInFileMessages = - 21; + 22; friend void swap(VectorsIdentity& a, VectorsIdentity& b) { a.Swap(&b); @@ -3830,7 +3990,7 @@ class VectorsData : &_VectorsData_default_instance_); } static constexpr int kIndexInFileMessages = - 22; + 23; friend void swap(VectorsData& a, VectorsData& b) { a.Swap(&b); @@ -3977,7 +4137,7 @@ class GetVectorIDsParam : &_GetVectorIDsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 24; friend void swap(GetVectorIDsParam& a, GetVectorIDsParam& b) { a.Swap(&b); @@ -4127,7 +4287,7 @@ class VectorFieldParam : &_VectorFieldParam_default_instance_); } static constexpr int kIndexInFileMessages = - 24; + 25; friend void swap(VectorFieldParam& a, VectorFieldParam& b) { a.Swap(&b); @@ -4264,7 +4424,7 @@ class FieldType : &_FieldType_default_instance_); } static constexpr int kIndexInFileMessages = - 25; + 26; friend void swap(FieldType& a, FieldType& b) { a.Swap(&b); @@ -4420,7 +4580,7 @@ class FieldParam : &_FieldParam_default_instance_); } static constexpr int kIndexInFileMessages = - 26; + 27; friend void swap(FieldParam& a, FieldParam& b) { a.Swap(&b); @@ -4587,7 +4747,7 @@ class VectorFieldValue : &_VectorFieldValue_default_instance_); } static constexpr int kIndexInFileMessages = - 27; + 28; friend void swap(VectorFieldValue& a, VectorFieldValue& b) { a.Swap(&b); @@ -4735,7 +4895,7 @@ class FieldValue : &_FieldValue_default_instance_); } static constexpr int kIndexInFileMessages = - 28; + 29; friend void swap(FieldValue& a, FieldValue& b) { a.Swap(&b); @@ -4952,7 +5112,7 @@ class Mapping : &_Mapping_default_instance_); } static constexpr int kIndexInFileMessages = - 29; + 30; friend void swap(Mapping& a, Mapping& b) { a.Swap(&b); @@ -5119,7 +5279,7 @@ class MappingList : &_MappingList_default_instance_); } static constexpr int kIndexInFileMessages = - 30; + 31; friend void swap(MappingList& a, MappingList& b) { a.Swap(&b); @@ -5266,7 +5426,7 @@ class TermQuery : &_TermQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 31; + 32; friend void swap(TermQuery& a, TermQuery& b) { a.Swap(&b); @@ -5443,7 +5603,7 @@ class CompareExpr : &_CompareExpr_default_instance_); } static constexpr int kIndexInFileMessages = - 32; + 33; friend void swap(CompareExpr& a, CompareExpr& b) { a.Swap(&b); @@ -5587,7 +5747,7 @@ class RangeQuery : &_RangeQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 33; + 34; friend void swap(RangeQuery& a, RangeQuery& b) { a.Swap(&b); @@ -5757,7 +5917,7 @@ class VectorQuery : &_VectorQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 34; + 35; friend void swap(VectorQuery& a, VectorQuery& b) { a.Swap(&b); @@ -5934,7 +6094,7 @@ class BooleanQuery : &_BooleanQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 35; + 36; friend void swap(BooleanQuery& a, BooleanQuery& b) { a.Swap(&b); @@ -6086,7 +6246,7 @@ class GeneralQuery : &_GeneralQuery_default_instance_); } static constexpr int kIndexInFileMessages = - 36; + 37; friend void swap(GeneralQuery& a, GeneralQuery& b) { a.Swap(&b); @@ -6264,7 +6424,7 @@ class HSearchParam : &_HSearchParam_default_instance_); } static constexpr int kIndexInFileMessages = - 37; + 38; friend void swap(HSearchParam& a, HSearchParam& b) { a.Swap(&b); @@ -6443,7 +6603,7 @@ class HSearchInSegmentsParam : &_HSearchInSegmentsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 38; + 39; friend void swap(HSearchInSegmentsParam& a, HSearchInSegmentsParam& b) { a.Swap(&b); @@ -6596,7 +6756,7 @@ class AttrRecord : &_AttrRecord_default_instance_); } static constexpr int kIndexInFileMessages = - 39; + 40; friend void swap(AttrRecord& a, AttrRecord& b) { a.Swap(&b); @@ -6739,7 +6899,7 @@ class HEntity : &_HEntity_default_instance_); } static constexpr int kIndexInFileMessages = - 40; + 41; friend void swap(HEntity& a, HEntity& b) { a.Swap(&b); @@ -6932,7 +7092,7 @@ class HQueryResult : &_HQueryResult_default_instance_); } static constexpr int kIndexInFileMessages = - 41; + 42; friend void swap(HQueryResult& a, HQueryResult& b) { a.Swap(&b); @@ -7114,7 +7274,7 @@ class HInsertParam : &_HInsertParam_default_instance_); } static constexpr int kIndexInFileMessages = - 42; + 43; friend void swap(HInsertParam& a, HInsertParam& b) { a.Swap(&b); @@ -7301,7 +7461,7 @@ class HEntityIdentity : &_HEntityIdentity_default_instance_); } static constexpr int kIndexInFileMessages = - 43; + 44; friend void swap(HEntityIdentity& a, HEntityIdentity& b) { a.Swap(&b); @@ -7445,7 +7605,7 @@ class HEntityIDs : &_HEntityIDs_default_instance_); } static constexpr int kIndexInFileMessages = - 44; + 45; friend void swap(HEntityIDs& a, HEntityIDs& b) { a.Swap(&b); @@ -7593,7 +7753,7 @@ class HGetEntityIDsParam : &_HGetEntityIDsParam_default_instance_); } static constexpr int kIndexInFileMessages = - 45; + 46; friend void swap(HGetEntityIDsParam& a, HGetEntityIDsParam& b) { a.Swap(&b); @@ -7743,7 +7903,7 @@ class HDeleteByIDParam : &_HDeleteByIDParam_default_instance_); } static constexpr int kIndexInFileMessages = - 46; + 47; friend void swap(HDeleteByIDParam& a, HDeleteByIDParam& b) { a.Swap(&b); @@ -7894,7 +8054,7 @@ class HIndexParam : &_HIndexParam_default_instance_); } static constexpr int kIndexInFileMessages = - 47; + 48; friend void swap(HIndexParam& a, HIndexParam& b) { a.Swap(&b); @@ -9561,6 +9721,126 @@ SearchByIDParam::extra_params() const { // ------------------------------------------------------------------- +// ReLoadSegmentsParam + +// string collection_name = 1; +inline void ReLoadSegmentsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& ReLoadSegmentsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.ReLoadSegmentsParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void ReLoadSegmentsParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline void ReLoadSegmentsParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.ReLoadSegmentsParam.collection_name) +} +inline std::string* ReLoadSegmentsParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.ReLoadSegmentsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* ReLoadSegmentsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.ReLoadSegmentsParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void ReLoadSegmentsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.ReLoadSegmentsParam.collection_name) +} + +// repeated string segment_id_array = 2; +inline int ReLoadSegmentsParam::segment_id_array_size() const { + return segment_id_array_.size(); +} +inline void ReLoadSegmentsParam::clear_segment_id_array() { + segment_id_array_.Clear(); +} +inline const std::string& ReLoadSegmentsParam::segment_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Get(index); +} +inline std::string* ReLoadSegmentsParam::mutable_segment_id_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Mutable(index); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(value); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(std::move(value)); +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::set_segment_id_array(int index, const char* value, size_t size) { + segment_id_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline std::string* ReLoadSegmentsParam::add_segment_id_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_.Add(); +} +inline void ReLoadSegmentsParam::add_segment_id_array(const std::string& value) { + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(std::string&& value) { + segment_id_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline void ReLoadSegmentsParam::add_segment_id_array(const char* value, size_t size) { + segment_id_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.ReLoadSegmentsParam.segment_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ReLoadSegmentsParam::segment_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return segment_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ReLoadSegmentsParam::mutable_segment_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.ReLoadSegmentsParam.segment_id_array) + return &segment_id_array_; +} + +// ------------------------------------------------------------------- + // TopKQueryResult // .milvus.grpc.Status status = 1; @@ -13721,6 +14001,8 @@ HIndexParam::extra_params() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/shards/mishards/router/plugins/file_based_hash_ring_router.py b/shards/mishards/router/plugins/file_based_hash_ring_router.py index 8e691075bd..93d14022a0 100644 --- a/shards/mishards/router/plugins/file_based_hash_ring_router.py +++ b/shards/mishards/router/plugins/file_based_hash_ring_router.py @@ -1,3 +1,4 @@ +from collections import defaultdict import logging import re from sqlalchemy import exc as sqlalchemy_exc @@ -10,6 +11,28 @@ from mishards.hash_ring import HashRing logger = logging.getLogger(__name__) +file_updatetime_map = defaultdict(dict) + + +def filter_file_to_update(host, files_list): + host_files = file_updatetime_map[host] + + file_need_update_list = [] + for fl in files_list: + file_id, update_time = fl + pre_update_time = host_files.get(file_id, 0) + + if pre_update_time >= update_time: + continue + logger.debug("[{}] file id: {}. pre update time {} is small than {}" + .format(host, file_id, pre_update_time, update_time)) + host_files[file_id] = update_time + # if pre_update_time > 0: + file_need_update_list.append(file_id) + + return file_need_update_list + + class Factory(RouterMixin): name = 'FileBasedHashRingRouter' @@ -92,9 +115,16 @@ class Factory(RouterMixin): if not sub: sub = [] routing[target_host] = sub - routing[target_host].append(str(f.id)) + # routing[target_host].append({"id": str(f.id), "update_time": int(f.updated_time)}) + routing[target_host].append((str(f.id), int(f.updated_time))) - return routing + filter_routing = {} + for host, filess in routing.items(): + ud_files = filter_file_to_update(host, filess) + search_files = [f[0] for f in filess] + filter_routing[host] = (search_files, ud_files) + + return filter_routing @classmethod def Create(cls, **kwargs): diff --git a/shards/mishards/service_handler.py b/shards/mishards/service_handler.py index 0c8a5ecb8f..e6bb749e85 100644 --- a/shards/mishards/service_handler.py +++ b/shards/mishards/service_handler.py @@ -4,7 +4,6 @@ import json import ujson import multiprocessing -from concurrent.futures import ThreadPoolExecutor from milvus.grpc_gen import milvus_pb2, milvus_pb2_grpc, status_pb2 from milvus.client import types as Types from milvus import MetricType @@ -126,24 +125,25 @@ class ServiceHandler(milvus_pb2_grpc.MilvusServiceServicer): with self.tracer.start_span('do_search', child_of=p_span) as span: if len(routing) == 0: - logger.warning('SearchVector: partition_tags = {}'.format(partition_tags)) ft = self.router.connection().search(collection_id, topk, vectors, list(partition_tags), search_params, _async=True) ret = ft.result(raw=True) all_topk_results.append(ret) else: futures = [] - for addr, file_ids in routing.items(): + for addr, files_tuple in routing.items(): + search_file_ids, ud_file_ids = files_tuple + logger.info(f"<{addr}> needed update segment ids {ud_file_ids}") conn = self.router.query_conn(addr, metadata=metadata) start = time.time() + ud_file_ids and conn.reload_segments(collection_id, ud_file_ids) span = kwargs.get('span', None) span = span if span else (None if self.tracer.empty else context.get_active_span().context) with self.tracer.start_span('search_{}'.format(addr), child_of=span): - logger.warning("Search file ids is {}".format(file_ids)) future = conn.search_in_segment(collection_name=collection_id, - file_ids=file_ids, + file_ids=search_file_ids, query_records=vectors, top_k=topk, params=search_params, _async=True) @@ -579,6 +579,9 @@ class ServiceHandler(milvus_pb2_grpc.MilvusServiceServicer): return status_pb2.Status(error_code=_status.code, reason=_status.message) + def ReloadSegments(self, request, context): + raise NotImplementedError("Not implemented in mishards") + def _describe_index(self, collection_name, metadata=None): return self.router.connection(metadata=metadata).get_index_info(collection_name) diff --git a/shards/mishards/settings.py b/shards/mishards/settings.py index 3e4cba2b48..e270e76047 100644 --- a/shards/mishards/settings.py +++ b/shards/mishards/settings.py @@ -12,7 +12,7 @@ else: env.read_env() -SERVER_VERSIONS = ['0.9.0', '0.9.1'] +SERVER_VERSIONS = ['0.9.0', '0.9.1', '0.10.0'] DEBUG = env.bool('DEBUG', False) MAX_RETRY = env.int('MAX_RETRY', 3) diff --git a/shards/requirements.txt b/shards/requirements.txt index 05157d771d..c5597b6fad 100644 --- a/shards/requirements.txt +++ b/shards/requirements.txt @@ -14,8 +14,8 @@ py==1.8.0 pyasn1==0.4.7 pyasn1-modules==0.2.6 pylint==2.5.0 -pymilvus==0.2.12 -#pymilvus-test==0.3.17 +#pymilvus==0.2.12 +pymilvus-test==0.3.25 pyparsing==2.4.0 pytest==4.6.3 pytest-level==0.1.1