Skip to content

milvus
milvus

BaiXuePrincess / milvus
与 Fork 源项目一致

从无法访问的项目Fork

通知 7
Star 4
Fork 0
milvus
milvus

体验新版 GitCode，发现更多精彩内容 >>

提交 786e9c5a 编写于 作者: Y Yu Kun
浏览文件
操作

MS-592 Change showtables stream transport to unary 


Former-commit-id: c094aa407179fc9b5aea81fdda3fe849d7564bda
上级 cf3798dd
隐藏空白更改
内联 并排
Showing with 1366 addition and 567 deletion
cpp/CHANGELOG.md
浏览文件 @ 786e9c5a
......@@ -153,6 +153,7 @@ Please mark all change in change log and use the ticket from JIRA.
- MS-546 - Add simple mode resource_config
- MS-570 - Add prometheus docker-compose file
- MS-576 - Scheduler refactor
- MS-592 - Change showtables stream transport to unary
## New Feature
- MS-343 - Implement ResourceMgr
......
cpp/src/grpc/gen-milvus/milvus.grpc.pb.cc
浏览文件 @ 786e9c5a
......@@ -53,7 +53,7 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan
, rpcmethod_SearchInFiles_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_DescribeTable_(MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_CountTable_(MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_ShowTables_(MilvusService_method_names[9], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel)
, rpcmethod_ShowTables_(MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_Cmd_(MilvusService_method_names[10], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_DeleteByRange_(MilvusService_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
, rpcmethod_PreloadTable_(MilvusService_method_names[12], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
......@@ -313,20 +313,32 @@ void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext*
return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, false);
}
::grpc::ClientReader< ::milvus::grpc::TableName>* MilvusService::Stub::ShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request) {
return ::grpc_impl::internal::ClientReaderFactory< ::milvus::grpc::TableName>::Create(channel_.get(), rpcmethod_ShowTables_, context, request);
::grpc::Status MilvusService::Stub::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) {
return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTables_, context, request, response);
}
void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, ::milvus::grpc::Command* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TableName>* reactor) {
::grpc_impl::internal::ClientCallbackReaderFactory< ::milvus::grpc::TableName>::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, reactor);
void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)> f) {
::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f));
}
::grpc::ClientAsyncReader< ::milvus::grpc::TableName>* MilvusService::Stub::AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq, void* tag) {
return ::grpc_impl::internal::ClientAsyncReaderFactory< ::milvus::grpc::TableName>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, true, tag);
void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)> f) {
::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f));
}
::grpc::ClientAsyncReader< ::milvus::grpc::TableName>* MilvusService::Stub::PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return ::grpc_impl::internal::ClientAsyncReaderFactory< ::milvus::grpc::TableName>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, false, nullptr);
void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor);
}
void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor);
}
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, true);
}
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, false);
}
::grpc::Status MilvusService::Stub::Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) {
......@@ -517,8 +529,8 @@ MilvusService::Service::Service() {
std::mem_fn(&MilvusService::Service::CountTable), this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
MilvusService_method_names[9],
::grpc::internal::RpcMethod::SERVER_STREAMING,
new ::grpc::internal::ServerStreamingHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::TableName>(
::grpc::internal::RpcMethod::NORMAL_RPC,
new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(
std::mem_fn(&MilvusService::Service::ShowTables), this)));
AddMethod(new ::grpc::internal::RpcServiceMethod(
MilvusService_method_names[10],
......@@ -613,10 +625,10 @@ MilvusService::Service::~Service() {
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
::grpc::Status MilvusService::Service::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) {
::grpc::Status MilvusService::Service::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) {
(void) context;
(void) request;
(void) writer;
(void) response;
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
......
cpp/src/grpc/gen-milvus/milvus.grpc.pb.h
浏览文件 @ 786e9c5a
......@@ -192,14 +192,12 @@ class MilvusService final {
//
//
// @return table names.
std::unique_ptr< ::grpc::ClientReaderInterface< ::milvus::grpc::TableName>> ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request) {
return std::unique_ptr< ::grpc::ClientReaderInterface< ::milvus::grpc::TableName>>(ShowTablesRaw(context, request));
virtual ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) = 0;
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq));
}
std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq, void* tag) {
return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>>(AsyncShowTablesRaw(context, request, cq, tag));
}
std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>>(PrepareAsyncShowTablesRaw(context, request, cq));
std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq));
}
// *
// @brief Give the server status
......@@ -387,7 +385,10 @@ class MilvusService final {
//
//
// @return table names.
virtual void ShowTables(::grpc::ClientContext* context, ::milvus::grpc::Command* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TableName>* reactor) = 0;
virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) = 0;
virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) = 0;
virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
// *
// @brief Give the server status
//
......@@ -459,9 +460,8 @@ class MilvusService final {
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientReaderInterface< ::milvus::grpc::TableName>* ShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request) = 0;
virtual ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq, void* tag) = 0;
virtual ::grpc::ClientAsyncReaderInterface< ::milvus::grpc::TableName>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) = 0;
......@@ -539,14 +539,12 @@ class MilvusService final {
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq));
}
std::unique_ptr< ::grpc::ClientReader< ::milvus::grpc::TableName>> ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request) {
return std::unique_ptr< ::grpc::ClientReader< ::milvus::grpc::TableName>>(ShowTablesRaw(context, request));
}
std::unique_ptr< ::grpc::ClientAsyncReader< ::milvus::grpc::TableName>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq, void* tag) {
return std::unique_ptr< ::grpc::ClientAsyncReader< ::milvus::grpc::TableName>>(AsyncShowTablesRaw(context, request, cq, tag));
::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq));
}
std::unique_ptr< ::grpc::ClientAsyncReader< ::milvus::grpc::TableName>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncReader< ::milvus::grpc::TableName>>(PrepareAsyncShowTablesRaw(context, request, cq));
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq));
}
::grpc::Status Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) override;
std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>> AsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
......@@ -622,7 +620,10 @@ class MilvusService final {
void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) override;
void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
void ShowTables(::grpc::ClientContext* context, ::milvus::grpc::Command* request, ::grpc::experimental::ClientReadReactor< ::milvus::grpc::TableName>* reactor) override;
void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) override;
void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) override;
void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
......@@ -672,9 +673,8 @@ class MilvusService final {
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientReader< ::milvus::grpc::TableName>* ShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request) override;
::grpc::ClientAsyncReader< ::milvus::grpc::TableName>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq, void* tag) override;
::grpc::ClientAsyncReader< ::milvus::grpc::TableName>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) override;
......@@ -798,7 +798,7 @@ class MilvusService final {
//
//
// @return table names.
virtual ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer);
virtual ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response);
// *
// @brief Give the server status
//
......@@ -1027,12 +1027,12 @@ class MilvusService final {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
void RequestShowTables(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncWriter< ::milvus::grpc::TableName>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
::grpc::Service::RequestAsyncServerStreaming(9, context, request, writer, new_call_cq, notification_cq, tag);
void RequestShowTables(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
......@@ -1422,20 +1422,29 @@ class MilvusService final {
public:
ExperimentalWithCallbackMethod_ShowTables() {
::grpc::Service::experimental().MarkMethodCallback(9,
new ::grpc_impl::internal::CallbackServerStreamingHandler< ::milvus::grpc::Command, ::milvus::grpc::TableName>(
[this] { return this->ShowTables(); }));
new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(
[this](::grpc::ServerContext* context,
const ::milvus::grpc::Command* request,
::milvus::grpc::TableNameList* response,
::grpc::experimental::ServerCallbackRpcController* controller) {
return this->ShowTables(context, request, response, controller);
}));
}
void SetMessageAllocatorFor_ShowTables(
::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>* allocator) {
static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>*>(
::grpc::Service::experimental().GetHandler(9))
->SetMessageAllocator(allocator);
}
~ExperimentalWithCallbackMethod_ShowTables() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
virtual ::grpc::experimental::ServerWriteReactor< ::milvus::grpc::Command, ::milvus::grpc::TableName>* ShowTables() {
return new ::grpc_impl::internal::UnimplementedWriteReactor<
::milvus::grpc::Command, ::milvus::grpc::TableName>;}
virtual void ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
};
template <class BaseClass>
class ExperimentalWithCallbackMethod_Cmd : public BaseClass {
......@@ -1758,7 +1767,7 @@ class MilvusService final {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
......@@ -2040,12 +2049,12 @@ class MilvusService final {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
void RequestShowTables(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncWriter< ::grpc::ByteBuffer>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
::grpc::Service::RequestAsyncServerStreaming(9, context, request, writer, new_call_cq, notification_cq, tag);
void RequestShowTables(::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(9, context, request, response, new_call_cq, notification_cq, tag);
}
};
template <class BaseClass>
......@@ -2380,20 +2389,23 @@ class MilvusService final {
public:
ExperimentalWithRawCallbackMethod_ShowTables() {
::grpc::Service::experimental().MarkMethodRawCallback(9,
new ::grpc_impl::internal::CallbackServerStreamingHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
[this] { return this->ShowTables(); }));
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->ShowTables(context, request, response, controller);
}));
}
~ExperimentalWithRawCallbackMethod_ShowTables() override {
BaseClassMustBeDerivedFromService(this);
}
// disable synchronous version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
virtual ::grpc::experimental::ServerWriteReactor< ::grpc::ByteBuffer, ::grpc::ByteBuffer>* ShowTables() {
return new ::grpc_impl::internal::UnimplementedWriteReactor<
::grpc::ByteBuffer, ::grpc::ByteBuffer>;}
virtual void ShowTables(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
};
template <class BaseClass>
class ExperimentalWithRawCallbackMethod_Cmd : public BaseClass {
......@@ -2701,6 +2713,26 @@ class MilvusService final {
virtual ::grpc::Status StreamedCountTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableRowCount>* server_unary_streamer) = 0;
};
template <class BaseClass>
class WithStreamedUnaryMethod_ShowTables : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service *service) {}
public:
WithStreamedUnaryMethod_ShowTables() {
::grpc::Service::MarkMethodStreamed(9,
new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(std::bind(&WithStreamedUnaryMethod_ShowTables<BaseClass>::StreamedShowTables, this, std::placeholders::_1, std::placeholders::_2)));
}
~WithStreamedUnaryMethod_ShowTables() override {
BaseClassMustBeDerivedFromService(this);
}
// disable regular version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
// replace default version of method with streamed unary
virtual ::grpc::Status StreamedShowTables(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::TableNameList>* server_unary_streamer) = 0;
};
template <class BaseClass>
class WithStreamedUnaryMethod_Cmd : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service *service) {}
......@@ -2800,29 +2832,9 @@ class MilvusService final {
// replace default version of method with streamed unary
virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0;
};
typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > StreamedUnaryService;
template <class BaseClass>
class WithSplitStreamingMethod_ShowTables : public BaseClass {
private:
void BaseClassMustBeDerivedFromService(const Service *service) {}
public:
WithSplitStreamingMethod_ShowTables() {
::grpc::Service::MarkMethodStreamed(9,
new ::grpc::internal::SplitServerStreamingHandler< ::milvus::grpc::Command, ::milvus::grpc::TableName>(std::bind(&WithSplitStreamingMethod_ShowTables<BaseClass>::StreamedShowTables, this, std::placeholders::_1, std::placeholders::_2)));
}
~WithSplitStreamingMethod_ShowTables() override {
BaseClassMustBeDerivedFromService(this);
}
// disable regular version of this method
::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::grpc::ServerWriter< ::milvus::grpc::TableName>* writer) override {
abort();
return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
}
// replace default version of method with split streamed
virtual ::grpc::Status StreamedShowTables(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< ::milvus::grpc::Command,::milvus::grpc::TableName>* server_split_streamer) = 0;
};
typedef WithSplitStreamingMethod_ShowTables<Service > SplitStreamedService;
typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithSplitStreamingMethod_ShowTables<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > > StreamedService;
typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithStreamedUnaryMethod_ShowTables<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > > StreamedUnaryService;
typedef Service SplitStreamedService;
typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithStreamedUnaryMethod_ShowTables<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > > StreamedService;
};
} // namespace grpc
......
cpp/src/grpc/gen-milvus/milvus.pb.cc
浏览文件 @ 786e9c5a
......@@ -21,7 +21,6 @@ extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal
extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RowRecord_milvus_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParam_milvus_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_status_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_status_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableName_milvus_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TopKQueryResult_milvus_2eproto;
namespace milvus {
namespace grpc {
......@@ -29,6 +28,10 @@ class TableNameDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableName> _instance;
} _TableName_default_instance_;
class TableNameListDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableNameList> _instance;
} _TableNameList_default_instance_;
class TableSchemaDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableSchema> _instance;
......@@ -170,7 +173,7 @@ static void InitDefaultsscc_info_IndexParam_milvus_2eproto() {
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_IndexParam_milvus_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_IndexParam_milvus_2eproto}, {
&scc_info_TableName_milvus_2eproto.base,
&scc_info_Status_status_2eproto.base,
&scc_info_Index_milvus_2eproto.base,}};
static void InitDefaultsscc_info_InsertParam_milvus_2eproto() {
......@@ -287,8 +290,22 @@ static void InitDefaultsscc_info_TableName_milvus_2eproto() {
::milvus::grpc::TableName::InitAsDefaultInstance();
}
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableName_milvus_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableName_milvus_2eproto}, {
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TableName_milvus_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TableName_milvus_2eproto}, {}};
static void InitDefaultsscc_info_TableNameList_milvus_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
{
void* ptr = &::milvus::grpc::_TableNameList_default_instance_;
new (ptr) ::milvus::grpc::TableNameList();
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
}
::milvus::grpc::TableNameList::InitAsDefaultInstance();
}
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableNameList_milvus_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableNameList_milvus_2eproto}, {
&scc_info_Status_status_2eproto.base,}};
static void InitDefaultsscc_info_TableRowCount_milvus_2eproto() {
......@@ -319,7 +336,7 @@ static void InitDefaultsscc_info_TableSchema_milvus_2eproto() {
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableSchema_milvus_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableSchema_milvus_2eproto}, {
&scc_info_TableName_milvus_2eproto.base,}};
&scc_info_Status_status_2eproto.base,}};
static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
......@@ -367,7 +384,7 @@ static void InitDefaultsscc_info_VectorIds_milvus_2eproto() {
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorIds_milvus_2eproto}, {
&scc_info_Status_status_2eproto.base,}};
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[18];
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[19];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_milvus_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr;
......@@ -377,13 +394,20 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, status_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, table_name_),
~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, status_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, table_names_),
~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, status_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, table_name_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, dimension_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, index_file_size_),
......@@ -492,6 +516,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, status_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, table_name_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, index_),
~0u, // no _has_bits_
......@@ -504,27 +529,29 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{ 0, -1, sizeof(::milvus::grpc::TableName)},
{ 7, -1, sizeof(::milvus::grpc::TableSchema)},
{ 16, -1, sizeof(::milvus::grpc::Range)},
{ 23, -1, sizeof(::milvus::grpc::RowRecord)},
{ 29, -1, sizeof(::milvus::grpc::InsertParam)},
{ 37, -1, sizeof(::milvus::grpc::VectorIds)},
{ 44, -1, sizeof(::milvus::grpc::SearchParam)},
{ 54, -1, sizeof(::milvus::grpc::SearchInFilesParam)},
{ 61, -1, sizeof(::milvus::grpc::QueryResult)},
{ 68, -1, sizeof(::milvus::grpc::TopKQueryResult)},
{ 74, -1, sizeof(::milvus::grpc::TopKQueryResultList)},
{ 81, -1, sizeof(::milvus::grpc::StringReply)},
{ 88, -1, sizeof(::milvus::grpc::BoolReply)},
{ 95, -1, sizeof(::milvus::grpc::TableRowCount)},
{ 102, -1, sizeof(::milvus::grpc::Command)},
{ 108, -1, sizeof(::milvus::grpc::Index)},
{ 115, -1, sizeof(::milvus::grpc::IndexParam)},
{ 122, -1, sizeof(::milvus::grpc::DeleteByRangeParam)},
{ 6, -1, sizeof(::milvus::grpc::TableNameList)},
{ 13, -1, sizeof(::milvus::grpc::TableSchema)},
{ 23, -1, sizeof(::milvus::grpc::Range)},
{ 30, -1, sizeof(::milvus::grpc::RowRecord)},
{ 36, -1, sizeof(::milvus::grpc::InsertParam)},
{ 44, -1, sizeof(::milvus::grpc::VectorIds)},
{ 51, -1, sizeof(::milvus::grpc::SearchParam)},
{ 61, -1, sizeof(::milvus::grpc::SearchInFilesParam)},
{ 68, -1, sizeof(::milvus::grpc::QueryResult)},
{ 75, -1, sizeof(::milvus::grpc::TopKQueryResult)},
{ 81, -1, sizeof(::milvus::grpc::TopKQueryResultList)},
{ 88, -1, sizeof(::milvus::grpc::StringReply)},
{ 95, -1, sizeof(::milvus::grpc::BoolReply)},
{ 102, -1, sizeof(::milvus::grpc::TableRowCount)},
{ 109, -1, sizeof(::milvus::grpc::Command)},
{ 115, -1, sizeof(::milvus::grpc::Index)},
{ 122, -1, sizeof(::milvus::grpc::IndexParam)},
{ 130, -1, sizeof(::milvus::grpc::DeleteByRangeParam)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableName_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableNameList_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableSchema_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Range_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_RowRecord_default_instance_),
......@@ -546,72 +573,74 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] =
const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
"\n\014milvus.proto\022\013milvus.grpc\032\014status.prot"
"o\"D\n\tTableName\022#\n\006status\030\001 \001(\0132\023.milvus."
"grpc.Status\022\022\n\ntable_name\030\002 \001(\t\"z\n\013Table"
"Schema\022*\n\ntable_name\030\001 \001(\0132\026.milvus.grpc"
".TableName\022\021\n\tdimension\030\002 \001(\003\022\027\n\017index_f"
"ile_size\030\003 \001(\003\022\023\n\013metric_type\030\004 \001(\005\"/\n\005R"
"ange\022\023\n\013start_value\030\001 \001(\t\022\021\n\tend_value\030\002"
" \001(\t\" \n\tRowRecord\022\023\n\013vector_data\030\001 \003(\002\"i"
"\n\013InsertParam\022\022\n\ntable_name\030\001 \001(\t\0220\n\020row"
"_record_array\030\002 \003(\0132\026.milvus.grpc.RowRec"
"ord\022\024\n\014row_id_array\030\003 \003(\003\"I\n\tVectorIds\022#"
"\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017v"
"ector_id_array\030\002 \003(\003\"\242\001\n\013SearchParam\022\022\n\n"
"table_name\030\001 \001(\t\0222\n\022query_record_array\030\002"
" \003(\0132\026.milvus.grpc.RowRecord\022-\n\021query_ra"
"nge_array\030\003 \003(\0132\022.milvus.grpc.Range\022\014\n\004t"
"opk\030\004 \001(\003\022\016\n\006nprobe\030\005 \001(\003\"[\n\022SearchInFil"
"esParam\022\025\n\rfile_id_array\030\001 \003(\t\022.\n\014search"
"_param\030\002 \001(\0132\030.milvus.grpc.SearchParam\"+"
"\n\013QueryResult\022\n\n\002id\030\001 \001(\003\022\020\n\010distance\030\002 "
"\001(\001\"H\n\017TopKQueryResult\0225\n\023query_result_a"
"rrays\030\001 \003(\0132\030.milvus.grpc.QueryResult\"s\n"
"\023TopKQueryResultList\022#\n\006status\030\001 \001(\0132\023.m"
"ilvus.grpc.Status\0227\n\021topk_query_result\030\002"
" \003(\0132\034.milvus.grpc.TopKQueryResult\"H\n\013St"
"ringReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc."
"Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoolRepl"
"y\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\022"
"\n\nbool_reply\030\002 \001(\010\"M\n\rTableRowCount\022#\n\006s"
"tatus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017tabl"
"e_row_count\030\002 \001(\003\"\026\n\007Command\022\013\n\003cmd\030\001 \001("
"\t\"*\n\005Index\022\022\n\nindex_type\030\001 \001(\005\022\r\n\005nlist\030"
"\002 \001(\005\"[\n\nIndexParam\022*\n\ntable_name\030\001 \001(\0132"
"\026.milvus.grpc.TableName\022!\n\005index\030\002 \001(\0132\022"
".milvus.grpc.Index\"K\n\022DeleteByRangeParam"
"\022!\n\005range\030\001 \001(\0132\022.milvus.grpc.Range\022\022\n\nt"
"able_name\030\002 \001(\t2\356\007\n\rMilvusService\022>\n\013Cre"
"ateTable\022\030.milvus.grpc.TableSchema\032\023.mil"
"vus.grpc.Status\"\000\022<\n\010HasTable\022\026.milvus.g"
"rpc.TableName\032\026.milvus.grpc.BoolReply\"\000\022"
":\n\tDropTable\022\026.milvus.grpc.TableName\032\023.m"
"ilvus.grpc.Status\"\000\022=\n\013CreateIndex\022\027.mil"
"vus.grpc.IndexParam\032\023.milvus.grpc.Status"
"\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertParam\032\026"
".milvus.grpc.VectorIds\"\000\022F\n\006Search\022\030.mil"
"vus.grpc.SearchParam\032 .milvus.grpc.TopKQ"
"ueryResultList\"\000\022T\n\rSearchInFiles\022\037.milv"
"us.grpc.SearchInFilesParam\032 .milvus.grpc"
".TopKQueryResultList\"\000\022C\n\rDescribeTable\022"
"\026.milvus.grpc.TableName\032\030.milvus.grpc.Ta"
"bleSchema\"\000\022B\n\nCountTable\022\026.milvus.grpc."
"TableName\032\032.milvus.grpc.TableRowCount\"\000\022"
">\n\nShowTables\022\024.milvus.grpc.Command\032\026.mi"
"lvus.grpc.TableName\"\0000\001\0227\n\003Cmd\022\024.milvus."
"grpc.Command\032\030.milvus.grpc.StringReply\"\000"
"\022G\n\rDeleteByRange\022\037.milvus.grpc.DeleteBy"
"RangeParam\032\023.milvus.grpc.Status\"\000\022=\n\014Pre"
"loadTable\022\026.milvus.grpc.TableName\032\023.milv"
"us.grpc.Status\"\000\022B\n\rDescribeIndex\022\026.milv"
"us.grpc.TableName\032\027.milvus.grpc.IndexPar"
"am\"\000\022:\n\tDropIndex\022\026.milvus.grpc.TableNam"
"e\032\023.milvus.grpc.Status\"\000b\006proto3"
"o\"\037\n\tTableName\022\022\n\ntable_name\030\001 \001(\t\"I\n\rTa"
"bleNameList\022#\n\006status\030\001 \001(\0132\023.milvus.grp"
"c.Status\022\023\n\013table_names\030\002 \003(\t\"\207\001\n\013TableS"
"chema\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Stat"
"us\022\022\n\ntable_name\030\002 \001(\t\022\021\n\tdimension\030\003 \001("
"\003\022\027\n\017index_file_size\030\004 \001(\003\022\023\n\013metric_typ"
"e\030\005 \001(\005\"/\n\005Range\022\023\n\013start_value\030\001 \001(\t\022\021\n"
"\tend_value\030\002 \001(\t\" \n\tRowRecord\022\023\n\013vector_"
"data\030\001 \003(\002\"i\n\013InsertParam\022\022\n\ntable_name\030"
"\001 \001(\t\0220\n\020row_record_array\030\002 \003(\0132\026.milvus"
".grpc.RowRecord\022\024\n\014row_id_array\030\003 \003(\003\"I\n"
"\tVectorIds\022#\n\006status\030\001 \001(\0132\023.milvus.grpc"
".Status\022\027\n\017vector_id_array\030\002 \003(\003\"\242\001\n\013Sea"
"rchParam\022\022\n\ntable_name\030\001 \001(\t\0222\n\022query_re"
"cord_array\030\002 \003(\0132\026.milvus.grpc.RowRecord"
"\022-\n\021query_range_array\030\003 \003(\0132\022.milvus.grp"
"c.Range\022\014\n\004topk\030\004 \001(\003\022\016\n\006nprobe\030\005 \001(\003\"[\n"
"\022SearchInFilesParam\022\025\n\rfile_id_array\030\001 \003"
"(\t\022.\n\014search_param\030\002 \001(\0132\030.milvus.grpc.S"
"earchParam\"+\n\013QueryResult\022\n\n\002id\030\001 \001(\003\022\020\n"
"\010distance\030\002 \001(\001\"H\n\017TopKQueryResult\0225\n\023qu"
"ery_result_arrays\030\001 \003(\0132\030.milvus.grpc.Qu"
"eryResult\"s\n\023TopKQueryResultList\022#\n\006stat"
"us\030\001 \001(\0132\023.milvus.grpc.Status\0227\n\021topk_qu"
"ery_result\030\002 \003(\0132\034.milvus.grpc.TopKQuery"
"Result\"H\n\013StringReply\022#\n\006status\030\001 \001(\0132\023."
"milvus.grpc.Status\022\024\n\014string_reply\030\002 \001(\t"
"\"D\n\tBoolReply\022#\n\006status\030\001 \001(\0132\023.milvus.g"
"rpc.Status\022\022\n\nbool_reply\030\002 \001(\010\"M\n\rTableR"
"owCount\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St"
"atus\022\027\n\017table_row_count\030\002 \001(\003\"\026\n\007Command"
"\022\013\n\003cmd\030\001 \001(\t\"*\n\005Index\022\022\n\nindex_type\030\001 \001"
"(\005\022\r\n\005nlist\030\002 \001(\005\"h\n\nIndexParam\022#\n\006statu"
"s\030\001 \001(\0132\023.milvus.grpc.Status\022\022\n\ntable_na"
"me\030\002 \001(\t\022!\n\005index\030\003 \001(\0132\022.milvus.grpc.In"
"dex\"K\n\022DeleteByRangeParam\022!\n\005range\030\001 \001(\013"
"2\022.milvus.grpc.Range\022\022\n\ntable_name\030\002 \001(\t"
"2\360\007\n\rMilvusService\022>\n\013CreateTable\022\030.milv"
"us.grpc.TableSchema\032\023.milvus.grpc.Status"
"\"\000\022<\n\010HasTable\022\026.milvus.grpc.TableName\032\026"
".milvus.grpc.BoolReply\"\000\022:\n\tDropTable\022\026."
"milvus.grpc.TableName\032\023.milvus.grpc.Stat"
"us\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexP"
"aram\032\023.milvus.grpc.Status\"\000\022<\n\006Insert\022\030."
"milvus.grpc.InsertParam\032\026.milvus.grpc.Ve"
"ctorIds\"\000\022F\n\006Search\022\030.milvus.grpc.Search"
"Param\032 .milvus.grpc.TopKQueryResultList\""
"\000\022T\n\rSearchInFiles\022\037.milvus.grpc.SearchI"
"nFilesParam\032 .milvus.grpc.TopKQueryResul"
"tList\"\000\022C\n\rDescribeTable\022\026.milvus.grpc.T"
"ableName\032\030.milvus.grpc.TableSchema\"\000\022B\n\n"
"CountTable\022\026.milvus.grpc.TableName\032\032.mil"
"vus.grpc.TableRowCount\"\000\022@\n\nShowTables\022\024"
".milvus.grpc.Command\032\032.milvus.grpc.Table"
"NameList\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032"
"\030.milvus.grpc.StringReply\"\000\022G\n\rDeleteByR"
"ange\022\037.milvus.grpc.DeleteByRangeParam\032\023."
"milvus.grpc.Status\"\000\022=\n\014PreloadTable\022\026.m"
"ilvus.grpc.TableName\032\023.milvus.grpc.Statu"
"s\"\000\022B\n\rDescribeIndex\022\026.milvus.grpc.Table"
"Name\032\027.milvus.grpc.IndexParam\"\000\022:\n\tDropI"
"ndex\022\026.milvus.grpc.TableName\032\023.milvus.gr"
"pc.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[18] = {
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[19] = {
&scc_info_BoolReply_milvus_2eproto.base,
&scc_info_Command_milvus_2eproto.base,
&scc_info_DeleteByRangeParam_milvus_2eproto.base,
......@@ -625,6 +654,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil
&scc_info_SearchParam_milvus_2eproto.base,
&scc_info_StringReply_milvus_2eproto.base,
&scc_info_TableName_milvus_2eproto.base,
&scc_info_TableNameList_milvus_2eproto.base,
&scc_info_TableRowCount_milvus_2eproto.base,
&scc_info_TableSchema_milvus_2eproto.base,
&scc_info_TopKQueryResult_milvus_2eproto.base,
......@@ -634,10 +664,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", 2472,
&descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 18, 1,
&descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 2539,
&descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 19, 1,
schemas, file_default_instances, TableStruct_milvus_2eproto::offsets,
file_level_metadata_milvus_2eproto, 18, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto,
file_level_metadata_milvus_2eproto, 19, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto,
};
// Force running AddDescriptors() at dynamic initialization time.
......@@ -648,24 +678,11 @@ namespace grpc {
// ===================================================================
void TableName::InitAsDefaultInstance() {
::milvus::grpc::_TableName_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
::milvus::grpc::Status::internal_default_instance());
}
class TableName::_Internal {
public:
static const ::milvus::grpc::Status& status(const TableName* msg);
};
const ::milvus::grpc::Status&
TableName::_Internal::status(const TableName* msg) {
return *msg->status_;
}
void TableName::clear_status() {
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
status_ = nullptr;
}
TableName::TableName()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
......@@ -679,18 +696,12 @@ TableName::TableName(const TableName& from)
if (!from.table_name().empty()) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
if (from.has_status()) {
status_ = new ::milvus::grpc::Status(*from.status_);
} else {
status_ = nullptr;
}
// @@protoc_insertion_point(copy_constructor:milvus.grpc.TableName)
}
void TableName::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableName_milvus_2eproto.base);
table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
status_ = nullptr;
}
TableName::~TableName() {
......@@ -700,7 +711,6 @@ TableName::~TableName() {
void TableName::SharedDtor() {
table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (this != internal_default_instance()) delete status_;
}
void TableName::SetCachedSize(int size) const {
......@@ -719,6 +729,290 @@ void TableName::Clear() {
(void) cached_has_bits;
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TableName::_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 table_name = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableName.table_name");
CHK_(ptr);
} else goto handle_unusual;
continue;
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
CHK_(ptr != nullptr);
continue;
}
} // switch
} // while
success:
return ptr;
failure:
ptr = nullptr;
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TableName::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.TableName)
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 table_name = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_table_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.TableName.table_name"));
} 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.TableName)
return true;
failure:
// @@protoc_insertion_point(parse_failure:milvus.grpc.TableName)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void TableName::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:milvus.grpc.TableName)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// string table_name = 1;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableName.table_name");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
1, this->table_name(), 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.TableName)
}
::PROTOBUF_NAMESPACE_ID::uint8* TableName::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableName)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// string table_name = 1;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableName.table_name");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
1, this->table_name(), 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.TableName)
return target;
}
size_t TableName::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableName)
size_t total_size = 0;
if (_internal_metadata_.have_unknown_fields()) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
_internal_metadata_.unknown_fields());
}
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// string table_name = 1;
if (this->table_name().size() > 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->table_name());
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void TableName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableName)
GOOGLE_DCHECK_NE(&from, this);
const TableName* source =
::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableName>(
&from);
if (source == nullptr) {
// @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableName)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
// @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableName)
MergeFrom(*source);
}
}
void TableName::MergeFrom(const TableName& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableName)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.table_name().size() > 0) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
}
void TableName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableName)
if (&from == this) return;
Clear();
MergeFrom(from);
}
void TableName::CopyFrom(const TableName& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableName)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool TableName::IsInitialized() const {
return true;
}
void TableName::InternalSwap(TableName* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
}
::PROTOBUF_NAMESPACE_ID::Metadata TableName::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
void TableNameList::InitAsDefaultInstance() {
::milvus::grpc::_TableNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
::milvus::grpc::Status::internal_default_instance());
}
class TableNameList::_Internal {
public:
static const ::milvus::grpc::Status& status(const TableNameList* msg);
};
const ::milvus::grpc::Status&
TableNameList::_Internal::status(const TableNameList* msg) {
return *msg->status_;
}
void TableNameList::clear_status() {
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
status_ = nullptr;
}
TableNameList::TableNameList()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
// @@protoc_insertion_point(constructor:milvus.grpc.TableNameList)
}
TableNameList::TableNameList(const TableNameList& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr),
table_names_(from.table_names_) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
if (from.has_status()) {
status_ = new ::milvus::grpc::Status(*from.status_);
} else {
status_ = nullptr;
}
// @@protoc_insertion_point(copy_constructor:milvus.grpc.TableNameList)
}
void TableNameList::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableNameList_milvus_2eproto.base);
status_ = nullptr;
}
TableNameList::~TableNameList() {
// @@protoc_insertion_point(destructor:milvus.grpc.TableNameList)
SharedDtor();
}
void TableNameList::SharedDtor() {
if (this != internal_default_instance()) delete status_;
}
void TableNameList::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
const TableNameList& TableNameList::default_instance() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableNameList_milvus_2eproto.base);
return *internal_default_instance();
}
void TableNameList::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableNameList)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
table_names_.Clear();
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
......@@ -727,7 +1021,7 @@ void TableName::Clear() {
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* TableName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
const char* TableNameList::_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;
......@@ -741,11 +1035,16 @@ const char* TableName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::
CHK_(ptr);
} else goto handle_unusual;
continue;
// string table_name = 2;
// repeated string table_names = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableName.table_name");
CHK_(ptr);
ptr -= 1;
do {
ptr += 1;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_names(), ptr, ctx, "milvus.grpc.TableNameList.table_names");
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: {
......@@ -768,11 +1067,11 @@ failure:
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool TableName::MergePartialFromCodedStream(
bool TableNameList::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.TableName)
// @@protoc_insertion_point(parse_start:milvus.grpc.TableNameList)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
......@@ -789,15 +1088,16 @@ bool TableName::MergePartialFromCodedStream(
break;
}
// string table_name = 2;
// repeated string table_names = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_table_name()));
input, this->add_table_names()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
this->table_names(this->table_names_size() - 1).data(),
static_cast<int>(this->table_names(this->table_names_size() - 1).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.TableName.table_name"));
"milvus.grpc.TableNameList.table_names"));
} else {
goto handle_unusual;
}
......@@ -816,18 +1116,18 @@ bool TableName::MergePartialFromCodedStream(
}
}
success:
// @@protoc_insertion_point(parse_success:milvus.grpc.TableName)
// @@protoc_insertion_point(parse_success:milvus.grpc.TableNameList)
return true;
failure:
// @@protoc_insertion_point(parse_failure:milvus.grpc.TableName)
// @@protoc_insertion_point(parse_failure:milvus.grpc.TableNameList)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void TableName::SerializeWithCachedSizes(
void TableNameList::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:milvus.grpc.TableName)
// @@protoc_insertion_point(serialize_start:milvus.grpc.TableNameList)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
......@@ -837,26 +1137,26 @@ void TableName::SerializeWithCachedSizes(
1, _Internal::status(this), output);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
// repeated string table_names = 2;
for (int i = 0, n = this->table_names_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
this->table_names(i).data(), static_cast<int>(this->table_names(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableName.table_name");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->table_name(), output);
"milvus.grpc.TableNameList.table_names");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
2, this->table_names(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.TableName)
// @@protoc_insertion_point(serialize_end:milvus.grpc.TableNameList)
}
::PROTOBUF_NAMESPACE_ID::uint8* TableName::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* TableNameList::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableName)
// @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableNameList)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
......@@ -867,27 +1167,26 @@ void TableName::SerializeWithCachedSizes(
1, _Internal::status(this), target);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
// repeated string table_names = 2;
for (int i = 0, n = this->table_names_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
this->table_names(i).data(), static_cast<int>(this->table_names(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableName.table_name");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
2, this->table_name(), target);
"milvus.grpc.TableNameList.table_names");
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
WriteStringToArray(2, this->table_names(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.TableName)
// @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableNameList)
return target;
}
size_t TableName::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableName)
size_t TableNameList::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableNameList)
size_t total_size = 0;
if (_internal_metadata_.have_unknown_fields()) {
......@@ -899,11 +1198,12 @@ size_t TableName::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// string table_name = 2;
if (this->table_name().size() > 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->table_name());
// repeated string table_names = 2;
total_size += 1 *
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_names_size());
for (int i = 0, n = this->table_names_size(); i < n; i++) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->table_names(i));
}
// .milvus.grpc.Status status = 1;
......@@ -918,64 +1218,60 @@ size_t TableName::ByteSizeLong() const {
return total_size;
}
void TableName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableName)
void TableNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableNameList)
GOOGLE_DCHECK_NE(&from, this);
const TableName* source =
::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableName>(
const TableNameList* source =
::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableNameList>(
&from);
if (source == nullptr) {
// @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableName)
// @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableNameList)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
// @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableName)
// @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableNameList)
MergeFrom(*source);
}
}
void TableName::MergeFrom(const TableName& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableName)
void TableNameList::MergeFrom(const TableNameList& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableNameList)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.table_name().size() > 0) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
table_names_.MergeFrom(from.table_names_);
if (from.has_status()) {
mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
}
}
void TableName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableName)
void TableNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableNameList)
if (&from == this) return;
Clear();
MergeFrom(from);
}
void TableName::CopyFrom(const TableName& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableName)
void TableNameList::CopyFrom(const TableNameList& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableNameList)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool TableName::IsInitialized() const {
bool TableNameList::IsInitialized() const {
return true;
}
void TableName::InternalSwap(TableName* other) {
void TableNameList::InternalSwap(TableNameList* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
table_names_.InternalSwap(CastToBase(&other->table_names_));
swap(status_, other->status_);
}
::PROTOBUF_NAMESPACE_ID::Metadata TableName::GetMetadata() const {
::PROTOBUF_NAMESPACE_ID::Metadata TableNameList::GetMetadata() const {
return GetMetadataStatic();
}
......@@ -983,17 +1279,23 @@ void TableName::InternalSwap(TableName* other) {
// ===================================================================
void TableSchema::InitAsDefaultInstance() {
::milvus::grpc::_TableSchema_default_instance_._instance.get_mutable()->table_name_ = const_cast< ::milvus::grpc::TableName*>(
::milvus::grpc::TableName::internal_default_instance());
::milvus::grpc::_TableSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
::milvus::grpc::Status::internal_default_instance());
}
class TableSchema::_Internal {
public:
static const ::milvus::grpc::TableName& table_name(const TableSchema* msg);
static const ::milvus::grpc::Status& status(const TableSchema* msg);
};
const ::milvus::grpc::TableName&
TableSchema::_Internal::table_name(const TableSchema* msg) {
return *msg->table_name_;
const ::milvus::grpc::Status&
TableSchema::_Internal::status(const TableSchema* msg) {
return *msg->status_;
}
void TableSchema::clear_status() {
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
status_ = nullptr;
}
TableSchema::TableSchema()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
......@@ -1004,10 +1306,14 @@ TableSchema::TableSchema(const TableSchema& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
if (from.has_table_name()) {
table_name_ = new ::milvus::grpc::TableName(*from.table_name_);
table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.table_name().empty()) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
if (from.has_status()) {
status_ = new ::milvus::grpc::Status(*from.status_);
} else {
table_name_ = nullptr;
status_ = nullptr;
}
::memcpy(&dimension_, &from.dimension_,
static_cast<size_t>(reinterpret_cast<char*>(&metric_type_) -
......@@ -1017,9 +1323,10 @@ TableSchema::TableSchema(const TableSchema& from)
void TableSchema::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableSchema_milvus_2eproto.base);
::memset(&table_name_, 0, static_cast<size_t>(
table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(&status_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&metric_type_) -
reinterpret_cast<char*>(&table_name_)) + sizeof(metric_type_));
reinterpret_cast<char*>(&status_)) + sizeof(metric_type_));
}
TableSchema::~TableSchema() {
......@@ -1028,7 +1335,8 @@ TableSchema::~TableSchema() {
}
void TableSchema::SharedDtor() {
if (this != internal_default_instance()) delete table_name_;
table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (this != internal_default_instance()) delete status_;
}
void TableSchema::SetCachedSize(int size) const {
......@@ -1046,10 +1354,11 @@ void TableSchema::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
if (GetArenaNoVirtual() == nullptr && table_name_ != nullptr) {
delete table_name_;
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
table_name_ = nullptr;
status_ = nullptr;
::memset(&dimension_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&metric_type_) -
reinterpret_cast<char*>(&dimension_)) + sizeof(metric_type_));
......@@ -1064,30 +1373,37 @@ const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
// .milvus.grpc.TableName table_name = 1;
// .milvus.grpc.Status status = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
ptr = ctx->ParseMessage(mutable_table_name(), ptr);
ptr = ctx->ParseMessage(mutable_status(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// int64 dimension = 2;
// string table_name = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableSchema.table_name");
CHK_(ptr);
} else goto handle_unusual;
continue;
// int64 index_file_size = 3;
// int64 dimension = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
index_file_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// int32 metric_type = 4;
// int64 index_file_size = 4;
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
index_file_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// int32 metric_type = 5;
case 5:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
metric_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
} else goto handle_unusual;
......@@ -1122,20 +1438,35 @@ bool TableSchema::MergePartialFromCodedStream(
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// .milvus.grpc.TableName table_name = 1;
// .milvus.grpc.Status status = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_table_name()));
input, mutable_status()));
} else {
goto handle_unusual;
}
break;
}
// int64 dimension = 2;
// string table_name = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_table_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.TableSchema.table_name"));
} else {
goto handle_unusual;
}
break;
}
// int64 dimension = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
......@@ -1146,9 +1477,9 @@ bool TableSchema::MergePartialFromCodedStream(
break;
}
// int64 index_file_size = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
// int64 index_file_size = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
......@@ -1159,9 +1490,9 @@ bool TableSchema::MergePartialFromCodedStream(
break;
}
// int32 metric_type = 4;
case 4: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
// int32 metric_type = 5;
case 5: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
......@@ -1199,25 +1530,35 @@ void TableSchema::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
1, _Internal::table_name(this), output);
1, _Internal::status(this), output);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableSchema.table_name");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->table_name(), output);
}
// int64 dimension = 2;
// int64 dimension = 3;
if (this->dimension() != 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->dimension(), output);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->dimension(), output);
}
// int64 index_file_size = 3;
// int64 index_file_size = 4;
if (this->index_file_size() != 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->index_file_size(), output);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->index_file_size(), output);
}
// int32 metric_type = 4;
// int32 metric_type = 5;
if (this->metric_type() != 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(4, this->metric_type(), output);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(5, this->metric_type(), output);
}
if (_internal_metadata_.have_unknown_fields()) {
......@@ -1233,26 +1574,37 @@ void TableSchema::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(
1, _Internal::table_name(this), target);
1, _Internal::status(this), target);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.TableSchema.table_name");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
2, this->table_name(), target);
}
// int64 dimension = 2;
// int64 dimension = 3;
if (this->dimension() != 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->dimension(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->dimension(), target);
}
// int64 index_file_size = 3;
// int64 index_file_size = 4;
if (this->index_file_size() != 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->index_file_size(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->index_file_size(), target);
}
// int32 metric_type = 4;
// int32 metric_type = 5;
if (this->metric_type() != 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->metric_type(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->metric_type(), target);
}
if (_internal_metadata_.have_unknown_fields()) {
......@@ -1276,28 +1628,35 @@ size_t TableSchema::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// string table_name = 2;
if (this->table_name().size() > 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->table_name());
}
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*table_name_);
*status_);
}
// int64 dimension = 2;
// int64 dimension = 3;
if (this->dimension() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
this->dimension());
}
// int64 index_file_size = 3;
// int64 index_file_size = 4;
if (this->index_file_size() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
this->index_file_size());
}
// int32 metric_type = 4;
// int32 metric_type = 5;
if (this->metric_type() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
......@@ -1331,8 +1690,12 @@ void TableSchema::MergeFrom(const TableSchema& from) {
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.has_table_name()) {
mutable_table_name()->::milvus::grpc::TableName::MergeFrom(from.table_name());
if (from.table_name().size() > 0) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
if (from.has_status()) {
mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
}
if (from.dimension() != 0) {
set_dimension(from.dimension());
......@@ -1366,7 +1729,9 @@ bool TableSchema::IsInitialized() const {
void TableSchema::InternalSwap(TableSchema* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(table_name_, other->table_name_);
table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
swap(status_, other->status_);
swap(dimension_, other->dimension_);
swap(index_file_size_, other->index_file_size_);
swap(metric_type_, other->metric_type_);
......@@ -5928,25 +6293,31 @@ void Index::InternalSwap(Index* other) {
// ===================================================================
void IndexParam::InitAsDefaultInstance() {
::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->table_name_ = const_cast< ::milvus::grpc::TableName*>(
::milvus::grpc::TableName::internal_default_instance());
::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
::milvus::grpc::Status::internal_default_instance());
::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->index_ = const_cast< ::milvus::grpc::Index*>(
::milvus::grpc::Index::internal_default_instance());
}
class IndexParam::_Internal {
public:
static const ::milvus::grpc::TableName& table_name(const IndexParam* msg);
static const ::milvus::grpc::Status& status(const IndexParam* msg);
static const ::milvus::grpc::Index& index(const IndexParam* msg);
};
const ::milvus::grpc::TableName&
IndexParam::_Internal::table_name(const IndexParam* msg) {
return *msg->table_name_;
const ::milvus::grpc::Status&
IndexParam::_Internal::status(const IndexParam* msg) {
return *msg->status_;
}
const ::milvus::grpc::Index&
IndexParam::_Internal::index(const IndexParam* msg) {
return *msg->index_;
}
void IndexParam::clear_status() {
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
status_ = nullptr;
}
IndexParam::IndexParam()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
......@@ -5956,10 +6327,14 @@ IndexParam::IndexParam(const IndexParam& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
if (from.has_table_name()) {
table_name_ = new ::milvus::grpc::TableName(*from.table_name_);
table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.table_name().empty()) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
if (from.has_status()) {
status_ = new ::milvus::grpc::Status(*from.status_);
} else {
table_name_ = nullptr;
status_ = nullptr;
}
if (from.has_index()) {
index_ = new ::milvus::grpc::Index(*from.index_);
......@@ -5971,9 +6346,10 @@ IndexParam::IndexParam(const IndexParam& from)
void IndexParam::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParam_milvus_2eproto.base);
::memset(&table_name_, 0, static_cast<size_t>(
table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(&status_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&index_) -
reinterpret_cast<char*>(&table_name_)) + sizeof(index_));
reinterpret_cast<char*>(&status_)) + sizeof(index_));
}
IndexParam::~IndexParam() {
......@@ -5982,7 +6358,8 @@ IndexParam::~IndexParam() {
}
void IndexParam::SharedDtor() {
if (this != internal_default_instance()) delete table_name_;
table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (this != internal_default_instance()) delete status_;
if (this != internal_default_instance()) delete index_;
}
......@@ -6001,10 +6378,11 @@ void IndexParam::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
if (GetArenaNoVirtual() == nullptr && table_name_ != nullptr) {
delete table_name_;
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
delete status_;
}
table_name_ = nullptr;
status_ = nullptr;
if (GetArenaNoVirtual() == nullptr && index_ != nullptr) {
delete index_;
}
......@@ -6020,16 +6398,23 @@ const char* IndexParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
// .milvus.grpc.TableName table_name = 1;
// .milvus.grpc.Status status = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
ptr = ctx->ParseMessage(mutable_table_name(), ptr);
ptr = ctx->ParseMessage(mutable_status(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// .milvus.grpc.Index index = 2;
// string table_name = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.IndexParam.table_name");
CHK_(ptr);
} else goto handle_unusual;
continue;
// .milvus.grpc.Index index = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
ptr = ctx->ParseMessage(mutable_index(), ptr);
CHK_(ptr);
} else goto handle_unusual;
......@@ -6064,20 +6449,35 @@ bool IndexParam::MergePartialFromCodedStream(
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// .milvus.grpc.TableName table_name = 1;
// .milvus.grpc.Status status = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_table_name()));
input, mutable_status()));
} else {
goto handle_unusual;
}
break;
}
// .milvus.grpc.Index index = 2;
// string table_name = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_table_name()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.IndexParam.table_name"));
} else {
goto handle_unusual;
}
break;
}
// .milvus.grpc.Index index = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_index()));
} else {
......@@ -6113,16 +6513,26 @@ void IndexParam::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
1, _Internal::table_name(this), output);
1, _Internal::status(this), output);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.IndexParam.table_name");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->table_name(), output);
}
// .milvus.grpc.Index index = 2;
// .milvus.grpc.Index index = 3;
if (this->has_index()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
2, _Internal::index(this), output);
3, _Internal::index(this), output);
}
if (_internal_metadata_.have_unknown_fields()) {
......@@ -6138,18 +6548,29 @@ void IndexParam::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(
1, _Internal::table_name(this), target);
1, _Internal::status(this), target);
}
// string table_name = 2;
if (this->table_name().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->table_name().data(), static_cast<int>(this->table_name().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.IndexParam.table_name");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
2, this->table_name(), target);
}
// .milvus.grpc.Index index = 2;
// .milvus.grpc.Index index = 3;
if (this->has_index()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(
2, _Internal::index(this), target);
3, _Internal::index(this), target);
}
if (_internal_metadata_.have_unknown_fields()) {
......@@ -6173,14 +6594,21 @@ size_t IndexParam::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// .milvus.grpc.TableName table_name = 1;
if (this->has_table_name()) {
// string table_name = 2;
if (this->table_name().size() > 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->table_name());
}
// .milvus.grpc.Status status = 1;
if (this->has_status()) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*table_name_);
*status_);
}
// .milvus.grpc.Index index = 2;
// .milvus.grpc.Index index = 3;
if (this->has_index()) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
......@@ -6214,8 +6642,12 @@ void IndexParam::MergeFrom(const IndexParam& from) {
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.has_table_name()) {
mutable_table_name()->::milvus::grpc::TableName::MergeFrom(from.table_name());
if (from.table_name().size() > 0) {
table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
}
if (from.has_status()) {
mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
}
if (from.has_index()) {
mutable_index()->::milvus::grpc::Index::MergeFrom(from.index());
......@@ -6243,7 +6675,9 @@ bool IndexParam::IsInitialized() const {
void IndexParam::InternalSwap(IndexParam* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(table_name_, other->table_name_);
table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
swap(status_, other->status_);
swap(index_, other->index_);
}
......@@ -6588,6 +7022,9 @@ PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::milvus::grpc::TableName* Arena::CreateMaybeMessage< ::milvus::grpc::TableName >(Arena* arena) {
return Arena::CreateInternal< ::milvus::grpc::TableName >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage< ::milvus::grpc::TableNameList >(Arena* arena) {
return Arena::CreateInternal< ::milvus::grpc::TableNameList >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage< ::milvus::grpc::TableSchema >(Arena* arena) {
return Arena::CreateInternal< ::milvus::grpc::TableSchema >(arena);
}
......
cpp/src/grpc/gen-milvus/milvus.pb.h
浏览文件 @ 786e9c5a
......@@ -48,7 +48,7 @@ struct TableStruct_milvus_2eproto {
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18]
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[19]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
......@@ -96,6 +96,9 @@ extern StringReplyDefaultTypeInternal _StringReply_default_instance_;
class TableName;
class TableNameDefaultTypeInternal;
extern TableNameDefaultTypeInternal _TableName_default_instance_;
class TableNameList;
class TableNameListDefaultTypeInternal;
extern TableNameListDefaultTypeInternal _TableNameList_default_instance_;
class TableRowCount;
class TableRowCountDefaultTypeInternal;
extern TableRowCountDefaultTypeInternal _TableRowCount_default_instance_;
......@@ -127,6 +130,7 @@ template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvu
template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*);
template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*);
template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*);
template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::grpc::TableNameList>(Arena*);
template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*);
template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*);
template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*);
......@@ -251,10 +255,9 @@ class TableName :
// accessors -------------------------------------------------------
enum : int {
kTableNameFieldNumber = 2,
kStatusFieldNumber = 1,
kTableNameFieldNumber = 1,
};
// string table_name = 2;
// string table_name = 1;
void clear_table_name();
const std::string& table_name() const;
void set_table_name(const std::string& value);
......@@ -265,6 +268,150 @@ class TableName :
std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
// @@protoc_insertion_point(class_scope:milvus.grpc.TableName)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
};
// -------------------------------------------------------------------
class TableNameList :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableNameList) */ {
public:
TableNameList();
virtual ~TableNameList();
TableNameList(const TableNameList& from);
TableNameList(TableNameList&& from) noexcept
: TableNameList() {
*this = ::std::move(from);
}
inline TableNameList& operator=(const TableNameList& from) {
CopyFrom(from);
return *this;
}
inline TableNameList& operator=(TableNameList&& 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 TableNameList& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const TableNameList* internal_default_instance() {
return reinterpret_cast<const TableNameList*>(
&_TableNameList_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(TableNameList& a, TableNameList& b) {
a.Swap(&b);
}
inline void Swap(TableNameList* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline TableNameList* New() const final {
return CreateMaybeMessage<TableNameList>(nullptr);
}
TableNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<TableNameList>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const TableNameList& from);
void MergeFrom(const TableNameList& 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(TableNameList* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.grpc.TableNameList";
}
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 {
kTableNamesFieldNumber = 2,
kStatusFieldNumber = 1,
};
// repeated string table_names = 2;
int table_names_size() const;
void clear_table_names();
const std::string& table_names(int index) const;
std::string* mutable_table_names(int index);
void set_table_names(int index, const std::string& value);
void set_table_names(int index, std::string&& value);
void set_table_names(int index, const char* value);
void set_table_names(int index, const char* value, size_t size);
std::string* add_table_names();
void add_table_names(const std::string& value);
void add_table_names(std::string&& value);
void add_table_names(const char* value);
void add_table_names(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& table_names() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_table_names();
// .milvus.grpc.Status status = 1;
bool has_status() const;
void clear_status();
......@@ -273,12 +420,12 @@ class TableName :
::milvus::grpc::Status* mutable_status();
void set_allocated_status(::milvus::grpc::Status* status);
// @@protoc_insertion_point(class_scope:milvus.grpc.TableName)
// @@protoc_insertion_point(class_scope:milvus.grpc.TableNameList)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> table_names_;
::milvus::grpc::Status* status_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
......@@ -327,7 +474,7 @@ class TableSchema :
&_TableSchema_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
2;
friend void swap(TableSchema& a, TableSchema& b) {
a.Swap(&b);
......@@ -398,30 +545,42 @@ class TableSchema :
// accessors -------------------------------------------------------
enum : int {
kTableNameFieldNumber = 1,
kDimensionFieldNumber = 2,
kIndexFileSizeFieldNumber = 3,
kMetricTypeFieldNumber = 4,
kTableNameFieldNumber = 2,
kStatusFieldNumber = 1,
kDimensionFieldNumber = 3,
kIndexFileSizeFieldNumber = 4,
kMetricTypeFieldNumber = 5,
};
// .milvus.grpc.TableName table_name = 1;
bool has_table_name() const;
// string table_name = 2;
void clear_table_name();
const ::milvus::grpc::TableName& table_name() const;
::milvus::grpc::TableName* release_table_name();
::milvus::grpc::TableName* mutable_table_name();
void set_allocated_table_name(::milvus::grpc::TableName* table_name);
const std::string& table_name() const;
void set_table_name(const std::string& value);
void set_table_name(std::string&& value);
void set_table_name(const char* value);
void set_table_name(const char* value, size_t size);
std::string* mutable_table_name();
std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
// int64 dimension = 2;
// .milvus.grpc.Status status = 1;
bool has_status() const;
void clear_status();
const ::milvus::grpc::Status& status() const;
::milvus::grpc::Status* release_status();
::milvus::grpc::Status* mutable_status();
void set_allocated_status(::milvus::grpc::Status* status);
// int64 dimension = 3;
void clear_dimension();
::PROTOBUF_NAMESPACE_ID::int64 dimension() const;
void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value);
// int64 index_file_size = 3;
// int64 index_file_size = 4;
void clear_index_file_size();
::PROTOBUF_NAMESPACE_ID::int64 index_file_size() const;
void set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value);
// int32 metric_type = 4;
// int32 metric_type = 5;
void clear_metric_type();
::PROTOBUF_NAMESPACE_ID::int32 metric_type() const;
void set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value);
......@@ -431,7 +590,8 @@ class TableSchema :
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::milvus::grpc::TableName* table_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
::milvus::grpc::Status* status_;
::PROTOBUF_NAMESPACE_ID::int64 dimension_;
::PROTOBUF_NAMESPACE_ID::int64 index_file_size_;
::PROTOBUF_NAMESPACE_ID::int32 metric_type_;
......@@ -482,7 +642,7 @@ class Range :
&_Range_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
3;
friend void swap(Range& a, Range& b) {
a.Swap(&b);
......@@ -632,7 +792,7 @@ class RowRecord :
&_RowRecord_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
4;
friend void swap(RowRecord& a, RowRecord& b) {
a.Swap(&b);
......@@ -770,7 +930,7 @@ class InsertParam :
&_InsertParam_default_instance_);
}
static constexpr int kIndexInFileMessages =
4;
5;
friend void swap(InsertParam& a, InsertParam& b) {
a.Swap(&b);
......@@ -934,7 +1094,7 @@ class VectorIds :
&_VectorIds_default_instance_);
}
static constexpr int kIndexInFileMessages =
5;
6;
friend void swap(VectorIds& a, VectorIds& b) {
a.Swap(&b);
......@@ -1082,7 +1242,7 @@ class SearchParam :
&_SearchParam_default_instance_);
}
static constexpr int kIndexInFileMessages =
6;
7;
friend void swap(SearchParam& a, SearchParam& b) {
a.Swap(&b);
......@@ -1259,7 +1419,7 @@ class SearchInFilesParam :
&_SearchInFilesParam_default_instance_);
}
static constexpr int kIndexInFileMessages =
7;
8;
friend void swap(SearchInFilesParam& a, SearchInFilesParam& b) {
a.Swap(&b);
......@@ -1412,7 +1572,7 @@ class QueryResult :
&_QueryResult_default_instance_);
}
static constexpr int kIndexInFileMessages =
8;
9;
friend void swap(QueryResult& a, QueryResult& b) {
a.Swap(&b);
......@@ -1550,7 +1710,7 @@ class TopKQueryResult :
&_TopKQueryResult_default_instance_);
}
static constexpr int kIndexInFileMessages =
9;
10;
friend void swap(TopKQueryResult& a, TopKQueryResult& b) {
a.Swap(&b);
......@@ -1687,7 +1847,7 @@ class TopKQueryResultList :
&_TopKQueryResultList_default_instance_);
}
static constexpr int kIndexInFileMessages =
10;
11;
friend void swap(TopKQueryResultList& a, TopKQueryResultList& b) {
a.Swap(&b);
......@@ -1834,7 +1994,7 @@ class StringReply :
&_StringReply_default_instance_);
}
static constexpr int kIndexInFileMessages =
11;
12;
friend void swap(StringReply& a, StringReply& b) {
a.Swap(&b);
......@@ -1981,7 +2141,7 @@ class BoolReply :
&_BoolReply_default_instance_);
}
static constexpr int kIndexInFileMessages =
12;
13;
friend void swap(BoolReply& a, BoolReply& b) {
a.Swap(&b);
......@@ -2122,7 +2282,7 @@ class TableRowCount :
&_TableRowCount_default_instance_);
}
static constexpr int kIndexInFileMessages =
13;
14;
friend void swap(TableRowCount& a, TableRowCount& b) {
a.Swap(&b);
......@@ -2263,7 +2423,7 @@ class Command :
&_Command_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
15;
friend void swap(Command& a, Command& b) {
a.Swap(&b);
......@@ -2400,7 +2560,7 @@ class Index :
&_Index_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
16;
friend void swap(Index& a, Index& b) {
a.Swap(&b);
......@@ -2538,7 +2698,7 @@ class IndexParam :
&_IndexParam_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
17;
friend void swap(IndexParam& a, IndexParam& b) {
a.Swap(&b);
......@@ -2609,18 +2769,30 @@ class IndexParam :
// accessors -------------------------------------------------------
enum : int {
kTableNameFieldNumber = 1,
kIndexFieldNumber = 2,
kTableNameFieldNumber = 2,
kStatusFieldNumber = 1,
kIndexFieldNumber = 3,
};
// .milvus.grpc.TableName table_name = 1;
bool has_table_name() const;
// string table_name = 2;
void clear_table_name();
const ::milvus::grpc::TableName& table_name() const;
::milvus::grpc::TableName* release_table_name();
::milvus::grpc::TableName* mutable_table_name();
void set_allocated_table_name(::milvus::grpc::TableName* table_name);
const std::string& table_name() const;
void set_table_name(const std::string& value);
void set_table_name(std::string&& value);
void set_table_name(const char* value);
void set_table_name(const char* value, size_t size);
std::string* mutable_table_name();
std::string* release_table_name();
void set_allocated_table_name(std::string* table_name);
// .milvus.grpc.Status status = 1;
bool has_status() const;
void clear_status();
const ::milvus::grpc::Status& status() const;
::milvus::grpc::Status* release_status();
::milvus::grpc::Status* mutable_status();
void set_allocated_status(::milvus::grpc::Status* status);
// .milvus.grpc.Index index = 2;
// .milvus.grpc.Index index = 3;
bool has_index() const;
void clear_index();
const ::milvus::grpc::Index& index() const;
......@@ -2633,7 +2805,8 @@ class IndexParam :
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::milvus::grpc::TableName* table_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
::milvus::grpc::Status* status_;
::milvus::grpc::Index* index_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
......@@ -2682,7 +2855,7 @@ class DeleteByRangeParam :
&_DeleteByRangeParam_default_instance_);
}
static constexpr int kIndexInFileMessages =
17;
18;
friend void swap(DeleteByRangeParam& a, DeleteByRangeParam& b) {
a.Swap(&b);
......@@ -2796,52 +2969,7 @@ class DeleteByRangeParam :
#endif // __GNUC__
// TableName
// .milvus.grpc.Status status = 1;
inline bool TableName::has_status() const {
return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::grpc::Status& TableName::status() const {
const ::milvus::grpc::Status* p = status_;
// @@protoc_insertion_point(field_get:milvus.grpc.TableName.status)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
&::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* TableName::release_status() {
// @@protoc_insertion_point(field_release:milvus.grpc.TableName.status)
::milvus::grpc::Status* temp = status_;
status_ = nullptr;
return temp;
}
inline ::milvus::grpc::Status* TableName::mutable_status() {
if (status_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
status_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableName.status)
return status_;
}
inline void TableName::set_allocated_status(::milvus::grpc::Status* status) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
}
if (status) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, status, submessage_arena);
}
} else {
}
status_ = status;
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableName.status)
}
// string table_name = 2;
// string table_name = 1;
inline void TableName::clear_table_name() {
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
......@@ -2894,60 +3022,219 @@ inline void TableName::set_allocated_table_name(std::string* table_name) {
// -------------------------------------------------------------------
// TableSchema
// TableNameList
// .milvus.grpc.TableName table_name = 1;
inline bool TableSchema::has_table_name() const {
return this != internal_default_instance() && table_name_ != nullptr;
// .milvus.grpc.Status status = 1;
inline bool TableNameList::has_status() const {
return this != internal_default_instance() && status_ != nullptr;
}
inline void TableSchema::clear_table_name() {
if (GetArenaNoVirtual() == nullptr && table_name_ != nullptr) {
delete table_name_;
inline const ::milvus::grpc::Status& TableNameList::status() const {
const ::milvus::grpc::Status* p = status_;
// @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.status)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
&::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* TableNameList::release_status() {
// @@protoc_insertion_point(field_release:milvus.grpc.TableNameList.status)
::milvus::grpc::Status* temp = status_;
status_ = nullptr;
return temp;
}
inline ::milvus::grpc::Status* TableNameList::mutable_status() {
if (status_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
status_ = p;
}
table_name_ = nullptr;
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.status)
return status_;
}
inline const ::milvus::grpc::TableName& TableSchema::table_name() const {
const ::milvus::grpc::TableName* p = table_name_;
// @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::TableName*>(
&::milvus::grpc::_TableName_default_instance_);
inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
}
if (status) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, status, submessage_arena);
}
} else {
}
status_ = status;
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableNameList.status)
}
inline ::milvus::grpc::TableName* TableSchema::release_table_name() {
// @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name)
// repeated string table_names = 2;
inline int TableNameList::table_names_size() const {
return table_names_.size();
}
inline void TableNameList::clear_table_names() {
table_names_.Clear();
}
inline const std::string& TableNameList::table_names(int index) const {
// @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.table_names)
return table_names_.Get(index);
}
inline std::string* TableNameList::mutable_table_names(int index) {
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.table_names)
return table_names_.Mutable(index);
}
inline void TableNameList::set_table_names(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
table_names_.Mutable(index)->assign(value);
}
inline void TableNameList::set_table_names(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
table_names_.Mutable(index)->assign(std::move(value));
}
inline void TableNameList::set_table_names(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
table_names_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::set_table_names(int index, const char* value, size_t size) {
table_names_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableNameList.table_names)
}
inline std::string* TableNameList::add_table_names() {
// @@protoc_insertion_point(field_add_mutable:milvus.grpc.TableNameList.table_names)
return table_names_.Add();
}
inline void TableNameList::add_table_names(const std::string& value) {
table_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(std::string&& value) {
table_names_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(const char* value) {
GOOGLE_DCHECK(value != nullptr);
table_names_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:milvus.grpc.TableNameList.table_names)
}
inline void TableNameList::add_table_names(const char* value, size_t size) {
table_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:milvus.grpc.TableNameList.table_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TableNameList::table_names() const {
// @@protoc_insertion_point(field_list:milvus.grpc.TableNameList.table_names)
return table_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TableNameList::mutable_table_names() {
// @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableNameList.table_names)
return &table_names_;
}
// -------------------------------------------------------------------
// TableSchema
// .milvus.grpc.Status status = 1;
inline bool TableSchema::has_status() const {
return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::grpc::Status& TableSchema::status() const {
const ::milvus::grpc::Status* p = status_;
// @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.status)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
&::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::Status* TableSchema::release_status() {
// @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.status)
::milvus::grpc::TableName* temp = table_name_;
table_name_ = nullptr;
::milvus::grpc::Status* temp = status_;
status_ = nullptr;
return temp;
}
inline ::milvus::grpc::TableName* TableSchema::mutable_table_name() {
inline ::milvus::grpc::Status* TableSchema::mutable_status() {
if (table_name_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::TableName>(GetArenaNoVirtual());
table_name_ = p;
if (status_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
status_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name)
return table_name_;
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.status)
return status_;
}
inline void TableSchema::set_allocated_table_name(::milvus::grpc::TableName* table_name) {
inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete table_name_;
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
}
if (table_name) {
if (status) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
table_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, table_name, submessage_arena);
status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, status, submessage_arena);
}
} else {
}
table_name_ = table_name;
status_ = status;
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.status)
}
// string table_name = 2;
inline void TableSchema::clear_table_name() {
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& TableSchema::table_name() const {
// @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name)
return table_name_.GetNoArena();
}
inline void TableSchema::set_table_name(const std::string& value) {
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.table_name)
}
inline void TableSchema::set_table_name(std::string&& value) {
table_name_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableSchema.table_name)
}
inline void TableSchema::set_table_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.grpc.TableSchema.table_name)
}
inline void TableSchema::set_table_name(const char* value, size_t size) {
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableSchema.table_name)
}
inline std::string* TableSchema::mutable_table_name() {
// @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name)
return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TableSchema::release_table_name() {
// @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name)
return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TableSchema::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.table_name)
}
// int64 dimension = 2;
// int64 dimension = 3;
inline void TableSchema::clear_dimension() {
dimension_ = PROTOBUF_LONGLONG(0);
}
......@@ -2961,7 +3248,7 @@ inline void TableSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) {
// @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.dimension)
}
// int64 index_file_size = 3;
// int64 index_file_size = 4;
inline void TableSchema::clear_index_file_size() {
index_file_size_ = PROTOBUF_LONGLONG(0);
}
......@@ -2975,7 +3262,7 @@ inline void TableSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 valu
// @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_file_size)
}
// int32 metric_type = 4;
// int32 metric_type = 5;
inline void TableSchema::clear_metric_type() {
metric_type_ = 0;
}
......@@ -4048,58 +4335,103 @@ inline void Index::set_nlist(::PROTOBUF_NAMESPACE_ID::int32 value) {
// IndexParam
// .milvus.grpc.TableName table_name = 1;
inline bool IndexParam::has_table_name() const {
return this != internal_default_instance() && table_name_ != nullptr;
}
inline void IndexParam::clear_table_name() {
if (GetArenaNoVirtual() == nullptr && table_name_ != nullptr) {
delete table_name_;
}
table_name_ = nullptr;
// .milvus.grpc.Status status = 1;
inline bool IndexParam::has_status() const {
return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::grpc::TableName& IndexParam::table_name() const {
const ::milvus::grpc::TableName* p = table_name_;
// @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::TableName*>(
&::milvus::grpc::_TableName_default_instance_);
inline const ::milvus::grpc::Status& IndexParam::status() const {
const ::milvus::grpc::Status* p = status_;
// @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.status)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
&::milvus::grpc::_Status_default_instance_);
}
inline ::milvus::grpc::TableName* IndexParam::release_table_name() {
// @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name)
inline ::milvus::grpc::Status* IndexParam::release_status() {
// @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.status)
::milvus::grpc::TableName* temp = table_name_;
table_name_ = nullptr;
::milvus::grpc::Status* temp = status_;
status_ = nullptr;
return temp;
}
inline ::milvus::grpc::TableName* IndexParam::mutable_table_name() {
inline ::milvus::grpc::Status* IndexParam::mutable_status() {
if (table_name_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::TableName>(GetArenaNoVirtual());
table_name_ = p;
if (status_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
status_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name)
return table_name_;
// @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.status)
return status_;
}
inline void IndexParam::set_allocated_table_name(::milvus::grpc::TableName* table_name) {
inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete table_name_;
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
}
if (table_name) {
if (status) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
table_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, table_name, submessage_arena);
status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, status, submessage_arena);
}
} else {
}
table_name_ = table_name;
status_ = status;
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.status)
}
// string table_name = 2;
inline void IndexParam::clear_table_name() {
table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& IndexParam::table_name() const {
// @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name)
return table_name_.GetNoArena();
}
inline void IndexParam::set_table_name(const std::string& value) {
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.table_name)
}
inline void IndexParam::set_table_name(std::string&& value) {
table_name_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.table_name)
}
inline void IndexParam::set_table_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.table_name)
}
inline void IndexParam::set_table_name(const char* value, size_t size) {
table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.table_name)
}
inline std::string* IndexParam::mutable_table_name() {
// @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name)
return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* IndexParam::release_table_name() {
// @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name)
return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void IndexParam::set_allocated_table_name(std::string* table_name) {
if (table_name != nullptr) {
} else {
}
table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.table_name)
}
// .milvus.grpc.Index index = 2;
// .milvus.grpc.Index index = 3;
inline bool IndexParam::has_index() const {
return this != internal_default_instance() && index_ != nullptr;
}
......@@ -4293,6 +4625,8 @@ inline void DeleteByRangeParam::set_allocated_table_name(std::string* table_name
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
......
cpp/src/grpc/milvus.proto
浏览文件 @ 786e9c5a
......@@ -8,18 +8,26 @@ package milvus.grpc;
* @brief Table Name
*/
message TableName {
string table_name = 1;
}
/**
* @brief Table Name List
*/
message TableNameList {
Status status = 1;
string table_name = 2;
repeated string table_names = 2;
}
/**
* @brief Table Schema
*/
message TableSchema {
TableName table_name = 1;
int64 dimension = 2;
int64 index_file_size = 3;
int32 metric_type = 4;
Status status = 1;
string table_name = 2;
int64 dimension = 3;
int64 index_file_size = 4;
int32 metric_type = 5;
}
/**
......@@ -141,8 +149,9 @@ message Index {
* @brief Index params
*/
message IndexParam {
TableName table_name = 1;
Index index = 2;
Status status = 1;
string table_name = 2;
Index index = 3;
}
/**
......@@ -264,7 +273,7 @@ service MilvusService {
*
* @return table names.
*/
rpc ShowTables(Command) returns (stream TableName) {}
rpc ShowTables(Command) returns (TableNameList) {}
/**
* @brief Give the server status
......
cpp/src/sdk/examples/grpcsimple/src/ClientTest.cpp
浏览文件 @ 786e9c5a
......@@ -227,9 +227,9 @@ ClientTest::Test(const std::string& address, const std::string& port) {
std::cout << "All tables: " << std::endl;
for(auto& table : tables) {
int64_t row_count = 0;
conn->DropTable(table);
// stat = conn->CountTable(table, row_count);
// std::cout << "\t" << table << "(" << row_count << " rows)" << std::endl;
// conn->DropTable(table);
stat = conn->CountTable(table, row_count);
std::cout << "\t" << table << "(" << row_count << " rows)" << std::endl;
}
}
......@@ -343,8 +343,8 @@ ClientTest::Test(const std::string& address, const std::string& port) {
}
{//delete table
Status stat = conn->DropTable(TABLE_NAME);
std::cout << "DeleteTable function call status: " << stat.message() << std::endl;
// Status stat = conn->DropTable(TABLE_NAME);
// std::cout << "DeleteTable function call status: " << stat.message() << std::endl;
}
{//server status
......
cpp/src/sdk/grpc/ClientProxy.cpp
浏览文件 @ 786e9c5a
......@@ -93,7 +93,7 @@ Status
ClientProxy::CreateTable(const TableSchema &param) {
try {
::milvus::grpc::TableSchema schema;
schema.mutable_table_name()->set_table_name(param.table_name);
schema.set_table_name(param.table_name);
schema.set_dimension(param.dimension);
schema.set_index_file_size(param.index_file_size);
schema.set_metric_type((int32_t)param.metric_type);
......@@ -129,7 +129,7 @@ ClientProxy::CreateIndex(const IndexParam &index_param) {
try {
//TODO:add index params
::milvus::grpc::IndexParam grpc_index_param;
grpc_index_param.mutable_table_name()->set_table_name(index_param.table_name);
grpc_index_param.set_table_name(index_param.table_name);
grpc_index_param.mutable_index()->set_index_type((int32_t)index_param.index_type);
grpc_index_param.mutable_index()->set_nlist(index_param.nlist);
return client_ptr_->CreateIndex(grpc_index_param);
......@@ -281,7 +281,7 @@ ClientProxy::DescribeTable(const std::string &table_name, TableSchema &table_sch
Status status = client_ptr_->DescribeTable(grpc_schema, table_name);
table_schema.table_name = grpc_schema.table_name().table_name();
table_schema.table_name = grpc_schema.table_name();
table_schema.dimension = grpc_schema.dimension();
table_schema.index_file_size = grpc_schema.index_file_size();
table_schema.metric_type = (MetricType)grpc_schema.metric_type();
......@@ -307,7 +307,15 @@ ClientProxy::CountTable(const std::string &table_name, int64_t &row_count) {
Status
ClientProxy::ShowTables(std::vector<std::string> &table_array) {
try {
return client_ptr_->ShowTables(table_array);
Status status;
milvus::grpc::TableNameList table_name_list;
status = client_ptr_->ShowTables(table_name_list);
table_array.resize(table_name_list.table_names_size());
for (uint64_t i = 0; i < table_name_list.table_names_size(); ++i) {
table_array[i] = table_name_list.table_names(i);
}
return status;
} catch (std::exception &ex) {
return Status(StatusCode::UnknownError, "fail to show tables: " + std::string(ex.what()));
......
cpp/src/sdk/grpc/GrpcClient.cpp
浏览文件 @ 786e9c5a
......@@ -167,10 +167,10 @@ GrpcClient::DescribeTable(::milvus::grpc::TableSchema& grpc_schema,
return Status(StatusCode::RPCFailed, grpc_status.error_message());
}
if (grpc_schema.table_name().status().error_code() != grpc::SUCCESS) {
std::cerr << grpc_schema.table_name().status().reason() << std::endl;
if (grpc_schema.status().error_code() != grpc::SUCCESS) {
std::cerr << grpc_schema.status().reason() << std::endl;
return Status(StatusCode::ServerFailed,
grpc_schema.table_name().status().reason());
grpc_schema.status().reason());
}
return Status::OK();
......@@ -201,17 +201,10 @@ GrpcClient::CountTable(const std::string& table_name, Status& status) {
}
Status
GrpcClient::ShowTables(std::vector<std::string> &table_array) {
GrpcClient::ShowTables(milvus::grpc::TableNameList &table_name_list) {
ClientContext context;
::milvus::grpc::Command command;
std::unique_ptr<ClientReader<::milvus::grpc::TableName> > reader(
stub_->ShowTables(&context, command));
::milvus::grpc::TableName table_name;
while (reader->Read(&table_name)) {
table_array.emplace_back(table_name.table_name());
}
::grpc::Status grpc_status = reader->Finish();
::grpc::Status grpc_status = stub_->ShowTables(&context, command, &table_name_list);
if (!grpc_status.ok()) {
std::cerr << "ShowTables gRPC failed!" << std::endl;
......@@ -219,10 +212,10 @@ GrpcClient::ShowTables(std::vector<std::string> &table_array) {
return Status(StatusCode::RPCFailed, grpc_status.error_message());
}
if (table_name.status().error_code() != grpc::SUCCESS) {
std::cerr << table_name.status().reason() << std::endl;
if (table_name_list.status().error_code() != grpc::SUCCESS) {
std::cerr << table_name_list.status().reason() << std::endl;
return Status(StatusCode::ServerFailed,
table_name.status().reason());
table_name_list.status().reason());
}
return Status::OK();
......@@ -302,9 +295,9 @@ GrpcClient::DescribeIndex(grpc::TableName &table_name, grpc::IndexParam &index_p
std::cerr << "DescribeIndex rpc failed!" << std::endl;
return Status(StatusCode::RPCFailed, grpc_status.error_message());
}
if (index_param.mutable_table_name()->status().error_code() != grpc::SUCCESS) {
std::cerr << index_param.mutable_table_name()->status().reason() << std::endl;
return Status(StatusCode::ServerFailed, index_param.mutable_table_name()->status().reason());
if (index_param.status().error_code() != grpc::SUCCESS) {
std::cerr << index_param.status().reason() << std::endl;
return Status(StatusCode::ServerFailed, index_param.status().reason());
}
return Status::OK();
......
cpp/src/sdk/grpc/GrpcClient.h
浏览文件 @ 786e9c5a
......@@ -73,7 +73,7 @@ public:
CountTable(const std::string& table_name, Status& status);
Status
ShowTables(std::vector<std::string> &table_array);
ShowTables(milvus::grpc::TableNameList &table_name_list);
Status
Cmd(std::string &result, const std::string& cmd);
......
cpp/src/server/grpc_impl/GrpcRequestHandler.cpp
浏览文件 @ 786e9c5a
......@@ -122,8 +122,8 @@ GrpcRequestHandler::DescribeTable(::grpc::ServerContext *context,
BaseTaskPtr task_ptr = DescribeTableTask::Create(request->table_name(), response);
::milvus::grpc::Status grpc_status;
GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
response->mutable_table_name()->mutable_status()->set_error_code(grpc_status.error_code());
response->mutable_table_name()->mutable_status()->set_reason(grpc_status.reason());
response->mutable_status()->set_error_code(grpc_status.error_code());
response->mutable_status()->set_reason(grpc_status.reason());
return ::grpc::Status::OK;
}
......@@ -145,17 +145,14 @@ GrpcRequestHandler::CountTable(::grpc::ServerContext *context,
::grpc::Status
GrpcRequestHandler::ShowTables(::grpc::ServerContext *context,
const ::milvus::grpc::Command *request,
::grpc::ServerWriter<::milvus::grpc::TableName> *writer) {
::milvus::grpc::TableNameList *response) {
BaseTaskPtr task_ptr = ShowTablesTask::Create(writer);
BaseTaskPtr task_ptr = ShowTablesTask::Create(response);
::milvus::grpc::Status grpc_status;
GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
if (grpc_status.error_code() != SERVER_SUCCESS) {
::grpc::Status status(::grpc::UNKNOWN, grpc_status.reason());
return status;
} else {
return ::grpc::Status::OK;
}
response->mutable_status()->set_error_code(grpc_status.error_code());
response->mutable_status()->set_reason(grpc_status.reason());
return ::grpc::Status::OK;
}
::grpc::Status
......@@ -204,8 +201,8 @@ GrpcRequestHandler::DescribeIndex(::grpc::ServerContext *context,
BaseTaskPtr task_ptr = DescribeIndexTask::Create(request->table_name(), response);
::milvus::grpc::Status grpc_status;
GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
response->mutable_table_name()->mutable_status()->set_reason(grpc_status.reason());
response->mutable_table_name()->mutable_status()->set_error_code(grpc_status.error_code());
response->mutable_status()->set_reason(grpc_status.reason());
response->mutable_status()->set_error_code(grpc_status.error_code());
return ::grpc::Status::OK;
}
......
cpp/src/server/grpc_impl/GrpcRequestHandler.h
浏览文件 @ 786e9c5a
......@@ -234,7 +234,7 @@ public:
::grpc::Status
ShowTables(::grpc::ServerContext *context,
const ::milvus::grpc::Command *request,
::grpc::ServerWriter<::milvus::grpc::TableName> *writer) override;
::milvus::grpc::TableNameList *table_name_list) override;
/**
* @brief Give the server status
......
cpp/src/server/grpc_impl/GrpcRequestTask.cpp
浏览文件 @ 786e9c5a
......@@ -137,7 +137,7 @@ CreateTableTask::OnExecute() {
try {
//step 1: check arguments
auto status = ValidationUtil::ValidateTableName(schema_->table_name().table_name());
auto status = ValidationUtil::ValidateTableName(schema_->table_name());
if (!status.ok()) {
return status;
}
......@@ -159,7 +159,7 @@ CreateTableTask::OnExecute() {
//step 2: construct table schema
engine::meta::TableSchema table_info;
table_info.table_id_ = schema_->table_name().table_name();
table_info.table_id_ = schema_->table_name();
table_info.dimension_ = (uint16_t) schema_->dimension();
table_info.index_file_size_ = schema_->index_file_size();
table_info.metric_type_ = schema_->metric_type();
......@@ -214,7 +214,7 @@ DescribeTableTask::OnExecute() {
return status;
}
schema_->mutable_table_name()->set_table_name(table_info.table_id_);
schema_->set_table_name(table_info.table_id_);
schema_->set_dimension(table_info.dimension_);
schema_->set_index_file_size(table_info.index_file_size_);
schema_->set_metric_type(table_info.metric_type_);
......@@ -249,7 +249,7 @@ CreateIndexTask::OnExecute() {
TimeRecorder rc("CreateIndexTask");
//step 1: check arguments
std::string table_name_ = index_param_->table_name().table_name();
std::string table_name_ = index_param_->table_name();
auto status = ValidationUtil::ValidateTableName(table_name_);
if (!status.ok()) {
return status;
......@@ -384,15 +384,15 @@ DropTableTask::OnExecute() {
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ShowTablesTask::ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> *writer)
ShowTablesTask::ShowTablesTask(::milvus::grpc::TableNameList *table_name_list)
: GrpcBaseTask(DDL_DML_TASK_GROUP),
writer_(writer) {
table_name_list_(table_name_list) {
}
BaseTaskPtr
ShowTablesTask::Create(::grpc::ServerWriter<::milvus::grpc::TableName> *writer) {
return std::shared_ptr<GrpcBaseTask>(new ShowTablesTask(writer));
ShowTablesTask::Create(::milvus::grpc::TableNameList *table_name_list) {
return std::shared_ptr<GrpcBaseTask>(new ShowTablesTask(table_name_list));
}
Status
......@@ -404,11 +404,7 @@ ShowTablesTask::OnExecute() {
}
for (auto &schema : schema_array) {
::milvus::grpc::TableName tableName;
tableName.set_table_name(schema.table_id_);
if (!writer_->Write(tableName)) {
return Status(SERVER_WRITE_ERROR, "Write table name failed!");
}
table_name_list_->add_table_names(schema.table_id_);
}
return Status::OK();
}
......@@ -920,7 +916,7 @@ DescribeIndexTask::OnExecute() {
return status;
}
index_param_->mutable_table_name()->set_table_name(table_name_);
index_param_->set_table_name(table_name_);
index_param_->mutable_index()->set_index_type(index.engine_type_);
index_param_->mutable_index()->set_nlist(index.nlist_);
......
cpp/src/server/grpc_impl/GrpcRequestTask.h
浏览文件 @ 786e9c5a
......@@ -124,17 +124,17 @@ private:
class ShowTablesTask : public GrpcBaseTask {
public:
static BaseTaskPtr
Create(::grpc::ServerWriter<::milvus::grpc::TableName> *writer);
Create(::milvus::grpc::TableNameList *table_name_list);
protected:
explicit
ShowTablesTask(::grpc::ServerWriter<::milvus::grpc::TableName> *writer);
ShowTablesTask(::milvus::grpc::TableNameList *table_name_list);
Status
OnExecute() override;
private:
::grpc::ServerWriter<::milvus::grpc::TableName> *writer_;
::milvus::grpc::TableNameList *table_name_list_;
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
......
cpp/unittest/CMakeLists.txt
浏览文件 @ 786e9c5a
......@@ -72,7 +72,7 @@ set(unittest_files
${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
set(helper_files
${MILVUS_ENGINE_SRC}/server/ServerConfig.cpp
# ${MILVUS_ENGINE_SRC}/server/ServerConfig.cpp
${MILVUS_ENGINE_SRC}/utils/CommonUtil.cpp
${MILVUS_ENGINE_SRC}/utils/TimeRecorder.cpp
${MILVUS_ENGINE_SRC}/utils/Status.cpp
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或