diff --git a/core/src/CMakeLists.txt b/core/src/CMakeLists.txt index 0d6b6e71a1..6b8150cb64 100644 --- a/core/src/CMakeLists.txt +++ b/core/src/CMakeLists.txt @@ -46,6 +46,10 @@ set(grpc_service_files ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc ) +aux_source_directory(${MILVUS_ENGINE_SRC}/query query_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/context context_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/search search_files) + aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler scheduler_main_files) aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/action scheduler_action_files) aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/event scheduler_event_files) @@ -74,11 +78,13 @@ set(thirdparty_files aux_source_directory(${MILVUS_ENGINE_SRC}/server server_service_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/request delivery_request_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/hybrid_request delivery_hybrid_request_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/strategy delivery_strategy_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery delivery_files) set(server_files ${server_service_files} ${delivery_request_files} + ${delivery_hybrid_request_files} ${delivery_strategy_files} ${delivery_files} ) @@ -284,6 +290,9 @@ add_executable(milvus_server ${config_files} ${config_handler_files} ${metrics_files} + ${query_files} + ${search_files} + ${context_files} ${scheduler_files} ${server_files} ${grpc_server_files} diff --git a/core/src/codecs/AttrsFormat.h b/core/src/codecs/AttrsFormat.h index 6b4fb3b6b3..012493f18d 100644 --- a/core/src/codecs/AttrsFormat.h +++ b/core/src/codecs/AttrsFormat.h @@ -17,17 +17,28 @@ #pragma once +#include +#include + +#include "segment/Attrs.h" +#include "storage/FSHandler.h" + namespace milvus { namespace codec { class AttrsFormat { - // public: - // virtual Attrs - // read() = 0; - // - // virtual void - // write(Attrs attrs) = 0; + public: + virtual void + read(const storage::FSHandlerPtr& fs_ptr, segment::AttrsPtr& attrs_read) = 0; + + virtual void + write(const storage::FSHandlerPtr& fs_ptr, const segment::AttrsPtr& attr) = 0; + + virtual void + read_uids(const storage::FSHandlerPtr& fs_ptr, std::vector& uids) = 0; }; +using AttrsFormatPtr = std::shared_ptr; + } // namespace codec } // namespace milvus diff --git a/core/src/codecs/Codec.h b/core/src/codecs/Codec.h index 4242585547..1148b01416 100644 --- a/core/src/codecs/Codec.h +++ b/core/src/codecs/Codec.h @@ -33,6 +33,9 @@ class Codec { virtual VectorsFormatPtr GetVectorsFormat() = 0; + virtual AttrsFormatPtr + GetAttrsFormat() = 0; + virtual VectorIndexFormatPtr GetVectorIndexFormat() = 0; diff --git a/core/src/codecs/default/DefaultAttrsFormat.cpp b/core/src/codecs/default/DefaultAttrsFormat.cpp new file mode 100644 index 0000000000..fe8937a859 --- /dev/null +++ b/core/src/codecs/default/DefaultAttrsFormat.cpp @@ -0,0 +1,247 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "codecs/default/DefaultAttrsFormat.h" + +#include +#include +#include +#include + +#include + +#include "utils/Exception.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" + +namespace milvus { +namespace codec { + +void +DefaultAttrsFormat::read_attrs_internal(const std::string& file_path, off_t offset, size_t num, + std::vector& raw_attrs, size_t& nbytes) { + int ra_fd = open(file_path.c_str(), O_RDONLY, 00664); + if (ra_fd == -1) { + std::string err_msg = "Failed to open file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_CANNOT_CREATE_FILE, err_msg); + } + + size_t num_bytes; + if (::read(ra_fd, &num_bytes, sizeof(size_t)) == -1) { + std::string err_msg = "Failed to read from file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + num = std::min(num, num_bytes - offset); + + offset += sizeof(size_t); + int off = lseek(ra_fd, offset, SEEK_SET); + if (off == -1) { + std::string err_msg = "Failed to seek file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + raw_attrs.resize(num / sizeof(uint8_t)); + if (::read(ra_fd, raw_attrs.data(), num) == -1) { + std::string err_msg = "Failed to read from file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + nbytes = num; + + if (::close(ra_fd) == -1) { + std::string err_msg = "Failed to close file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } +} + +void +DefaultAttrsFormat::read_uids_internal(const std::string& file_path, std::vector& uids) { + int uid_fd = open(file_path.c_str(), O_RDONLY, 00664); + if (uid_fd == -1) { + std::string err_msg = "Failed to open file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_CANNOT_CREATE_FILE, err_msg); + } + + size_t num_bytes; + if (::read(uid_fd, &num_bytes, sizeof(size_t)) == -1) { + std::string err_msg = "Failed to read from file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + uids.resize(num_bytes / sizeof(int64_t)); + if (::read(uid_fd, uids.data(), num_bytes) == -1) { + std::string err_msg = "Failed to read from file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + if (::close(uid_fd) == -1) { + std::string err_msg = "Failed to close file: " + file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } +} + +void +DefaultAttrsFormat::read(const milvus::storage::FSHandlerPtr& fs_ptr, milvus::segment::AttrsPtr& attrs_read) { + const std::lock_guard lock(mutex_); + + std::string dir_path = fs_ptr->operation_ptr_->GetDirectory(); + if (!boost::filesystem::is_directory(dir_path)) { + std::string err_msg = "Directory: " + dir_path + "does not exist"; + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_INVALID_ARGUMENT, err_msg); + } + + boost::filesystem::path target_path(dir_path); + typedef boost::filesystem::directory_iterator d_it; + d_it it_end; + d_it uid_it(target_path); + std::vector uids; + for (; uid_it != it_end; ++uid_it) { + const auto& path = uid_it->path(); + if (path.extension().string() == user_id_extension_) { + read_uids_internal(path.string(), uids); + break; + } + } + + d_it it(target_path); + for (; it != it_end; ++it) { + const auto& path = it->path(); + if (path.extension().string() == raw_attr_extension_) { + auto file_name = path.filename().string(); + auto field_name = file_name.substr(0, file_name.size() - 3); + // void* attr_list; + std::vector attr_list; + size_t nbytes; + read_attrs_internal(path.string(), 0, INT64_MAX, attr_list, nbytes); + milvus::segment::AttrPtr attr = + std::make_shared(attr_list, nbytes, uids, field_name); + attrs_read->attrs.insert(std::pair(field_name, attr)); + } + } +} + +void +DefaultAttrsFormat::write(const milvus::storage::FSHandlerPtr& fs_ptr, const milvus::segment::AttrsPtr& attrs_ptr) { + const std::lock_guard lock(mutex_); + + TimeRecorder rc("write attributes"); + + std::string dir_path = fs_ptr->operation_ptr_->GetDirectory(); + + auto it = attrs_ptr->attrs.begin(); + if (it == attrs_ptr->attrs.end()) { + std::string err_msg = "Attributes is null"; + LOG_ENGINE_ERROR_ << err_msg; + return; + } + +#if 0 + const std::string uid_file_path = dir_path + "/" + it->second->GetCollectionId() + user_id_extension_; + + int uid_fd = open(uid_file_path.c_str(), O_WRONLY | O_TRUNC | O_CREAT, 00664); + if (uid_fd == -1) { + std::string err_msg = "Failed to open file: " + uid_file_path + ", error: " + std::strerror(errno); + ENGINE_LOG_ERROR << err_msg; + throw Exception(SERVER_CANNOT_CREATE_FILE, err_msg); + } + size_t uid_num_bytes = it->second->GetUids().size() * sizeof(int64_t); + if (::write(uid_fd, &uid_num_bytes, sizeof(size_t)) == -1) { + std::string err_msg = "Failed to write to file" + uid_file_path + ", error: " + std::strerror(errno); + ENGINE_LOG_ERROR << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + if (::write(uid_fd, it->second->GetUids().data(), uid_num_bytes) == -1) { + std::string err_msg = "Failed to write to file" + uid_file_path + ", error: " + std::strerror(errno); + ENGINE_LOG_ERROR << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + if (::close(uid_fd) == -1) { + std::string err_msg = "Failed to close file: " + uid_file_path + ", error: " + std::strerror(errno); + ENGINE_LOG_ERROR << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + rc.RecordSection("write uids done"); +#endif + + for (; it != attrs_ptr->attrs.end(); it++) { + const std::string ra_file_path = dir_path + "/" + it->second->GetName() + raw_attr_extension_; + + int ra_fd = open(ra_file_path.c_str(), O_WRONLY | O_TRUNC | O_CREAT, 00664); + if (ra_fd == -1) { + std::string err_msg = "Failed to open file: " + ra_file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_CANNOT_CREATE_FILE, err_msg); + } + + size_t ra_num_bytes = it->second->GetNbytes(); + if (::write(ra_fd, &ra_num_bytes, sizeof(size_t)) == -1) { + std::string err_msg = "Failed to write to file: " + ra_file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + if (::write(ra_fd, it->second->GetData().data(), ra_num_bytes) == -1) { + std::string err_msg = "Failed to write to file: " + ra_file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + if (::close(ra_fd) == -1) { + std::string err_msg = "Failed to close file: " + ra_file_path + ", error: " + std::strerror(errno); + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_WRITE_ERROR, err_msg); + } + + rc.RecordSection("write rv done"); + } +} + +void +DefaultAttrsFormat::read_uids(const milvus::storage::FSHandlerPtr& fs_ptr, std::vector& uids) { + const std::lock_guard lock(mutex_); + + std::string dir_path = fs_ptr->operation_ptr_->GetDirectory(); + if (!boost::filesystem::is_directory(dir_path)) { + std::string err_msg = "Directory: " + dir_path + "does not exist"; + LOG_ENGINE_ERROR_ << err_msg; + throw Exception(SERVER_INVALID_ARGUMENT, err_msg); + } + + boost::filesystem::path target_path(dir_path); + typedef boost::filesystem::directory_iterator d_it; + d_it it_end; + d_it it(target_path); + // for (auto& it : boost::filesystem::directory_iterator(dir_path)) { + for (; it != it_end; ++it) { + const auto& path = it->path(); + if (path.extension().string() == user_id_extension_) { + read_uids_internal(path.string(), uids); + } + } +} + +} // namespace codec +} // namespace milvus diff --git a/core/src/codecs/default/DefaultAttrsFormat.h b/core/src/codecs/default/DefaultAttrsFormat.h new file mode 100644 index 0000000000..40b8418238 --- /dev/null +++ b/core/src/codecs/default/DefaultAttrsFormat.h @@ -0,0 +1,67 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include + +#include "codecs/AttrsFormat.h" +#include "segment/Attrs.h" + +namespace milvus { +namespace codec { + +class DefaultAttrsFormat : public AttrsFormat { + public: + DefaultAttrsFormat() = default; + + void + read(const storage::FSHandlerPtr& fs_ptr, segment::AttrsPtr& attrs_read) override; + + void + write(const storage::FSHandlerPtr& fs_ptr, const segment::AttrsPtr& attr) override; + + void + read_uids(const storage::FSHandlerPtr& fs_ptr, std::vector& uids) override; + + // No copy and move + DefaultAttrsFormat(const DefaultAttrsFormat&) = delete; + DefaultAttrsFormat(DefaultAttrsFormat&&) = delete; + + DefaultAttrsFormat& + operator=(const DefaultAttrsFormat&) = delete; + DefaultAttrsFormat& + operator=(DefaultAttrsFormat&&) = delete; + + private: + void + read_attrs_internal(const std::string&, off_t, size_t, std::vector&, size_t&); + + void + read_uids_internal(const std::string&, std::vector&); + + private: + std::mutex mutex_; + + const std::string raw_attr_extension_ = ".ra"; + const std::string user_id_extension_ = ".uid"; +}; + +} // namespace codec +} // namespace milvus diff --git a/core/src/codecs/default/DefaultCodec.cpp b/core/src/codecs/default/DefaultCodec.cpp index 71ceacd348..d5dfd2d63a 100644 --- a/core/src/codecs/default/DefaultCodec.cpp +++ b/core/src/codecs/default/DefaultCodec.cpp @@ -19,6 +19,7 @@ #include +#include "DefaultAttrsFormat.h" #include "DefaultDeletedDocsFormat.h" #include "DefaultIdBloomFilterFormat.h" #include "DefaultVectorIndexFormat.h" @@ -29,6 +30,7 @@ namespace codec { DefaultCodec::DefaultCodec() { vectors_format_ptr_ = std::make_shared(); + attrs_format_ptr_ = std::make_shared(); vector_index_format_ptr_ = std::make_shared(); deleted_docs_format_ptr_ = std::make_shared(); id_bloom_filter_format_ptr_ = std::make_shared(); @@ -39,6 +41,11 @@ DefaultCodec::GetVectorsFormat() { return vectors_format_ptr_; } +AttrsFormatPtr +DefaultCodec::GetAttrsFormat() { + return attrs_format_ptr_; +} + VectorIndexFormatPtr DefaultCodec::GetVectorIndexFormat() { return vector_index_format_ptr_; diff --git a/core/src/codecs/default/DefaultCodec.h b/core/src/codecs/default/DefaultCodec.h index 63a25833fb..c53695de8c 100644 --- a/core/src/codecs/default/DefaultCodec.h +++ b/core/src/codecs/default/DefaultCodec.h @@ -29,6 +29,9 @@ class DefaultCodec : public Codec { VectorsFormatPtr GetVectorsFormat() override; + AttrsFormatPtr + GetAttrsFormat() override; + VectorIndexFormatPtr GetVectorIndexFormat() override; @@ -40,6 +43,7 @@ class DefaultCodec : public Codec { private: VectorsFormatPtr vectors_format_ptr_; + AttrsFormatPtr attrs_format_ptr_; VectorIndexFormatPtr vector_index_format_ptr_; DeletedDocsFormatPtr deleted_docs_format_ptr_; IdBloomFilterFormatPtr id_bloom_filter_format_ptr_; diff --git a/core/src/context/HybridSearchContext.h b/core/src/context/HybridSearchContext.h new file mode 100644 index 0000000000..976af1adc4 --- /dev/null +++ b/core/src/context/HybridSearchContext.h @@ -0,0 +1,39 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include + +#include "query/BinaryQuery.h" +#include "search/Task.h" + +namespace milvus { +namespace search { +class Task; + +using TaskPtr = std::shared_ptr; +} // namespace search + +namespace context { + +struct HybridSearchContext { + query::GeneralQueryPtr general_query_; + std::vector<::milvus::search::TaskPtr> tasks_; +}; + +using HybridSearchContextPtr = std::shared_ptr; + +} // namespace context +} // namespace milvus diff --git a/core/src/db/DB.h b/core/src/db/DB.h index c6a68d3ee5..ce51f33962 100644 --- a/core/src/db/DB.h +++ b/core/src/db/DB.h @@ -13,11 +13,14 @@ #include #include +#include #include #include "Options.h" #include "Types.h" +#include "context/HybridSearchContext.h" #include "meta/Meta.h" +#include "query/GeneralQuery.h" #include "server/context/Context.h" #include "utils/Status.h" @@ -142,6 +145,23 @@ class DB { virtual Status DropAll() = 0; + + virtual Status + CreateHybridCollection(meta::CollectionSchema& collection_schema, meta::hybrid::FieldsSchema& fields_schema) = 0; + + virtual Status + DescribeHybridCollection(meta::CollectionSchema& collection_schema, meta::hybrid::FieldsSchema& fields_schema) = 0; + + virtual Status + InsertEntities(const std::string& collection_id, const std::string& partition_tag, Entity& entity, + std::unordered_map& field_types) = 0; + + virtual Status + HybridQuery(const std::shared_ptr& context, const std::string& collection_id, + const std::vector& partition_tags, context::HybridSearchContextPtr hybrid_search_context, + query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, + engine::ResultIds& result_ids, engine::ResultDistances& result_distances) = 0; }; // DB using DBPtr = std::shared_ptr; diff --git a/core/src/db/DBImpl.cpp b/core/src/db/DBImpl.cpp index c1f61fc81a..310d70955c 100644 --- a/core/src/db/DBImpl.cpp +++ b/core/src/db/DBImpl.cpp @@ -21,8 +21,10 @@ #include #include #include +#include #include #include +#include #include #include "Utils.h" @@ -50,6 +52,8 @@ #include "utils/ValidationUtil.h" #include "wal/WalDefinations.h" +#include "search/TaskInst.h" + namespace milvus { namespace engine { @@ -208,6 +212,31 @@ DBImpl::CreateCollection(meta::CollectionSchema& collection_schema) { return meta_ptr_->CreateCollection(temp_schema); } +Status +DBImpl::CreateHybridCollection(meta::CollectionSchema& collection_schema, meta::hybrid::FieldsSchema& fields_schema) { + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + meta::CollectionSchema temp_schema = collection_schema; + if (options_.wal_enable_) { + // TODO(yukun): wal_mgr_->CreateHybridCollection() + } + + return meta_ptr_->CreateHybridCollection(temp_schema, fields_schema); +} + +Status +DBImpl::DescribeHybridCollection(meta::CollectionSchema& collection_schema, + milvus::engine::meta::hybrid::FieldsSchema& fields_schema) { + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + auto stat = meta_ptr_->DescribeHybridCollection(collection_schema, fields_schema); + return stat; +} + Status DBImpl::DropCollection(const std::string& collection_id) { if (!initialized_.load(std::memory_order_acquire)) { @@ -556,6 +585,149 @@ DBImpl::InsertVectors(const std::string& collection_id, const std::string& parti return status; } +Status +DBImpl::InsertEntities(const std::string& collection_id, const std::string& partition_tag, Entity& entity, + std::unordered_map& attr_types) { + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + // Generate id + if (entity.id_array_.empty()) { + SafeIDGenerator& id_generator = SafeIDGenerator::GetInstance(); + Status status = id_generator.GetNextIDNumbers(entity.entity_count_, entity.id_array_); + if (!status.ok()) { + return status; + } + } + + Status status; + // insert entities: collection_name is field id + wal::MXLogRecord record; + record.lsn = 0; + record.collection_id = collection_id; + record.partition_tag = partition_tag; + record.ids = entity.id_array_.data(); + record.length = entity.entity_count_; + + auto vector_it = entity.vector_data_.begin(); + if (vector_it->second.binary_data_.empty()) { + record.type = wal::MXLogType::Entity; + record.data = vector_it->second.float_data_.data(); + record.data_size = vector_it->second.float_data_.size() * sizeof(float); + } else { + // record.type = wal::MXLogType::InsertBinary; + // record.data = entities.vector_data_[0].binary_data_.data(); + // record.length = entities.vector_data_[0].binary_data_.size() * sizeof(uint8_t); + } + + auto attr_data_it = entity.attr_data_.begin(); + for (; attr_data_it != entity.attr_data_.end(); ++attr_data_it) { + switch (attr_types.at(attr_data_it->first)) { + case meta::hybrid::DataType::INT8: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atoi(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(int8_t)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(int8_t)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(int8_t))); + record.attr_data_size.insert( + std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(int8_t))); + break; + } + case meta::hybrid::DataType::INT16: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atoi(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(int16_t)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(int16_t)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(int16_t))); + record.attr_data_size.insert( + std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(int16_t))); + break; + } + case meta::hybrid::DataType::INT32: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atoi(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(int32_t)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(int32_t)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(int32_t))); + record.attr_data_size.insert( + std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(int32_t))); + break; + } + case meta::hybrid::DataType::INT64: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atoi(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(int64_t)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(int64_t)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(int64_t))); + record.attr_data_size.insert( + std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(int64_t))); + + break; + } + case meta::hybrid::DataType::FLOAT: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atof(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(float)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(float)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(float))); + record.attr_data_size.insert(std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(float))); + + break; + } + case meta::hybrid::DataType::DOUBLE: { + std::vector entity_data; + entity_data.resize(entity.entity_count_); + for (uint64_t j = 0; j < entity.entity_count_; ++j) { + entity_data[j] = atof(attr_data_it->second[j].c_str()); + } + std::vector data; + data.resize(entity.entity_count_ * sizeof(double)); + memcpy(data.data(), entity_data.data(), entity.entity_count_ * sizeof(double)); + record.attr_data.insert(std::make_pair(attr_data_it->first, data)); + + record.attr_nbytes.insert(std::make_pair(attr_data_it->first, sizeof(double))); + record.attr_data_size.insert( + std::make_pair(attr_data_it->first, entity.entity_count_ * sizeof(double))); + break; + } + } + } + + status = ExecWalRecord(record); + return status; +} + Status DBImpl::DeleteVector(const std::string& collection_id, IDNumber vector_id) { IDNumbers ids; @@ -1121,6 +1293,75 @@ DBImpl::QueryByID(const std::shared_ptr& context, const std::st return result; } +Status +DBImpl::HybridQuery(const std::shared_ptr& context, const std::string& collection_id, + const std::vector& partition_tags, + context::HybridSearchContextPtr hybrid_search_context, query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, + ResultIds& result_ids, ResultDistances& result_distances) { + auto query_ctx = context->Child("Query"); + + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + Status status; + std::vector ids; + meta::SegmentsSchema files_array; + + if (partition_tags.empty()) { + // no partition tag specified, means search in whole table + // get all table files from parent table + status = GetFilesToSearch(collection_id, files_array); + if (!status.ok()) { + return status; + } + + std::vector partition_array; + status = meta_ptr_->ShowPartitions(collection_id, partition_array); + if (!status.ok()) { + return status; + } + for (auto& schema : partition_array) { + status = GetFilesToSearch(schema.collection_id_, files_array); + if (!status.ok()) { + return Status(DB_ERROR, "GetFilesToSearch failed in HybridQuery"); + } + } + + if (files_array.empty()) { + return Status::OK(); + } + } else { + // get files from specified partitions + std::set partition_name_array; + GetPartitionsByTags(collection_id, partition_tags, partition_name_array); + + for (auto& partition_name : partition_name_array) { + status = GetFilesToSearch(partition_name, files_array); + if (!status.ok()) { + return Status(DB_ERROR, "GetFilesToSearch failed in HybridQuery"); + } + } + + if (files_array.empty()) { + return Status::OK(); + } + } + + cache::CpuCacheMgr::GetInstance()->PrintInfo(); // print cache info before query + status = HybridQueryAsync(query_ctx, collection_id, files_array, hybrid_search_context, general_query, attr_type, + nq, result_ids, result_distances); + if (!status.ok()) { + return status; + } + cache::CpuCacheMgr::GetInstance()->PrintInfo(); // print cache info after query + + query_ctx->GetTraceContext()->GetSpan()->Finish(); + + return status; +} + Status DBImpl::Query(const std::shared_ptr& context, const std::string& collection_id, const std::vector& partition_tags, uint64_t k, const milvus::json& extra_params, @@ -1265,6 +1506,70 @@ DBImpl::QueryAsync(const std::shared_ptr& context, const meta:: return Status::OK(); } +Status +DBImpl::HybridQueryAsync(const std::shared_ptr& context, const std::string& table_id, + const meta::SegmentsSchema& files, context::HybridSearchContextPtr hybrid_search_context, + query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, + ResultIds& result_ids, ResultDistances& result_distances) { + auto query_async_ctx = context->Child("Query Async"); + +#if 0 + // Construct tasks + for (auto file : files) { + std::unordered_map types; + auto it = attr_type.begin(); + for (; it != attr_type.end(); it++) { + types.insert(std::make_pair(it->first, (engine::DataType)it->second)); + } + + auto file_ptr = std::make_shared(file); + search::TaskPtr + task = std::make_shared(context, file_ptr, general_query, types, hybrid_search_context); + search::TaskInst::GetInstance().load_queue().push(task); + search::TaskInst::GetInstance().load_cv().notify_one(); + hybrid_search_context->tasks_.emplace_back(task); + } + +#endif + + //#if 0 + TimeRecorder rc(""); + + // step 1: construct search job + auto status = OngoingFileChecker::GetInstance().MarkOngoingFiles(files); + + VectorsData vectors; + + LOG_ENGINE_DEBUG_ << LogOut("Engine query begin, index file count: %ld", files.size()); + scheduler::SearchJobPtr job = + std::make_shared(query_async_ctx, general_query, attr_type, vectors); + for (auto& file : files) { + scheduler::SegmentSchemaPtr file_ptr = std::make_shared(file); + job->AddIndexFile(file_ptr); + } + + // step 2: put search job to scheduler and wait result + scheduler::JobMgrInst::GetInstance()->Put(job); + job->WaitResult(); + + status = OngoingFileChecker::GetInstance().UnmarkOngoingFiles(files); + if (!job->GetStatus().ok()) { + return job->GetStatus(); + } + + // step 3: construct results + nq = job->vector_count(); + result_ids = job->GetResultIds(); + result_distances = job->GetResultDistances(); + rc.ElapseFromBegin("Engine query totally cost"); + + query_async_ctx->GetTraceContext()->GetSpan()->Finish(); + //#endif + + return Status::OK(); +} + void DBImpl::BackgroundIndexThread() { server::SystemInfo::GetInstance().Init(); @@ -1464,6 +1769,96 @@ DBImpl::MergeFiles(const std::string& collection_id, const meta::SegmentsSchema& return status; } +Status +DBImpl::MergeHybridFiles(const std::string& collection_id, const milvus::engine::meta::SegmentsSchema& files) { + // const std::lock_guard lock(flush_merge_compact_mutex_); + + LOG_ENGINE_DEBUG_ << "Merge files for collection: " << collection_id; + + // step 1: create table file + meta::SegmentSchema table_file; + table_file.collection_id_ = collection_id; + table_file.file_type_ = meta::SegmentSchema::NEW_MERGE; + Status status = meta_ptr_->CreateHybridCollectionFile(table_file); + + if (!status.ok()) { + LOG_ENGINE_ERROR_ << "Failed to create collection: " << status.ToString(); + return status; + } + + // step 2: merge files + /* + ExecutionEnginePtr index = + EngineFactory::Build(table_file.dimension_, table_file.location_, (EngineType)table_file.engine_type_, + (MetricType)table_file.metric_type_, table_file.nlist_); +*/ + meta::SegmentsSchema updated; + + std::string new_segment_dir; + utils::GetParentPath(table_file.location_, new_segment_dir); + auto segment_writer_ptr = std::make_shared(new_segment_dir); + + for (auto& file : files) { + server::CollectMergeFilesMetrics metrics; + std::string segment_dir_to_merge; + utils::GetParentPath(file.location_, segment_dir_to_merge); + segment_writer_ptr->Merge(segment_dir_to_merge, table_file.file_id_); + auto file_schema = file; + file_schema.file_type_ = meta::SegmentSchema::TO_DELETE; + updated.push_back(file_schema); + auto size = segment_writer_ptr->Size(); + if (size >= file_schema.index_file_size_) { + break; + } + } + + // step 3: serialize to disk + try { + status = segment_writer_ptr->Serialize(); + fiu_do_on("DBImpl.MergeFiles.Serialize_ThrowException", throw std::exception()); + fiu_do_on("DBImpl.MergeFiles.Serialize_ErrorStatus", status = Status(DB_ERROR, "")); + } catch (std::exception& ex) { + std::string msg = "Serialize merged index encounter exception: " + std::string(ex.what()); + LOG_ENGINE_ERROR_ << msg; + status = Status(DB_ERROR, msg); + } + + if (!status.ok()) { + LOG_ENGINE_ERROR_ << "Failed to persist merged segment: " << new_segment_dir << ". Error: " << status.message(); + + // if failed to serialize merge file to disk + // typical error: out of disk space, out of memory or permission denied + table_file.file_type_ = meta::SegmentSchema::TO_DELETE; + status = meta_ptr_->UpdateCollectionFile(table_file); + LOG_ENGINE_DEBUG_ << "Failed to update file to index, mark file: " << table_file.file_id_ << " to to_delete"; + + return status; + } + + // step 4: update table files state + // if index type isn't IDMAP, set file type to TO_INDEX if file size exceed index_file_size + // else set file type to RAW, no need to build index + if (!utils::IsRawIndexType(table_file.engine_type_)) { + table_file.file_type_ = (segment_writer_ptr->Size() >= table_file.index_file_size_) + ? meta::SegmentSchema::TO_INDEX + : meta::SegmentSchema::RAW; + } else { + table_file.file_type_ = meta::SegmentSchema::RAW; + } + table_file.file_size_ = segment_writer_ptr->Size(); + table_file.row_count_ = segment_writer_ptr->VectorCount(); + updated.push_back(table_file); + status = meta_ptr_->UpdateCollectionFiles(updated); + LOG_ENGINE_DEBUG_ << "New merged segment " << table_file.segment_id_ << " of size " << segment_writer_ptr->Size() + << " bytes"; + + if (options_.insert_cache_immediately_) { + segment_writer_ptr->Cache(); + } + + return status; +} + Status DBImpl::BackgroundMergeFiles(const std::string& collection_id) { const std::lock_guard lock(flush_merge_compact_mutex_); @@ -1878,6 +2273,23 @@ DBImpl::ExecWalRecord(const wal::MXLogRecord& record) { Status status; switch (record.type) { + case wal::MXLogType::Entity: { + std::string target_collection_name; + status = GetPartitionByTag(record.collection_id, record.partition_tag, target_collection_name); + if (!status.ok()) { + return status; + } + + std::set flushed_tables; + status = mem_mgr_->InsertEntities(target_collection_name, record.length, record.ids, + (record.data_size / record.length / sizeof(float)), + (const float*)record.data, record.attr_nbytes, record.attr_data_size, + record.attr_data, record.lsn, flushed_tables); + collections_flushed(flushed_tables); + + milvus::server::CollectInsertMetrics metrics(record.length, status); + break; + } case wal::MXLogType::InsertBinary: { std::string target_collection_name; status = GetPartitionByTag(record.collection_id, record.partition_tag, target_collection_name); diff --git a/core/src/db/DBImpl.h b/core/src/db/DBImpl.h index a11140a3dc..4001326622 100644 --- a/core/src/db/DBImpl.h +++ b/core/src/db/DBImpl.h @@ -20,6 +20,7 @@ #include #include #include +#include #include #include "config/handler/CacheConfigHandler.h" @@ -134,6 +135,25 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi Status DropIndex(const std::string& collection_id) override; + Status + CreateHybridCollection(meta::CollectionSchema& collection_schema, + meta::hybrid::FieldsSchema& fields_schema) override; + + Status + DescribeHybridCollection(meta::CollectionSchema& collection_schema, + meta::hybrid::FieldsSchema& fields_schema) override; + + Status + InsertEntities(const std::string& collection_name, const std::string& partition_tag, engine::Entity& entity, + std::unordered_map& field_types) override; + + Status + HybridQuery(const std::shared_ptr& context, const std::string& collection_id, + const std::vector& partition_tags, context::HybridSearchContextPtr hybrid_search_context, + query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, + ResultIds& result_ids, ResultDistances& result_distances) override; + Status QueryByID(const std::shared_ptr& context, const std::string& collection_id, const std::vector& partition_tags, uint64_t k, const milvus::json& extra_params, @@ -165,6 +185,13 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi const milvus::json& extra_params, const VectorsData& vectors, ResultIds& result_ids, ResultDistances& result_distances); + Status + HybridQueryAsync(const std::shared_ptr& context, const std::string& table_id, + const meta::SegmentsSchema& files, context::HybridSearchContextPtr hybrid_search_context, + query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, + ResultIds& result_ids, ResultDistances& result_distances); + Status GetVectorByIdHelper(const std::string& collection_id, IDNumber vector_id, VectorsData& vector, const meta::SegmentsSchema& files); @@ -205,6 +232,9 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi void BackgroundMerge(std::set collection_ids); + Status + MergeHybridFiles(const std::string& table_id, const meta::SegmentsSchema& files); + void StartBuildIndexTask(); diff --git a/core/src/db/Types.h b/core/src/db/Types.h index 109c04ff95..03f45792e6 100644 --- a/core/src/db/Types.h +++ b/core/src/db/Types.h @@ -17,6 +17,7 @@ #include #include #include +#include #include #include @@ -47,6 +48,13 @@ struct VectorsData { IDNumbers id_array_; }; +struct Entity { + uint64_t entity_count_ = 0; + std::unordered_map> attr_data_; + std::unordered_map vector_data_; + IDNumbers id_array_; +}; + using File2ErrArray = std::map>; using Table2FileErr = std::map; using File2RefCount = std::map; diff --git a/core/src/db/engine/EngineFactory.cpp b/core/src/db/engine/EngineFactory.cpp index a3c50c89a8..f275439d55 100644 --- a/core/src/db/engine/EngineFactory.cpp +++ b/core/src/db/engine/EngineFactory.cpp @@ -34,5 +34,26 @@ EngineFactory::Build(uint16_t dimension, const std::string& location, EngineType return execution_engine_ptr; } +// ExecutionEnginePtr +// EngineFactory::Build(uint16_t dimension, +// const std::string& location, +// EngineType index_type, +// MetricType metric_type, +// std::unordered_map& attr_type, +// const milvus::json& index_params) { +// +// if (index_type == EngineType::INVALID) { +// ENGINE_LOG_ERROR << "Unsupported engine type"; +// return nullptr; +// } +// +// ENGINE_LOG_DEBUG << "EngineFactory index type: " << (int)index_type; +// ExecutionEnginePtr execution_engine_ptr = +// std::make_shared(dimension, location, index_type, metric_type, attr_type, index_params); +// +// execution_engine_ptr->Init(); +// return execution_engine_ptr; +//} + } // namespace engine } // namespace milvus diff --git a/core/src/db/engine/EngineFactory.h b/core/src/db/engine/EngineFactory.h index 46d37b86a7..14334c1522 100644 --- a/core/src/db/engine/EngineFactory.h +++ b/core/src/db/engine/EngineFactory.h @@ -25,6 +25,14 @@ class EngineFactory { static ExecutionEnginePtr Build(uint16_t dimension, const std::string& location, EngineType index_type, MetricType metric_type, const milvus::json& index_params); + + // static ExecutionEnginePtr + // Build(uint16_t dimension, + // const std::string& location, + // EngineType index_type, + // MetricType metric_type, + // std::unordered_map& attr_type, + // const milvus::json& index_params); }; } // namespace engine diff --git a/core/src/db/engine/ExecutionEngine.h b/core/src/db/engine/ExecutionEngine.h index 62e1806b2a..c682a75d77 100644 --- a/core/src/db/engine/ExecutionEngine.h +++ b/core/src/db/engine/ExecutionEngine.h @@ -13,8 +13,12 @@ #include #include +#include #include +#include + +#include "query/GeneralQuery.h" #include "utils/Json.h" #include "utils/Status.h" @@ -50,6 +54,23 @@ enum class MetricType { MAX_VALUE = SUPERSTRUCTURE }; +enum class DataType { + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + + STRING = 20, + + BOOL = 30, + + FLOAT = 40, + DOUBLE = 41, + + VECTOR = 100, + UNKNOWN = 9999, +}; + class ExecutionEngine { public: virtual Status @@ -94,6 +115,11 @@ class ExecutionEngine { virtual Status GetVectorByID(const int64_t& id, uint8_t* vector, bool hybrid) = 0; + virtual Status + ExecBinaryQuery(query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr bitset, + std::unordered_map& attr_type, uint64_t& nq, uint64_t& topk, + std::vector& distances, std::vector& labels) = 0; + virtual Status Search(int64_t n, const float* data, int64_t k, const milvus::json& extra_params, float* distances, int64_t* labels, bool hybrid) = 0; diff --git a/core/src/db/engine/ExecutionEngineImpl.cpp b/core/src/db/engine/ExecutionEngineImpl.cpp index 801cd709d8..fab2460508 100644 --- a/core/src/db/engine/ExecutionEngineImpl.cpp +++ b/core/src/db/engine/ExecutionEngineImpl.cpp @@ -15,6 +15,7 @@ #include #include +#include #include #include @@ -416,6 +417,16 @@ ExecutionEngineImpl::Load(bool to_cache) { auto& vectors_data = vectors->GetData(); + auto attrs = segment_ptr->attrs_ptr_; + + auto attrs_it = attrs->attrs.begin(); + for (; attrs_it != attrs->attrs.end(); ++attrs_it) { + attr_data_.insert(std::pair(attrs_it->first, attrs_it->second->GetData())); + attr_size_.insert(std::pair(attrs_it->first, attrs_it->second->GetNbytes())); + } + + vector_count_ = count; + faiss::ConcurrentBitsetPtr concurrent_bitset_ptr = std::make_shared(count); for (auto& offset : deleted_docs) { concurrent_bitset_ptr->set(offset); @@ -704,6 +715,318 @@ MapAndCopyResult(const knowhere::DatasetPtr& dataset, const std::vector +void +ProcessRangeQuery(std::vector data, T value, query::CompareOperator type, uint64_t j, + faiss::ConcurrentBitsetPtr& bitset) { + switch (type) { + case query::CompareOperator::LT: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] >= value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case query::CompareOperator::LTE: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] > value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case query::CompareOperator::GT: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] <= value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case query::CompareOperator::GTE: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] < value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case query::CompareOperator::EQ: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] != value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + } + case query::CompareOperator::NE: { + for (uint64_t i = 0; i < data.size(); ++i) { + if (data[i] == value) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + } +} + +Status +ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr bitset, + std::unordered_map& attr_type, uint64_t& nq, uint64_t& topk, + std::vector& distances, std::vector& labels) { + if (bitset == nullptr) { + bitset = std::make_shared(vector_count_); + } + + if (general_query->leaf == nullptr) { + Status status; + if (general_query->bin->left_query != nullptr) { + status = ExecBinaryQuery(general_query->bin->left_query, bitset, attr_type, nq, topk, distances, labels); + } + if (general_query->bin->right_query != nullptr) { + status = ExecBinaryQuery(general_query->bin->right_query, bitset, attr_type, nq, topk, distances, labels); + } + return status; + } else { + if (general_query->leaf->term_query != nullptr) { + // process attrs_data + auto field_name = general_query->leaf->term_query->field_name; + auto type = attr_type.at(field_name); + auto size = attr_size_.at(field_name); + switch (type) { + case DataType::INT8: { + std::vector data; + data.resize(size / sizeof(int8_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + int8_t query_value = atoi(term_value.c_str()); + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case DataType::INT16: { + std::vector data; + data.resize(size / sizeof(int16_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + int16_t query_value = atoi(term_value.c_str()); + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case DataType::INT32: { + std::vector data; + data.resize(size / sizeof(int32_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + int32_t query_value = atoi(term_value.c_str()); + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case DataType::INT64: { + std::vector data; + data.resize(size / sizeof(int64_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + int64_t query_value = atoi(term_value.c_str()); + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case DataType::FLOAT: { + std::vector data; + data.resize(size / sizeof(float)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + std::istringstream iss(term_value); + float query_value; + iss >> query_value; + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + case DataType::DOUBLE: { + std::vector data; + data.resize(size / sizeof(double)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + for (uint64_t i = 0; i < data.size(); ++i) { + bool value_in_term = false; + for (auto term_value : general_query->leaf->term_query->field_value) { + std::istringstream iss(term_value); + double query_value; + iss >> query_value; + if (data[i] == query_value) { + value_in_term = true; + break; + } + } + if (!value_in_term) { + if (!bitset->test(i)) { + bitset->set(i); + } + } + } + break; + } + } + return Status::OK(); + } + if (general_query->leaf->range_query != nullptr) { + auto field_name = general_query->leaf->range_query->field_name; + auto com_expr = general_query->leaf->range_query->compare_expr; + auto type = attr_type.at(field_name); + auto size = attr_size_.at(field_name); + for (uint64_t j = 0; j < com_expr.size(); ++j) { + auto operand = com_expr[j].operand; + switch (type) { + case DataType::INT8: { + std::vector data; + data.resize(size / sizeof(int8_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + int8_t value = atoi(operand.c_str()); + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + case DataType::INT16: { + std::vector data; + data.resize(size / sizeof(int16_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + int16_t value = atoi(operand.c_str()); + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + case DataType::INT32: { + std::vector data; + data.resize(size / sizeof(int32_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + int32_t value = atoi(operand.c_str()); + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + case DataType::INT64: { + std::vector data; + data.resize(size / sizeof(int64_t)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + int64_t value = atoi(operand.c_str()); + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + case DataType::FLOAT: { + std::vector data; + data.resize(size / sizeof(float)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + std::istringstream iss(operand); + double value; + iss >> value; + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + case DataType::DOUBLE: { + std::vector data; + data.resize(size / sizeof(double)); + memcpy(data.data(), attr_data_.at(field_name).data(), size); + std::istringstream iss(operand); + double value; + iss >> value; + ProcessRangeQuery(data, value, com_expr[j].compare_operator, j, bitset); + break; + } + } + } + return Status::OK(); + } + if (general_query->leaf->vector_query != nullptr) { + // Do search + faiss::ConcurrentBitsetPtr list; + list = index_->GetBlacklist(); + // Do OR + for (uint64_t i = 0; i < vector_count_; ++i) { + if (list->test(i) || bitset->test(i)) { + bitset->set(i); + } + } + index_->SetBlacklist(bitset); + auto vector_query = general_query->leaf->vector_query; + topk = vector_query->topk; + nq = vector_query->query_vector.float_data.size() / dim_; + + distances.resize(nq * topk); + labels.resize(nq * topk); + + return Search(nq, vector_query->query_vector.float_data.data(), topk, vector_query->extra_params, + distances.data(), labels.data()); + } + } +} + Status ExecutionEngineImpl::Search(int64_t n, const float* data, int64_t k, const milvus::json& extra_params, float* distances, int64_t* labels, bool hybrid) { diff --git a/core/src/db/engine/ExecutionEngineImpl.h b/core/src/db/engine/ExecutionEngineImpl.h index 35e0b9c217..269e61bc9a 100644 --- a/core/src/db/engine/ExecutionEngineImpl.h +++ b/core/src/db/engine/ExecutionEngineImpl.h @@ -16,6 +16,7 @@ #include #include +#include #include #include "ExecutionEngine.h" @@ -68,6 +69,11 @@ class ExecutionEngineImpl : public ExecutionEngine { Status GetVectorByID(const int64_t& id, uint8_t* vector, bool hybrid) override; + Status + ExecBinaryQuery(query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr bitset, + std::unordered_map& attr_type, uint64_t& nq, uint64_t& topk, + std::vector& distances, std::vector& labels) override; + Status Search(int64_t n, const float* data, int64_t k, const milvus::json& extra_params, float* distances, int64_t* labels, bool hybrid = false) override; @@ -122,6 +128,12 @@ class ExecutionEngineImpl : public ExecutionEngine { EngineType index_type_; MetricType metric_type_; + std::unordered_map attr_types_; + std::unordered_map> attr_data_; + std::unordered_map attr_size_; + query::BinaryQueryPtr binary_query_; + int64_t vector_count_; + int64_t dim_; std::string location_; diff --git a/core/src/db/insert/MemManager.h b/core/src/db/insert/MemManager.h index 77a3ffbf37..377ed4964f 100644 --- a/core/src/db/insert/MemManager.h +++ b/core/src/db/insert/MemManager.h @@ -14,6 +14,8 @@ #include #include #include +#include +#include #include "db/Types.h" #include "utils/Status.h" @@ -31,6 +33,13 @@ class MemManager { InsertVectors(const std::string& collection_id, int64_t length, const IDNumber* vector_ids, int64_t dim, const uint8_t* vectors, uint64_t lsn, std::set& flushed_tables) = 0; + virtual Status + InsertEntities(const std::string& table_id, int64_t length, const IDNumber* vector_ids, int64_t dim, + const float* vectors, const std::unordered_map& attr_nbytes, + const std::unordered_map& attr_size, + const std::unordered_map>& attr_data, uint64_t lsn, + std::set& flushed_tables) = 0; + virtual Status DeleteVector(const std::string& collection_id, IDNumber vector_id, uint64_t lsn) = 0; diff --git a/core/src/db/insert/MemManagerImpl.cpp b/core/src/db/insert/MemManagerImpl.cpp index 13a827e692..50750fce2a 100644 --- a/core/src/db/insert/MemManagerImpl.cpp +++ b/core/src/db/insert/MemManagerImpl.cpp @@ -85,6 +85,36 @@ MemManagerImpl::InsertVectors(const std::string& collection_id, int64_t length, return InsertVectorsNoLock(collection_id, source, lsn); } +Status +MemManagerImpl::InsertEntities(const std::string& table_id, int64_t length, const IDNumber* vector_ids, int64_t dim, + const float* vectors, const std::unordered_map& attr_nbytes, + const std::unordered_map& attr_size, + const std::unordered_map>& attr_data, uint64_t lsn, + std::set& flushed_tables) { + flushed_tables.clear(); + if (GetCurrentMem() > options_.insert_buffer_size_) { + LOG_ENGINE_DEBUG_ << LogOut("[%s][%ld] ", "insert", 0) + << "Insert buffer size exceeds limit. Performing force flush"; + auto status = Flush(flushed_tables, false); + if (!status.ok()) { + return status; + } + } + + VectorsData vectors_data; + vectors_data.vector_count_ = length; + vectors_data.float_data_.resize(length * dim); + memcpy(vectors_data.float_data_.data(), vectors, length * dim * sizeof(float)); + vectors_data.id_array_.resize(length); + memcpy(vectors_data.id_array_.data(), vector_ids, length * sizeof(IDNumber)); + + VectorSourcePtr source = std::make_shared(vectors_data, attr_nbytes, attr_size, attr_data); + + std::unique_lock lock(mutex_); + + return InsertEntitiesNoLock(table_id, source, lsn); +} + Status MemManagerImpl::InsertVectorsNoLock(const std::string& collection_id, const VectorSourcePtr& source, uint64_t lsn) { MemTablePtr mem = GetMemByTable(collection_id); @@ -94,6 +124,16 @@ MemManagerImpl::InsertVectorsNoLock(const std::string& collection_id, const Vect return status; } +Status +MemManagerImpl::InsertEntitiesNoLock(const std::string& collection_id, const milvus::engine::VectorSourcePtr& source, + uint64_t lsn) { + MemTablePtr mem = GetMemByTable(collection_id); + mem->SetLSN(lsn); + + auto status = mem->AddEntities(source); + return status; +} + Status MemManagerImpl::DeleteVector(const std::string& collection_id, IDNumber vector_id, uint64_t lsn) { std::unique_lock lock(mutex_); diff --git a/core/src/db/insert/MemManagerImpl.h b/core/src/db/insert/MemManagerImpl.h index e729fadbf0..51b79cfe0c 100644 --- a/core/src/db/insert/MemManagerImpl.h +++ b/core/src/db/insert/MemManagerImpl.h @@ -17,6 +17,7 @@ #include #include #include +#include #include #include "config/Config.h" @@ -48,6 +49,13 @@ class MemManagerImpl : public MemManager, public server::CacheConfigHandler { InsertVectors(const std::string& collection_id, int64_t length, const IDNumber* vector_ids, int64_t dim, const uint8_t* vectors, uint64_t lsn, std::set& flushed_tables) override; + Status + InsertEntities(const std::string& table_id, int64_t length, const IDNumber* vector_ids, int64_t dim, + const float* vectors, const std::unordered_map& attr_nbytes, + const std::unordered_map& attr_size, + const std::unordered_map>& attr_data, uint64_t lsn, + std::set& flushed_tables) override; + Status DeleteVector(const std::string& collection_id, IDNumber vector_id, uint64_t lsn) override; @@ -86,6 +94,9 @@ class MemManagerImpl : public MemManager, public server::CacheConfigHandler { Status InsertVectorsNoLock(const std::string& collection_id, const VectorSourcePtr& source, uint64_t lsn); + Status + InsertEntitiesNoLock(const std::string& collection_id, const VectorSourcePtr& source, uint64_t lsn); + Status ToImmutable(); diff --git a/core/src/db/insert/MemTable.cpp b/core/src/db/insert/MemTable.cpp index a7066b176d..d572ef967e 100644 --- a/core/src/db/insert/MemTable.cpp +++ b/core/src/db/insert/MemTable.cpp @@ -60,6 +60,34 @@ MemTable::Add(const VectorSourcePtr& source) { return Status::OK(); } +Status +MemTable::AddEntities(const milvus::engine::VectorSourcePtr& source) { + while (!source->AllAdded()) { + MemTableFilePtr current_mem_table_file; + if (!mem_table_file_list_.empty()) { + current_mem_table_file = mem_table_file_list_.back(); + } + + Status status; + if (mem_table_file_list_.empty() || current_mem_table_file->IsFull()) { + MemTableFilePtr new_mem_table_file = std::make_shared(collection_id_, meta_, options_); + status = new_mem_table_file->AddEntities(source); + if (status.ok()) { + mem_table_file_list_.emplace_back(new_mem_table_file); + } + } else { + status = current_mem_table_file->AddEntities(source); + } + + if (!status.ok()) { + std::string err_msg = "Insert failed: " + status.ToString(); + LOG_ENGINE_ERROR_ << LogOut("[%s][%ld] ", "insert", 0) << err_msg; + return Status(DB_ERROR, err_msg); + } + } + return Status::OK(); +} + Status MemTable::Delete(segment::doc_id_t doc_id) { // Locate which collection file the doc id lands in diff --git a/core/src/db/insert/MemTable.h b/core/src/db/insert/MemTable.h index f5e2f89024..8940e8b495 100644 --- a/core/src/db/insert/MemTable.h +++ b/core/src/db/insert/MemTable.h @@ -35,6 +35,9 @@ class MemTable : public server::CacheConfigHandler { Status Add(const VectorSourcePtr& source); + Status + AddEntities(const VectorSourcePtr& source); + Status Delete(segment::doc_id_t doc_id); diff --git a/core/src/db/insert/MemTableFile.cpp b/core/src/db/insert/MemTableFile.cpp index 1e11e763fd..b48a1b77c0 100644 --- a/core/src/db/insert/MemTableFile.cpp +++ b/core/src/db/insert/MemTableFile.cpp @@ -85,6 +85,33 @@ MemTableFile::Add(const VectorSourcePtr& source) { return Status::OK(); } +Status +MemTableFile::AddEntities(const VectorSourcePtr& source) { + if (table_file_schema_.dimension_ <= 0) { + std::string err_msg = + "MemTableFile::Add: table_file_schema dimension = " + std::to_string(table_file_schema_.dimension_) + + ", table_id = " + table_file_schema_.collection_id_; + LOG_ENGINE_ERROR_ << LogOut("[%s][%ld]", "insert", 0) << err_msg; + return Status(DB_ERROR, "Not able to create table file"); + } + + size_t single_entity_mem_size = source->SingleEntitySize(table_file_schema_.dimension_); + size_t mem_left = GetMemLeft(); + if (mem_left >= single_entity_mem_size) { + size_t num_entities_to_add = std::ceil(mem_left / single_entity_mem_size); + size_t num_entities_added; + + auto status = + source->AddEntities(segment_writer_ptr_, table_file_schema_, num_entities_to_add, num_entities_added); + + if (status.ok()) { + current_mem_ += (num_entities_added * single_entity_mem_size); + } + return status; + } + return Status::OK(); +} + Status MemTableFile::Delete(segment::doc_id_t doc_id) { segment::SegmentPtr segment_ptr; diff --git a/core/src/db/insert/MemTableFile.h b/core/src/db/insert/MemTableFile.h index d51fd828b7..315940908d 100644 --- a/core/src/db/insert/MemTableFile.h +++ b/core/src/db/insert/MemTableFile.h @@ -36,6 +36,9 @@ class MemTableFile : public server::CacheConfigHandler { Status Add(const VectorSourcePtr& source); + Status + AddEntities(const VectorSourcePtr& source); + Status Delete(segment::doc_id_t doc_id); diff --git a/core/src/db/insert/VectorSource.cpp b/core/src/db/insert/VectorSource.cpp index 49bb59b7f1..2a88e1651c 100644 --- a/core/src/db/insert/VectorSource.cpp +++ b/core/src/db/insert/VectorSource.cpp @@ -26,6 +26,15 @@ VectorSource::VectorSource(VectorsData vectors) : vectors_(std::move(vectors)) { current_num_vectors_added = 0; } +VectorSource::VectorSource(milvus::engine::VectorsData vectors, + const std::unordered_map& attr_nbytes, + const std::unordered_map& attr_size, + const std::unordered_map>& attr_data) + : vectors_(std::move(vectors)), attr_nbytes_(attr_nbytes), attr_size_(attr_size), attr_data_(attr_data) { + current_num_vectors_added = 0; + current_num_attrs_added = 0; +} + Status VectorSource::Add(/*const ExecutionEnginePtr& execution_engine,*/ const segment::SegmentWriterPtr& segment_writer_ptr, const meta::SegmentSchema& table_file_schema, const size_t& num_vectors_to_add, @@ -96,6 +105,61 @@ VectorSource::Add(/*const ExecutionEnginePtr& execution_engine,*/ const segment: return status; } +Status +VectorSource::AddEntities(const milvus::segment::SegmentWriterPtr& segment_writer_ptr, + const milvus::engine::meta::SegmentSchema& collection_file_schema, + const size_t& num_entities_to_add, size_t& num_entities_added) { + // TODO: n = vectors_.vector_count_;??? + uint64_t n = vectors_.vector_count_; + num_entities_added = + current_num_attrs_added + num_entities_to_add <= n ? num_entities_to_add : n - current_num_attrs_added; + IDNumbers vector_ids_to_add; + if (vectors_.id_array_.empty()) { + SafeIDGenerator& id_generator = SafeIDGenerator::GetInstance(); + Status status = id_generator.GetNextIDNumbers(num_entities_added, vector_ids_to_add); + if (!status.ok()) { + return status; + } + } else { + vector_ids_to_add.resize(num_entities_added); + for (size_t pos = current_num_attrs_added; pos < current_num_attrs_added + num_entities_added; pos++) { + vector_ids_to_add[pos - current_num_attrs_added] = vectors_.id_array_[pos]; + } + } + + Status status; + status = + segment_writer_ptr->AddAttrs(collection_file_schema.collection_id_, attr_size_, attr_data_, vector_ids_to_add); + + if (status.ok()) { + current_num_attrs_added += num_entities_added; + } else { + LOG_ENGINE_ERROR_ << LogOut("[%s][%ld]", "insert", 0) << "Generate ids fail: " << status.message(); + return status; + } + + std::vector vectors; + auto size = num_entities_added * collection_file_schema.dimension_ * sizeof(float); + vectors.resize(size); + memcpy(vectors.data(), vectors_.float_data_.data() + current_num_vectors_added * collection_file_schema.dimension_, + size); + LOG_ENGINE_DEBUG_ << LogOut("[%s][%ld]", "insert", 0) << "Insert into segment"; + status = segment_writer_ptr->AddVectors(collection_file_schema.file_id_, vectors, vector_ids_to_add); + if (status.ok()) { + current_num_vectors_added += num_entities_added; + vector_ids_.insert(vector_ids_.end(), std::make_move_iterator(vector_ids_to_add.begin()), + std::make_move_iterator(vector_ids_to_add.end())); + } + + // don't need to add current_num_attrs_added again + if (!status.ok()) { + LOG_ENGINE_ERROR_ << LogOut("[%s][%ld]", "insert", 0) << "VectorSource::Add failed: " + status.ToString(); + return status; + } + + return status; +} + size_t VectorSource::GetNumVectorsAdded() { return current_num_vectors_added; @@ -111,6 +175,17 @@ VectorSource::SingleVectorSize(uint16_t dimension) { return 0; } +size_t +VectorSource::SingleEntitySize(uint16_t dimension) { + // TODO(yukun) add entity type and size compute + size_t size = 0; + size += dimension * FLOAT_TYPE_SIZE; + auto nbyte_it = attr_nbytes_.begin(); + for (; nbyte_it != attr_nbytes_.end(); ++nbyte_it) { + size += nbyte_it->second; + } + return size; +} bool VectorSource::AllAdded() { diff --git a/core/src/db/insert/VectorSource.h b/core/src/db/insert/VectorSource.h index 70bc4e43ca..6b9f89e428 100644 --- a/core/src/db/insert/VectorSource.h +++ b/core/src/db/insert/VectorSource.h @@ -12,6 +12,9 @@ #pragma once #include +#include +#include +#include #include "db/IDGenerator.h" #include "db/engine/ExecutionEngine.h" @@ -28,16 +31,27 @@ class VectorSource { public: explicit VectorSource(VectorsData vectors); + VectorSource(VectorsData vectors, const std::unordered_map& attr_nbytes, + const std::unordered_map& attr_size, + const std::unordered_map>& attr_data); + Status Add(/*const ExecutionEnginePtr& execution_engine,*/ const segment::SegmentWriterPtr& segment_writer_ptr, const meta::SegmentSchema& table_file_schema, const size_t& num_vectors_to_add, size_t& num_vectors_added); + Status + AddEntities(const segment::SegmentWriterPtr& segment_writer_ptr, const meta::SegmentSchema& collection_file_schema, + const size_t& num_attrs_to_add, size_t& num_attrs_added); + size_t GetNumVectorsAdded(); size_t SingleVectorSize(uint16_t dimension); + size_t + SingleEntitySize(uint16_t dimension); + bool AllAdded(); @@ -47,8 +61,12 @@ class VectorSource { private: VectorsData vectors_; IDNumbers vector_ids_; + const std::unordered_map attr_nbytes_; + std::unordered_map attr_size_; + std::unordered_map> attr_data_; size_t current_num_vectors_added; + size_t current_num_attrs_added; }; // VectorSource using VectorSourcePtr = std::shared_ptr; diff --git a/core/src/db/meta/Meta.h b/core/src/db/meta/Meta.h index 7f85c2caa5..9419502f3d 100644 --- a/core/src/db/meta/Meta.h +++ b/core/src/db/meta/Meta.h @@ -28,6 +28,9 @@ namespace meta { static const char* META_ENVIRONMENT = "Environment"; static const char* META_TABLES = "Tables"; static const char* META_TABLEFILES = "TableFiles"; +static const char* META_COLLECTIONS = "Collections"; +static const char* META_FIELDS = "Fields"; +static const char* META_COLLECTIONFILES = "CollectionFiles"; class Meta { /* @@ -151,6 +154,15 @@ class Meta { virtual Status GetGlobalLastLSN(uint64_t& lsn) = 0; + + virtual Status + CreateHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) = 0; + + virtual Status + DescribeHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) = 0; + + virtual Status + CreateHybridCollectionFile(SegmentSchema& file_schema) = 0; }; // MetaData using MetaPtr = std::shared_ptr; diff --git a/core/src/db/meta/MetaTypes.h b/core/src/db/meta/MetaTypes.h index 2102c95b55..63b37c8bed 100644 --- a/core/src/db/meta/MetaTypes.h +++ b/core/src/db/meta/MetaTypes.h @@ -97,6 +97,129 @@ struct SegmentSchema { using SegmentSchemaPtr = std::shared_ptr; using SegmentsSchema = std::vector; +namespace hybrid { + +enum class DataType { + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + + STRING = 20, + + BOOL = 30, + + FLOAT = 40, + DOUBLE = 41, + + VECTOR = 100, + UNKNOWN = 9999, +}; + +struct VectorFieldSchema { + std::string vector_id_; + int64_t dimension; + int64_t index_file_size_ = DEFAULT_INDEX_FILE_SIZE; + int32_t engine_type_ = DEFAULT_ENGINE_TYPE; + std::string index_params_ = "{}"; + int32_t metric_type_ = DEFAULT_METRIC_TYPE; +}; + +struct VectorFieldsSchema { + std::vector vector_fields_; +}; +using VectorFieldSchemaPtr = std::shared_ptr; + +struct CollectionSchema { + typedef enum { + NORMAL, + TO_DELETE, + } COLLETION_STATE; + + size_t id_ = 0; + std::string collection_id_; + int32_t state_ = (int)NORMAL; + int64_t field_num = 0; + int64_t created_on_ = 0; + int64_t flag_ = 0; + std::string owner_collection_; + std::string partition_tag_; + std::string version_ = CURRENT_VERSION; + uint64_t flush_lsn_ = 0; +}; + +using CollectionSchemaPtr = std::shared_ptr; + +struct FieldSchema { + typedef enum { + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + + STRING = 20, + + BOOL = 30, + + FLOAT = 40, + DOUBLE = 41, + + VECTOR = 100, + UNKNOWN = 9999, + } FIELD_TYPE; + + // TODO(yukun): need field_id? + std::string collection_id_; + std::string field_name_; + int32_t field_type_ = (int)INT8; + std::string field_params_; +}; + +struct FieldsSchema { + std::vector fields_schema_; +}; + +using FieldSchemaPtr = std::shared_ptr; + +struct VectorFileSchema { + std::string field_name_; + int64_t index_file_size_ = DEFAULT_INDEX_FILE_SIZE; // not persist to meta + int32_t engine_type_ = DEFAULT_ENGINE_TYPE; + std::string index_params_ = "{}"; // not persist to meta + int32_t metric_type_ = DEFAULT_METRIC_TYPE; // not persist to meta +}; + +using VectorFileSchemaPtr = std::shared_ptr; + +struct CollectionFileSchema { + typedef enum { + NEW, + RAW, + TO_INDEX, + INDEX, + TO_DELETE, + NEW_MERGE, + NEW_INDEX, + BACKUP, + } FILE_TYPE; + + size_t id_ = 0; + std::string collection_id_; + std::string segment_id_; + std::string file_id_; + int32_t file_type_ = NEW; + size_t file_size_ = 0; + size_t row_count_ = 0; + DateT date_ = EmptyDate; + std::string location_; + int64_t updated_time_ = 0; + int64_t created_on_ = 0; + uint64_t flush_lsn_ = 0; +}; + +using CollectionFileSchemaPtr = std::shared_ptr; +} // namespace hybrid + } // namespace meta } // namespace engine } // namespace milvus diff --git a/core/src/db/meta/MySQLMetaImpl.cpp b/core/src/db/meta/MySQLMetaImpl.cpp index 5c75c8c123..cfb4af3502 100644 --- a/core/src/db/meta/MySQLMetaImpl.cpp +++ b/core/src/db/meta/MySQLMetaImpl.cpp @@ -2631,6 +2631,18 @@ MySQLMetaImpl::GetGlobalLastLSN(uint64_t& lsn) { return Status::OK(); } +Status +MySQLMetaImpl::CreateHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) { +} + +Status +MySQLMetaImpl::DescribeHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) { +} + +Status +MySQLMetaImpl::CreateHybridCollectionFile(milvus::engine::meta::SegmentSchema& file_schema) { +} + } // namespace meta } // namespace engine } // namespace milvus diff --git a/core/src/db/meta/MySQLMetaImpl.h b/core/src/db/meta/MySQLMetaImpl.h index c14c215af2..6f26425b66 100644 --- a/core/src/db/meta/MySQLMetaImpl.h +++ b/core/src/db/meta/MySQLMetaImpl.h @@ -142,6 +142,15 @@ class MySQLMetaImpl : public Meta { Status GetGlobalLastLSN(uint64_t& lsn) override; + Status + CreateHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) override; + + Status + DescribeHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) override; + + Status + CreateHybridCollectionFile(SegmentSchema& file_schema) override; + private: Status NextFileId(std::string& file_id); diff --git a/core/src/db/meta/SqliteMetaImpl.cpp b/core/src/db/meta/SqliteMetaImpl.cpp index fbe958d617..3921a988a2 100644 --- a/core/src/db/meta/SqliteMetaImpl.cpp +++ b/core/src/db/meta/SqliteMetaImpl.cpp @@ -75,6 +75,10 @@ StoragePrototype(const std::string& path) { make_column("partition_tag", &CollectionSchema::partition_tag_, default_value("")), make_column("version", &CollectionSchema::version_, default_value(CURRENT_VERSION)), make_column("flush_lsn", &CollectionSchema::flush_lsn_)), + make_table(META_FIELDS, make_column("collection_id", &hybrid::FieldSchema::collection_id_), + make_column("field_name", &hybrid::FieldSchema::field_name_), + make_column("field_type", &hybrid::FieldSchema::field_type_), + make_column("field_params", &hybrid::FieldSchema::field_params_)), make_table( META_TABLEFILES, make_column("id", &SegmentSchema::id_, primary_key()), make_column("table_id", &SegmentSchema::collection_id_), @@ -88,9 +92,46 @@ StoragePrototype(const std::string& path) { make_column("flush_lsn", &SegmentSchema::flush_lsn_))); } -using ConnectorT = decltype(StoragePrototype("")); +inline auto +CollectionPrototype(const std::string& path) { + return make_storage( + path, + make_table(META_ENVIRONMENT, make_column("global_lsn", &EnvironmentSchema::global_lsn_, default_value(0))), + make_table(META_COLLECTIONS, make_column("id", &hybrid::CollectionSchema::id_, primary_key()), + make_column("collection_id", &hybrid::CollectionSchema::collection_id_, unique()), + make_column("state", &hybrid::CollectionSchema::state_), + make_column("field_num", &hybrid::CollectionSchema::field_num), + make_column("created_on", &hybrid::CollectionSchema::created_on_), + make_column("flag", &hybrid::CollectionSchema::flag_, default_value(0)), + make_column("owner_collection", &hybrid::CollectionSchema::owner_collection_, default_value("")), + make_column("partition_tag", &hybrid::CollectionSchema::partition_tag_, default_value("")), + make_column("version", &hybrid::CollectionSchema::version_, default_value(CURRENT_VERSION)), + make_column("flush_lsn", &hybrid::CollectionSchema::flush_lsn_)), + make_table(META_FIELDS, make_column("collection_id", &hybrid::FieldSchema::collection_id_), + make_column("field_name", &hybrid::FieldSchema::field_name_), + make_column("field_type", &hybrid::FieldSchema::field_type_), + make_column("field_params", &hybrid::FieldSchema::field_params_)), + make_table( + META_COLLECTIONFILES, + make_column("id", &hybrid::CollectionFileSchema::id_, primary_key()), + make_column("collection_id", &hybrid::CollectionFileSchema::collection_id_), + make_column("segment_id", &hybrid::CollectionFileSchema::segment_id_, default_value("")), + make_column("file_id", &hybrid::CollectionFileSchema::file_id_), + make_column("file_type", &hybrid::CollectionFileSchema::file_type_), + make_column("file_size", &hybrid::CollectionFileSchema::file_size_, default_value(0)), + make_column("row_count", &hybrid::CollectionFileSchema::row_count_, default_value(0)), + make_column("updated_time", &hybrid::CollectionFileSchema::updated_time_), + make_column("created_on", &hybrid::CollectionFileSchema::created_on_), + make_column("date", &hybrid::CollectionFileSchema::date_), + make_column("flush_lsn", &hybrid::CollectionFileSchema::flush_lsn_))); +} + +using ConnectorT = decltype(StoragePrototype("table")); static std::unique_ptr ConnectorPtr; +using CollectionConnectT = decltype(CollectionPrototype("")); +static std::unique_ptr CollectionConnectPtr; + SqliteMetaImpl::SqliteMetaImpl(const DBMetaOptions& options) : options_(options) { Initialize(); } @@ -132,12 +173,40 @@ SqliteMetaImpl::ValidateMetaSchema() { sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_TABLES]) { throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version"); } + if (ret.find(META_FIELDS) != ret.end() + && sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_FIELDS]) { + throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version"); + } if (ret.find(META_TABLEFILES) != ret.end() && sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_TABLEFILES]) { throw Exception(DB_INCOMPATIB_META, "Meta TableFiles schema is created by Milvus old version"); } } +void +SqliteMetaImpl::ValidateCollectionMetaSchema() { + bool is_null_connector{CollectionConnectPtr == nullptr}; + fiu_do_on("SqliteMetaImpl.ValidateMetaSchema.NullConnection", is_null_connector = true); + if (is_null_connector) { + return; + } + + // old meta could be recreated since schema changed, throw exception if meta schema is not compatible + auto ret = CollectionConnectPtr->sync_schema_simulate(); + if (ret.find(META_COLLECTIONS) != ret.end() && + sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_COLLECTIONS]) { + throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version"); + } + if (ret.find(META_FIELDS) != ret.end() + && sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_FIELDS]) { + throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version"); + } + if (ret.find(META_COLLECTIONFILES) != ret.end() && + sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_TABLEFILES]) { + throw Exception(DB_INCOMPATIB_META, "Meta TableFiles schema is created by Milvus old version"); + } +} + Status SqliteMetaImpl::Initialize() { if (!boost::filesystem::is_directory(options_.path_)) { @@ -158,6 +227,14 @@ SqliteMetaImpl::Initialize() { ConnectorPtr->open_forever(); // thread safe option ConnectorPtr->pragma.journal_mode(journal_mode::WAL); // WAL => write ahead log + CollectionConnectPtr = std::make_unique(CollectionPrototype(options_.path_ + "/metah.sqlite")); + + ValidateCollectionMetaSchema(); + + CollectionConnectPtr->sync_schema(); + CollectionConnectPtr->open_forever(); + CollectionConnectPtr->pragma.journal_mode(journal_mode::WAL); // WAL => write ahead log + CleanUpShadowFiles(); return Status::OK(); @@ -1772,6 +1849,176 @@ SqliteMetaImpl::GetGlobalLastLSN(uint64_t& lsn) { return Status::OK(); } +Status +SqliteMetaImpl::CreateHybridCollection(meta::CollectionSchema& collection_schema, + meta::hybrid::FieldsSchema& fields_schema) { + try { + server::MetricCollector metric; + + // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here + std::lock_guard meta_lock(meta_mutex_); + + if (collection_schema.collection_id_ == "") { + NextCollectionId(collection_schema.collection_id_); + } else { + fiu_do_on("SqliteMetaImpl.CreateCollection.throw_exception", throw std::exception()); + auto collection = ConnectorPtr->select(columns(&CollectionSchema::state_), + where(c(&CollectionSchema::collection_id_) + == collection_schema.collection_id_)); + if (collection.size() == 1) { + if (CollectionSchema::TO_DELETE == std::get<0>(collection[0])) { + return Status(DB_ERROR, "Collection already exists and it is in delete state, please wait a second"); + } else { + // Change from no error to already exist. + return Status(DB_ALREADY_EXIST, "Collection already exists"); + } + } + } + + collection_schema.id_ = -1; + collection_schema.created_on_ = utils::GetMicroSecTimeStamp(); + + try { + fiu_do_on("SqliteMetaImpl.CreateHybridCollection.insert_throw_exception", throw std::exception()); + auto id = ConnectorPtr->insert(collection_schema); + collection_schema.id_ = id; + } catch (std::exception& e) { + return HandleException("Encounter exception when create collection", e.what()); + } + + LOG_ENGINE_DEBUG_ << "Successfully create collection collection: " << collection_schema.collection_id_; + + Status status = utils::CreateCollectionPath(options_, collection_schema.collection_id_); + if (!status.ok()) { + return status; + } + + try { + for (uint64_t i = 0; i < fields_schema.fields_schema_.size(); ++i) { + hybrid::FieldSchema schema = fields_schema.fields_schema_[i]; + auto field_id = ConnectorPtr->insert(schema); + LOG_ENGINE_DEBUG_ << "Successfully create collection field" << field_id; + } + } catch (std::exception& e) { + return HandleException("Encounter exception when create collection field", e.what()); + } + + return status; + } catch (std::exception& e) { + return HandleException("Encounter exception when create collection", e.what()); + } +} + +Status +SqliteMetaImpl::DescribeHybridCollection(milvus::engine::meta::CollectionSchema& collection_schema, + milvus::engine::meta::hybrid::FieldsSchema& fields_schema) { + + try { + server::MetricCollector metric; + fiu_do_on("SqliteMetaImpl.DescriCollection.throw_exception", throw std::exception()); + auto groups = ConnectorPtr->select( + columns(&CollectionSchema::id_, &CollectionSchema::state_, &CollectionSchema::dimension_, &CollectionSchema::created_on_, + &CollectionSchema::flag_, &CollectionSchema::index_file_size_, &CollectionSchema::engine_type_, + &CollectionSchema::index_params_, &CollectionSchema::metric_type_, &CollectionSchema::owner_collection_, + &CollectionSchema::partition_tag_, &CollectionSchema::version_, &CollectionSchema::flush_lsn_), + where(c(&CollectionSchema::collection_id_) == collection_schema.collection_id_ and + c(&CollectionSchema::state_) != (int)CollectionSchema::TO_DELETE)); + + if (groups.size() == 1) { + collection_schema.id_ = std::get<0>(groups[0]); + collection_schema.state_ = std::get<1>(groups[0]); + collection_schema.dimension_ = std::get<2>(groups[0]); + collection_schema.created_on_ = std::get<3>(groups[0]); + collection_schema.flag_ = std::get<4>(groups[0]); + collection_schema.index_file_size_ = std::get<5>(groups[0]); + collection_schema.engine_type_ = std::get<6>(groups[0]); + collection_schema.index_params_ = std::get<7>(groups[0]); + collection_schema.metric_type_ = std::get<8>(groups[0]); + collection_schema.owner_collection_ = std::get<9>(groups[0]); + collection_schema.partition_tag_ = std::get<10>(groups[0]); + collection_schema.version_ = std::get<11>(groups[0]); + collection_schema.flush_lsn_ = std::get<12>(groups[0]); + } else { + return Status(DB_NOT_FOUND, "Collection " + collection_schema.collection_id_ + " not found"); + } + + auto field_groups = ConnectorPtr->select( + columns(&hybrid::FieldSchema::collection_id_, + &hybrid::FieldSchema::field_name_, + &hybrid::FieldSchema::field_type_, + &hybrid::FieldSchema::field_params_), + where(c(&hybrid::FieldSchema::collection_id_) == collection_schema.collection_id_)); + + if (field_groups.size() >= 1) { + fields_schema.fields_schema_.resize(field_groups.size()); + for (uint64_t i = 0; i < field_groups.size(); ++i) { + fields_schema.fields_schema_[i].collection_id_ = std::get<0>(field_groups[i]); + fields_schema.fields_schema_[i].field_name_ = std::get<1>(field_groups[i]); + fields_schema.fields_schema_[i].field_type_ = std::get<2>(field_groups[i]); + fields_schema.fields_schema_[i].field_params_ = std::get<3>(field_groups[i]); + } + } else { + return Status(DB_NOT_FOUND, "Collection " + collection_schema.collection_id_ + " fields not found"); + } + + } catch (std::exception& e) { + return HandleException("Encounter exception when describe collection", e.what()); + } + + return Status::OK(); +} + +Status +SqliteMetaImpl::CreateHybridCollectionFile(SegmentSchema& file_schema) { + + if (file_schema.date_ == EmptyDate) { + file_schema.date_ = utils::GetDate(); + } + CollectionSchema collection_schema; + hybrid::FieldsSchema fields_schema; + collection_schema.collection_id_ = file_schema.collection_id_; + auto status = DescribeHybridCollection(collection_schema, fields_schema); + if (!status.ok()) { + return status; + } + + try { + fiu_do_on("SqliteMetaImpl.CreateCollectionFile.throw_exception", throw std::exception()); + server::MetricCollector metric; + + NextFileId(file_schema.file_id_); + if (file_schema.segment_id_.empty()) { + file_schema.segment_id_ = file_schema.file_id_; + } + file_schema.dimension_ = collection_schema.dimension_; + file_schema.file_size_ = 0; + file_schema.row_count_ = 0; + file_schema.created_on_ = utils::GetMicroSecTimeStamp(); + file_schema.updated_time_ = file_schema.created_on_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.engine_type_ = collection_schema.engine_type_; + file_schema.metric_type_ = collection_schema.metric_type_; + + // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here + std::lock_guard meta_lock(meta_mutex_); + + auto id = ConnectorPtr->insert(file_schema); + file_schema.id_ = id; + + for (auto field_schema : fields_schema.fields_schema_) { + ConnectorPtr->insert(field_schema); + } + + LOG_ENGINE_DEBUG_ << "Successfully create collection file, file id = " << file_schema.file_id_; + return utils::CreateCollectionFilePath(options_, file_schema); + } catch (std::exception& e) { + return HandleException("Encounter exception when create collection file", e.what()); + } + + return Status::OK(); +} + } // namespace meta } // namespace engine } // namespace milvus diff --git a/core/src/db/meta/SqliteMetaImpl.h b/core/src/db/meta/SqliteMetaImpl.h index 6446b4849a..a71931e155 100644 --- a/core/src/db/meta/SqliteMetaImpl.h +++ b/core/src/db/meta/SqliteMetaImpl.h @@ -25,6 +25,9 @@ namespace meta { auto StoragePrototype(const std::string& path); +auto +CollectionPrototype(const std::string& path); + class SqliteMetaImpl : public Meta { public: explicit SqliteMetaImpl(const DBMetaOptions& options); @@ -141,6 +144,15 @@ class SqliteMetaImpl : public Meta { Status GetGlobalLastLSN(uint64_t& lsn) override; + Status + CreateHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) override; + + Status + DescribeHybridCollection(CollectionSchema& collection_schema, hybrid::FieldsSchema& fields_schema) override; + + Status + CreateHybridCollectionFile(SegmentSchema& file_schema) override; + private: Status NextFileId(std::string& file_id); @@ -151,6 +163,8 @@ class SqliteMetaImpl : public Meta { void ValidateMetaSchema(); + void + ValidateCollectionMetaSchema(); Status Initialize(); diff --git a/core/src/db/wal/WalDefinations.h b/core/src/db/wal/WalDefinations.h index d4f02daee2..b166b87264 100644 --- a/core/src/db/wal/WalDefinations.h +++ b/core/src/db/wal/WalDefinations.h @@ -14,6 +14,7 @@ #include #include #include +#include #include "db/Types.h" #include "db/meta/MetaTypes.h" @@ -23,12 +24,12 @@ namespace engine { namespace wal { using TableSchemaPtr = std::shared_ptr; -using TableMetaPtr = std::shared_ptr >; +using TableMetaPtr = std::shared_ptr>; #define UNIT_MB (1024 * 1024) #define LSN_OFFSET_MASK 0x00000000ffffffff -enum class MXLogType { InsertBinary, InsertVector, Delete, Update, Flush, None }; +enum class MXLogType { InsertBinary, InsertVector, Delete, Update, Flush, None, Entity }; struct MXLogRecord { uint64_t lsn; @@ -39,6 +40,9 @@ struct MXLogRecord { const IDNumber* ids; uint32_t data_size; const void* data; + std::unordered_map attr_nbytes; + std::unordered_map attr_data_size; + std::unordered_map> attr_data; }; struct MXLogConfiguration { diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc index 2276765803..72fd9653d7 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc @@ -44,6 +44,20 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/PreloadCollection", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", + "/milvus.grpc.MilvusService/CreateHybridCollection", + "/milvus.grpc.MilvusService/HasHybridCollection", + "/milvus.grpc.MilvusService/DropHybridCollection", + "/milvus.grpc.MilvusService/DescribeHybridCollection", + "/milvus.grpc.MilvusService/CountHybridCollection", + "/milvus.grpc.MilvusService/ShowHybridCollections", + "/milvus.grpc.MilvusService/ShowHybridCollectionInfo", + "/milvus.grpc.MilvusService/PreloadHybridCollection", + "/milvus.grpc.MilvusService/InsertEntity", + "/milvus.grpc.MilvusService/HybridSearch", + "/milvus.grpc.MilvusService/HybridSearchInSegments", + "/milvus.grpc.MilvusService/GetEntityByID", + "/milvus.grpc.MilvusService/GetEntityIDs", + "/milvus.grpc.MilvusService/DeleteEntitiesByID", }; std::unique_ptr< MilvusService::Stub> MilvusService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { @@ -77,6 +91,20 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_PreloadCollection_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Flush_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Compact_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CreateHybridCollection_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasHybridCollection_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollections_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_InsertEntity_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearch_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityByID_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityIDs_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { @@ -751,6 +779,398 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, false); } +::grpc::Status MilvusService::Stub::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* MilvusService::Stub::AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Mapping>::Create(channel_.get(), cq, rpcmethod_DescribeHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* MilvusService::Stub::PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Mapping>::Create(channel_.get(), cq, rpcmethod_DescribeHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowHybridCollections_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* MilvusService::Stub::AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::MappingList>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollections_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* MilvusService::Stub::PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::MappingList>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollections_, context, request, false); +} + +::grpc::Status MilvusService::Stub::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowHybridCollectionInfo_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollectionInfo_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollectionInfo_, context, request, false); +} + +::grpc::Status MilvusService::Stub::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_InsertEntity_, context, request, response); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_InsertEntity_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_InsertEntity_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HybridSearch_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearch_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearch_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HybridSearchInSegments_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearchInSegments_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearchInSegments_, context, request, false); +} + +::grpc::Status MilvusService::Stub::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetEntityByID_, context, request, response); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, false); +} + +::grpc::Status MilvusService::Stub::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetEntityIDs_, context, request, response); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_GetEntityIDs_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_GetEntityIDs_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DeleteEntitiesByID_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteEntitiesByID_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteEntitiesByID_, context, request, false); +} + MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[0], @@ -872,6 +1292,76 @@ MilvusService::Service::Service() { ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[24], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Mapping, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::CreateHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[25], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + std::mem_fn(&MilvusService::Service::HasHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[26], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DropHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[27], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( + std::mem_fn(&MilvusService::Service::DescribeHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[28], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + std::mem_fn(&MilvusService::Service::CountHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[29], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::MappingList>( + std::mem_fn(&MilvusService::Service::ShowHybridCollections), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[30], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + std::mem_fn(&MilvusService::Service::ShowHybridCollectionInfo), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[31], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::PreloadHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[32], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( + std::mem_fn(&MilvusService::Service::InsertEntity), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[33], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + std::mem_fn(&MilvusService::Service::HybridSearch), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[34], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( + std::mem_fn(&MilvusService::Service::HybridSearchInSegments), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[35], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + std::mem_fn(&MilvusService::Service::GetEntityByID), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[36], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( + std::mem_fn(&MilvusService::Service::GetEntityIDs), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[37], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DeleteEntitiesByID), this))); } MilvusService::Service::~Service() { @@ -1045,6 +1535,104 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } +::grpc::Status MilvusService::Service::CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HasHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DropHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DescribeHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::CountHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::ShowHybridCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::ShowHybridCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::PreloadHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HybridSearchInSegments(::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::GetEntityIDs(::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DeleteEntitiesByID(::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + } // namespace milvus } // namespace grpc diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.h b/core/src/grpc/gen-milvus/milvus.grpc.pb.h index c9f00d5e92..fd2b54b5a1 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.h +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.h @@ -359,6 +359,117 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } + // *******************************New Interface******************************************* + // + virtual ::grpc::Status CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>> AsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>>(AsyncDescribeHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>> PrepareAsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>>(PrepareAsyncDescribeHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> AsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(AsyncCountHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>> AsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>>(AsyncShowHybridCollectionsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>> PrepareAsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>>(PrepareAsyncShowHybridCollectionsRaw(context, request, cq)); + } + virtual ::grpc::Status ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> AsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(AsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + virtual ::grpc::Status PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadHybridCollectionRaw(context, request, cq)); + } + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual ::grpc::Status InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> AsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(AsyncInsertEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> PrepareAsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(PrepareAsyncInsertEntityRaw(context, request, cq)); + } + // TODO(yukun): will change to HQueryResult + virtual ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchRaw(context, request, cq)); + } + virtual ::grpc::Status HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + virtual ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>>(AsyncGetEntityByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>>(PrepareAsyncGetEntityByIDRaw(context, request, cq)); + } + virtual ::grpc::Status GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> AsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(AsyncGetEntityIDsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> PrepareAsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(PrepareAsyncGetEntityIDsRaw(context, request, cq)); + } + virtual ::grpc::Status DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDeleteEntitiesByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDeleteEntitiesByIDRaw(context, request, cq)); + } class experimental_async_interface { public: virtual ~experimental_async_interface() {} @@ -602,6 +713,75 @@ class MilvusService final { virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // *******************************New Interface******************************************* + // + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // TODO(yukun): will change to HQueryResult + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; }; virtual class experimental_async_interface* experimental_async() { return nullptr; } private: @@ -653,6 +833,34 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>* AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>* PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>* AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>* PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: @@ -825,6 +1033,104 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } + ::grpc::Status CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>> AsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>>(AsyncDescribeHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>> PrepareAsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>>(PrepareAsyncDescribeHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> AsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(AsyncCountHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>> AsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>>(AsyncShowHybridCollectionsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>> PrepareAsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>>(PrepareAsyncShowHybridCollectionsRaw(context, request, cq)); + } + ::grpc::Status ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> AsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(AsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + ::grpc::Status PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> AsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(AsyncInsertEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> PrepareAsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(PrepareAsyncInsertEntityRaw(context, request, cq)); + } + ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchRaw(context, request, cq)); + } + ::grpc::Status HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>>(AsyncGetEntityByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>>(PrepareAsyncGetEntityByIDRaw(context, request, cq)); + } + ::grpc::Status GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> AsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(AsyncGetEntityIDsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> PrepareAsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(PrepareAsyncGetEntityIDsRaw(context, request, cq)); + } + ::grpc::Status DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDeleteEntitiesByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDeleteEntitiesByIDRaw(context, request, cq)); + } class experimental_async final : public StubInterface::experimental_async_interface { public: @@ -924,6 +1230,62 @@ class MilvusService final { void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function) override; + void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function) override; + void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit experimental_async(Stub* stub): stub_(stub) { } @@ -983,6 +1345,34 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_CreateCollection_; const ::grpc::internal::RpcMethod rpcmethod_HasCollection_; const ::grpc::internal::RpcMethod rpcmethod_DescribeCollection_; @@ -1007,6 +1397,20 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; + const ::grpc::internal::RpcMethod rpcmethod_CreateHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_HasHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DropHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DescribeHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_CountHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ShowHybridCollections_; + const ::grpc::internal::RpcMethod rpcmethod_ShowHybridCollectionInfo_; + const ::grpc::internal::RpcMethod rpcmethod_PreloadHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_InsertEntity_; + const ::grpc::internal::RpcMethod rpcmethod_HybridSearch_; + const ::grpc::internal::RpcMethod rpcmethod_HybridSearchInSegments_; + const ::grpc::internal::RpcMethod rpcmethod_GetEntityByID_; + const ::grpc::internal::RpcMethod rpcmethod_GetEntityIDs_; + const ::grpc::internal::RpcMethod rpcmethod_DeleteEntitiesByID_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -1182,6 +1586,33 @@ class MilvusService final { // // @return Status virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + // *******************************New Interface******************************************* + // + virtual ::grpc::Status CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status HasHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response); + virtual ::grpc::Status DropHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response); + virtual ::grpc::Status CountHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response); + virtual ::grpc::Status ShowHybridCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response); + virtual ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response); + virtual ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual ::grpc::Status InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response); + // TODO(yukun): will change to HQueryResult + virtual ::grpc::Status HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response); + virtual ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response); + virtual ::grpc::Status GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response); + virtual ::grpc::Status GetEntityIDs(::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response); + virtual ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response); }; template class WithAsyncMethod_CreateCollection : public BaseClass { @@ -1663,7 +2094,287 @@ class MilvusService final { ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + template + class WithAsyncMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodAsync(24); + } + ~WithAsyncMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCreateHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::Mapping* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodAsync(25); + } + ~WithAsyncMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHasHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodAsync(26); + } + ~WithAsyncMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDropHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodAsync(27); + } + ~WithAsyncMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Mapping>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodAsync(28); + } + ~WithAsyncMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCountHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodAsync(29); + } + ~WithAsyncMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::MappingList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodAsync(30); + } + ~WithAsyncMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodAsync(31); + } + ~WithAsyncMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_InsertEntity() { + ::grpc::Service::MarkMethodAsync(32); + } + ~WithAsyncMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestInsertEntity(::grpc::ServerContext* context, ::milvus::grpc::HInsertParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HybridSearch() { + ::grpc::Service::MarkMethodAsync(33); + } + ~WithAsyncMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodAsync(34); + } + ~WithAsyncMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::milvus::grpc::HSearchInSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetEntityByID() { + ::grpc::Service::MarkMethodAsync(35); + } + ~WithAsyncMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::HEntityIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodAsync(36); + } + ~WithAsyncMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityIDs(::grpc::ServerContext* context, ::milvus::grpc::HGetEntityIDsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodAsync(37); + } + ~WithAsyncMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::milvus::grpc::HDeleteByIDParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: @@ -2408,7 +3119,441 @@ class MilvusService final { } virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + template + class ExperimentalWithCallbackMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_CreateHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(24, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::Mapping* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->CreateHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_CreateHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Mapping, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(24)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HasHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(25, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::BoolReply* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HasHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HasHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( + ::grpc::Service::experimental().GetHandler(25)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DropHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(26, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DropHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DropHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(26)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DescribeHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(27, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Mapping* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DescribeHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DescribeHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>*>( + ::grpc::Service::experimental().GetHandler(27)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_CountHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(28, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->CountHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_CountHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( + ::grpc::Service::experimental().GetHandler(28)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ShowHybridCollections() { + ::grpc::Service::experimental().MarkMethodCallback(29, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::Command* request, + ::milvus::grpc::MappingList* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ShowHybridCollections(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ShowHybridCollections( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::MappingList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>*>( + ::grpc::Service::experimental().GetHandler(29)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() { + ::grpc::Service::experimental().MarkMethodCallback(30, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ShowHybridCollectionInfo(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ShowHybridCollectionInfo( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( + ::grpc::Service::experimental().GetHandler(30)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_PreloadHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(31, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->PreloadHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_PreloadHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(31)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_InsertEntity() { + ::grpc::Service::experimental().MarkMethodCallback(32, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HInsertParam* request, + ::milvus::grpc::HEntityIDs* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->InsertEntity(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_InsertEntity( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>*>( + ::grpc::Service::experimental().GetHandler(32)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HybridSearch() { + ::grpc::Service::experimental().MarkMethodCallback(33, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HSearchParam* request, + ::milvus::grpc::TopKQueryResult* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HybridSearch(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HybridSearch( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>*>( + ::grpc::Service::experimental().GetHandler(33)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HybridSearchInSegments() { + ::grpc::Service::experimental().MarkMethodCallback(34, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HSearchInSegmentsParam* request, + ::milvus::grpc::TopKQueryResult* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HybridSearchInSegments(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HybridSearchInSegments( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>*>( + ::grpc::Service::experimental().GetHandler(34)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_GetEntityByID() { + ::grpc::Service::experimental().MarkMethodCallback(35, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HEntityIdentity* request, + ::milvus::grpc::HEntity* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->GetEntityByID(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_GetEntityByID( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>*>( + ::grpc::Service::experimental().GetHandler(35)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_GetEntityIDs() { + ::grpc::Service::experimental().MarkMethodCallback(36, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HGetEntityIDsParam* request, + ::milvus::grpc::HEntityIDs* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->GetEntityIDs(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_GetEntityIDs( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>*>( + ::grpc::Service::experimental().GetHandler(36)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DeleteEntitiesByID() { + ::grpc::Service::experimental().MarkMethodCallback(37, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HDeleteByIDParam* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DeleteEntitiesByID(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DeleteEntitiesByID( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(37)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template class WithGenericMethod_CreateCollection : public BaseClass { private: @@ -2818,6 +3963,244 @@ class MilvusService final { } }; template + class WithGenericMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodGeneric(24); + } + ~WithGenericMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodGeneric(25); + } + ~WithGenericMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodGeneric(26); + } + ~WithGenericMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodGeneric(27); + } + ~WithGenericMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodGeneric(28); + } + ~WithGenericMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodGeneric(29); + } + ~WithGenericMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodGeneric(30); + } + ~WithGenericMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodGeneric(31); + } + ~WithGenericMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_InsertEntity() { + ::grpc::Service::MarkMethodGeneric(32); + } + ~WithGenericMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HybridSearch() { + ::grpc::Service::MarkMethodGeneric(33); + } + ~WithGenericMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodGeneric(34); + } + ~WithGenericMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetEntityByID() { + ::grpc::Service::MarkMethodGeneric(35); + } + ~WithGenericMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodGeneric(36); + } + ~WithGenericMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodGeneric(37); + } + ~WithGenericMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template class WithRawMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -3298,6 +4681,286 @@ class MilvusService final { } }; template + class WithRawMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodRaw(24); + } + ~WithRawMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodRaw(25); + } + ~WithRawMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHasHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodRaw(26); + } + ~WithRawMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDropHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodRaw(27); + } + ~WithRawMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodRaw(28); + } + ~WithRawMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCountHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodRaw(29); + } + ~WithRawMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodRaw(30); + } + ~WithRawMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodRaw(31); + } + ~WithRawMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_InsertEntity() { + ::grpc::Service::MarkMethodRaw(32); + } + ~WithRawMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestInsertEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HybridSearch() { + ::grpc::Service::MarkMethodRaw(33); + } + ~WithRawMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearch(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodRaw(34); + } + ~WithRawMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetEntityByID() { + ::grpc::Service::MarkMethodRaw(35); + } + ~WithRawMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodRaw(36); + } + ~WithRawMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityIDs(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodRaw(37); + } + ~WithRawMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class ExperimentalWithRawCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -3898,6 +5561,356 @@ class MilvusService final { virtual void Compact(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithRawCallbackMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_CreateHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(24, + 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->CreateHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HasHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(25, + 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->HasHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HasHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DropHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(26, + 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->DropHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DropHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DescribeHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(27, + 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->DescribeHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_CountHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(28, + 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->CountHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CountHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ShowHybridCollections() { + ::grpc::Service::experimental().MarkMethodRawCallback(29, + 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->ShowHybridCollections(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() { + ::grpc::Service::experimental().MarkMethodRawCallback(30, + 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->ShowHybridCollectionInfo(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_PreloadHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(31, + 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->PreloadHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_InsertEntity() { + ::grpc::Service::experimental().MarkMethodRawCallback(32, + 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->InsertEntity(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void InsertEntity(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HybridSearch() { + ::grpc::Service::experimental().MarkMethodRawCallback(33, + 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->HybridSearch(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HybridSearchInSegments() { + ::grpc::Service::experimental().MarkMethodRawCallback(34, + 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->HybridSearchInSegments(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_GetEntityByID() { + ::grpc::Service::experimental().MarkMethodRawCallback(35, + 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->GetEntityByID(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_GetEntityIDs() { + ::grpc::Service::experimental().MarkMethodRawCallback(36, + 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->GetEntityIDs(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityIDs(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() { + ::grpc::Service::experimental().MarkMethodRawCallback(37, + 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->DeleteEntitiesByID(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class WithStreamedUnaryMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -4377,9 +6390,289 @@ class MilvusService final { // replace default version of method with streamed unary virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + template + class WithStreamedUnaryMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodStreamed(24, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateHybridCollection::StreamedCreateHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Mapping,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodStreamed(25, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasHybridCollection::StreamedHasHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHasHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodStreamed(26, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropHybridCollection::StreamedDropHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDropHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodStreamed(27, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>(std::bind(&WithStreamedUnaryMethod_DescribeHybridCollection::StreamedDescribeHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Mapping>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodStreamed(28, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountHybridCollection::StreamedCountHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCountHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionRowCount>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodStreamed(29, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollections::StreamedShowHybridCollections, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedShowHybridCollections(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::MappingList>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodStreamed(30, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollectionInfo::StreamedShowHybridCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionInfo>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodStreamed(31, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadHybridCollection::StreamedPreloadHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_InsertEntity() { + ::grpc::Service::MarkMethodStreamed(32, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_InsertEntity::StreamedInsertEntity, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedInsertEntity(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HInsertParam,::milvus::grpc::HEntityIDs>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HybridSearch() { + ::grpc::Service::MarkMethodStreamed(33, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHybridSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodStreamed(34, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearchInSegments::StreamedHybridSearchInSegments, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchInSegmentsParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetEntityByID() { + ::grpc::Service::MarkMethodStreamed(35, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetEntityByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HEntityIdentity,::milvus::grpc::HEntity>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodStreamed(36, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_GetEntityIDs::StreamedGetEntityIDs, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetEntityIDs(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HGetEntityIDsParam,::milvus::grpc::HEntityIDs>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodStreamed(37, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DeleteEntitiesByID::StreamedDeleteEntitiesByID, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HDeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/core/src/grpc/gen-milvus/milvus.pb.cc b/core/src/grpc/gen-milvus/milvus.pb.cc index ed3d048ff6..f5fc22f6d1 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.pb.cc @@ -15,12 +15,26 @@ #include // @@protoc_insertion_point(includes) #include +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldParam_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldType_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldValue_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HEntity_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HSearchParam_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Mapping_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PartitionStat_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_milvus_2eproto; 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_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SegmentStat_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_TermQuery_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldValue_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto; namespace milvus { namespace grpc { class KeyValuePairDefaultTypeInternal { @@ -127,8 +141,131 @@ class GetVectorIDsParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _GetVectorIDsParam_default_instance_; +class VectorFieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldParam_default_instance_; +class FieldTypeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + int data_type_; + const ::milvus::grpc::VectorFieldParam* vector_param_; +} _FieldType_default_instance_; +class FieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldParam_default_instance_; +class VectorFieldValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldValue_default_instance_; +class FieldValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_; + bool bool_value_; + const ::milvus::grpc::VectorFieldValue* vector_value_; +} _FieldValue_default_instance_; +class MappingDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Mapping_default_instance_; +class MappingListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _MappingList_default_instance_; +class TermQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TermQuery_default_instance_; +class CompareExprDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CompareExpr_default_instance_; +class RangeQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RangeQuery_default_instance_; +class VectorQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorQuery_default_instance_; +class BooleanQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BooleanQuery_default_instance_; +class GeneralQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + const ::milvus::grpc::BooleanQuery* boolean_query_; + const ::milvus::grpc::TermQuery* term_query_; + const ::milvus::grpc::RangeQuery* range_query_; + const ::milvus::grpc::VectorQuery* vector_query_; +} _GeneralQuery_default_instance_; +class HSearchParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HSearchParam_default_instance_; +class HSearchInSegmentsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HSearchInSegmentsParam_default_instance_; +class AttrRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _AttrRecord_default_instance_; +class HEntityDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntity_default_instance_; +class HQueryResultDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HQueryResult_default_instance_; +class HInsertParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HInsertParam_default_instance_; +class HEntityIdentityDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntityIdentity_default_instance_; +class HEntityIDsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntityIDs_default_instance_; +class HGetEntityIDsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HGetEntityIDsParam_default_instance_; +class HDeleteByIDParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HDeleteByIDParam_default_instance_; +class HIndexParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HIndexParam_default_instance_; } // namespace grpc } // namespace milvus +static void InitDefaultsscc_info_AttrRecord_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_AttrRecord_default_instance_; + new (ptr) ::milvus::grpc::AttrRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::AttrRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AttrRecord_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -144,6 +281,29 @@ static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_BooleanQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_BooleanQuery_default_instance_; + new (ptr) ::milvus::grpc::BooleanQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + { + void* ptr = &::milvus::grpc::_GeneralQuery_default_instance_; + new (ptr) ::milvus::grpc::GeneralQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::BooleanQuery::InitAsDefaultInstance(); + ::milvus::grpc::GeneralQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_BooleanQuery_milvus_2eproto}, { + &scc_info_TermQuery_milvus_2eproto.base, + &scc_info_RangeQuery_milvus_2eproto.base, + &scc_info_VectorQuery_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_CollectionInfo_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -234,6 +394,20 @@ static void InitDefaultsscc_info_Command_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Command_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Command_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_CompareExpr_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CompareExpr_default_instance_; + new (ptr) ::milvus::grpc::CompareExpr(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CompareExpr::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CompareExpr_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -248,6 +422,52 @@ static void InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeleteByIDParam_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_FieldParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldParam_default_instance_; + new (ptr) ::milvus::grpc::FieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_FieldParam_milvus_2eproto}, { + &scc_info_FieldType_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldType_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldType_default_instance_; + new (ptr) ::milvus::grpc::FieldType(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldType::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldType_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldType_milvus_2eproto}, { + &scc_info_VectorFieldParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldValue_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldValue_default_instance_; + new (ptr) ::milvus::grpc::FieldValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldValue_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldValue_milvus_2eproto}, { + &scc_info_VectorFieldValue_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_FlushParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -276,6 +496,159 @@ static void InitDefaultsscc_info_GetVectorIDsParam_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GetVectorIDsParam_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_GetVectorIDsParam_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_HDeleteByIDParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HDeleteByIDParam_default_instance_; + new (ptr) ::milvus::grpc::HDeleteByIDParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HDeleteByIDParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HDeleteByIDParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HDeleteByIDParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HEntity_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntity_default_instance_; + new (ptr) ::milvus::grpc::HEntity(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntity::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HEntity_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_HEntity_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_AttrRecord_milvus_2eproto.base, + &scc_info_FieldValue_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HEntityIDs_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntityIDs_default_instance_; + new (ptr) ::milvus::grpc::HEntityIDs(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntityIDs::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HEntityIDs_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_HEntityIDs_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_HEntityIdentity_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntityIdentity_default_instance_; + new (ptr) ::milvus::grpc::HEntityIdentity(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntityIdentity::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HEntityIdentity_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HEntityIdentity_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HGetEntityIDsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HGetEntityIDsParam_default_instance_; + new (ptr) ::milvus::grpc::HGetEntityIDsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HGetEntityIDsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HGetEntityIDsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HGetEntityIDsParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HIndexParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HIndexParam_default_instance_; + new (ptr) ::milvus::grpc::HIndexParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HIndexParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HIndexParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HIndexParam_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HInsertParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HInsertParam_default_instance_; + new (ptr) ::milvus::grpc::HInsertParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HInsertParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HInsertParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HInsertParam_milvus_2eproto}, { + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HQueryResult_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HQueryResult_default_instance_; + new (ptr) ::milvus::grpc::HQueryResult(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HQueryResult::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HQueryResult_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HQueryResult_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_HEntity_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HSearchInSegmentsParam_default_instance_; + new (ptr) ::milvus::grpc::HSearchInSegmentsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HSearchInSegmentsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HSearchInSegmentsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto}, { + &scc_info_HSearchParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HSearchParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HSearchParam_default_instance_; + new (ptr) ::milvus::grpc::HSearchParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HSearchParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HSearchParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HSearchParam_milvus_2eproto}, { + &scc_info_BooleanQuery_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_IndexParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -322,6 +695,38 @@ static void InitDefaultsscc_info_KeyValuePair_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_KeyValuePair_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_Mapping_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Mapping_default_instance_; + new (ptr) ::milvus::grpc::Mapping(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Mapping::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Mapping_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_Mapping_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_FieldParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_MappingList_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_MappingList_default_instance_; + new (ptr) ::milvus::grpc::MappingList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::MappingList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_MappingList_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_MappingList_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_Mapping_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_PartitionList_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -366,6 +771,22 @@ static void InitDefaultsscc_info_PartitionStat_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PartitionStat_milvus_2eproto}, { &scc_info_SegmentStat_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_RangeQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_RangeQuery_default_instance_; + new (ptr) ::milvus::grpc::RangeQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::RangeQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RangeQuery_milvus_2eproto}, { + &scc_info_CompareExpr_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_RowRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -455,6 +876,21 @@ static void InitDefaultsscc_info_StringReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_TermQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_TermQuery_default_instance_; + new (ptr) ::milvus::grpc::TermQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::TermQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TermQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TermQuery_milvus_2eproto}, { + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -486,6 +922,35 @@ static void InitDefaultsscc_info_VectorData_milvus_2eproto() { &scc_info_Status_status_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_VectorFieldParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldParam_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorFieldParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_VectorFieldValue_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldValue_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldValue_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorFieldValue_milvus_2eproto}, { + &scc_info_RowRecord_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_VectorIdentity_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -515,8 +980,24 @@ 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[26]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_milvus_2eproto = nullptr; +static void InitDefaultsscc_info_VectorQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorQuery_default_instance_; + new (ptr) ::milvus::grpc::VectorQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_VectorQuery_milvus_2eproto}, { + &scc_info_RowRecord_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[50]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -720,6 +1201,205 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, segment_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, dimension_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, data_type_), + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, vector_param_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, int32_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, int64_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, float_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, double_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, string_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, bool_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, vector_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, collection_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, fields_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, mapping_list_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, values_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operator__), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operand_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, operand_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, query_boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, topk_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, occur_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, general_query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, boolean_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, term_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, range_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, vector_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, partition_tag_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, general_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, segment_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, search_param_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, entity_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, field_names_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, attr_records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, result_values_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, entities_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, row_num_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, score_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, distance_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entities_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entity_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, entity_id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, segment_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, index_type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, extra_params_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::milvus::grpc::KeyValuePair)}, @@ -748,6 +1428,30 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 179, -1, sizeof(::milvus::grpc::VectorIdentity)}, { 186, -1, sizeof(::milvus::grpc::VectorData)}, { 193, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, + { 200, -1, sizeof(::milvus::grpc::VectorFieldParam)}, + { 206, -1, sizeof(::milvus::grpc::FieldType)}, + { 214, -1, sizeof(::milvus::grpc::FieldParam)}, + { 223, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 229, -1, sizeof(::milvus::grpc::FieldValue)}, + { 242, -1, sizeof(::milvus::grpc::Mapping)}, + { 251, -1, sizeof(::milvus::grpc::MappingList)}, + { 258, -1, sizeof(::milvus::grpc::TermQuery)}, + { 267, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 274, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 283, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 293, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 300, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 310, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 319, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 326, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 332, -1, sizeof(::milvus::grpc::HEntity)}, + { 342, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 352, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 362, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 369, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 376, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 383, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 390, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -777,6 +1481,30 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_VectorIdentity_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorData_default_instance_), reinterpret_cast(&::milvus::grpc::_GetVectorIDsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldType_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldValue_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldValue_default_instance_), + reinterpret_cast(&::milvus::grpc::_Mapping_default_instance_), + reinterpret_cast(&::milvus::grpc::_MappingList_default_instance_), + reinterpret_cast(&::milvus::grpc::_TermQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_CompareExpr_default_instance_), + reinterpret_cast(&::milvus::grpc::_RangeQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_BooleanQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_GeneralQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_HSearchParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HSearchInSegmentsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_AttrRecord_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntity_default_instance_), + reinterpret_cast(&::milvus::grpc::_HQueryResult_default_instance_), + reinterpret_cast(&::milvus::grpc::_HInsertParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntityIdentity_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntityIDs_default_instance_), + reinterpret_cast(&::milvus::grpc::_HGetEntityIDsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HDeleteByIDParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HIndexParam_default_instance_), }; const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = @@ -841,95 +1569,280 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "\001(\0132\023.milvus.grpc.Status\022+\n\013vector_data\030" "\002 \001(\0132\026.milvus.grpc.RowRecord\"B\n\021GetVect" "orIDsParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014s" - "egment_name\030\002 \001(\t2\276\r\n\rMilvusService\022H\n\020C" - "reateCollection\022\035.milvus.grpc.Collection" - "Schema\032\023.milvus.grpc.Status\"\000\022F\n\rHasColl" - "ection\022\033.milvus.grpc.CollectionName\032\026.mi" - "lvus.grpc.BoolReply\"\000\022R\n\022DescribeCollect" - "ion\022\033.milvus.grpc.CollectionName\032\035.milvu" - "s.grpc.CollectionSchema\"\000\022Q\n\017CountCollec" - "tion\022\033.milvus.grpc.CollectionName\032\037.milv" - "us.grpc.CollectionRowCount\"\000\022J\n\017ShowColl" - "ections\022\024.milvus.grpc.Command\032\037.milvus.g" - "rpc.CollectionNameList\"\000\022P\n\022ShowCollecti" - "onInfo\022\033.milvus.grpc.CollectionName\032\033.mi" - "lvus.grpc.CollectionInfo\"\000\022D\n\016DropCollec" - "tion\022\033.milvus.grpc.CollectionName\032\023.milv" - "us.grpc.Status\"\000\022=\n\013CreateIndex\022\027.milvus" - ".grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022" - "G\n\rDescribeIndex\022\033.milvus.grpc.Collectio" - "nName\032\027.milvus.grpc.IndexParam\"\000\022\?\n\tDrop" - "Index\022\033.milvus.grpc.CollectionName\032\023.mil" - "vus.grpc.Status\"\000\022E\n\017CreatePartition\022\033.m" - "ilvus.grpc.PartitionParam\032\023.milvus.grpc." - "Status\"\000\022K\n\016ShowPartitions\022\033.milvus.grpc" - ".CollectionName\032\032.milvus.grpc.PartitionL" - "ist\"\000\022C\n\rDropPartition\022\033.milvus.grpc.Par" - "titionParam\032\023.milvus.grpc.Status\"\000\022<\n\006In" - "sert\022\030.milvus.grpc.InsertParam\032\026.milvus." - "grpc.VectorIds\"\000\022G\n\rGetVectorByID\022\033.milv" - "us.grpc.VectorIdentity\032\027.milvus.grpc.Vec" - "torData\"\000\022H\n\014GetVectorIDs\022\036.milvus.grpc." - "GetVectorIDsParam\032\026.milvus.grpc.VectorId" - "s\"\000\022B\n\006Search\022\030.milvus.grpc.SearchParam\032" - "\034.milvus.grpc.TopKQueryResult\"\000\022J\n\nSearc" - "hByID\022\034.milvus.grpc.SearchByIDParam\032\034.mi" - "lvus.grpc.TopKQueryResult\"\000\022P\n\rSearchInF" - "iles\022\037.milvus.grpc.SearchInFilesParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\0227\n\003Cmd\022\024.m" - "ilvus.grpc.Command\032\030.milvus.grpc.StringR" - "eply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.Delet" - "eByIDParam\032\023.milvus.grpc.Status\"\000\022G\n\021Pre" - "loadCollection\022\033.milvus.grpc.CollectionN" - "ame\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mi" - "lvus.grpc.FlushParam\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\007Compact\022\033.milvus.grpc.CollectionN" - "ame\032\023.milvus.grpc.Status\"\000b\006proto3" + "egment_name\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n" + "\tdimension\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_ty" + "pe\030\001 \001(\0162\025.milvus.grpc.DataTypeH\000\0225\n\014vec" + "tor_param\030\002 \001(\0132\035.milvus.grpc.VectorFiel" + "dParamH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 " + "\001(\004\022\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus" + ".grpc.FieldType\022/\n\014extra_params\030\004 \003(\0132\031." + "milvus.grpc.KeyValuePair\"9\n\020VectorFieldV" + "alue\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRec" + "ord\"\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H" + "\000\022\025\n\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030" + "\003 \001(\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014strin" + "g_value\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n" + "\014vector_value\030\007 \001(\0132\035.milvus.grpc.Vector" + "FieldValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006sta" + "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollec" + "tion_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'" + "\n\006fields\030\004 \003(\0132\027.milvus.grpc.FieldParam\"" + "^\n\013MappingList\022#\n\006status\030\001 \001(\0132\023.milvus." + "grpc.Status\022*\n\014mapping_list\030\002 \003(\0132\024.milv" + "us.grpc.Mapping\"o\n\tTermQuery\022\022\n\nfield_na" + "me\030\001 \001(\t\022\016\n\006values\030\002 \003(\t\022\r\n\005boost\030\003 \001(\002\022" + "/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyV" + "aluePair\"N\n\013CompareExpr\022.\n\010operator\030\001 \001(" + "\0162\034.milvus.grpc.CompareOperator\022\017\n\007opera" + "nd\030\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfield_name\030\001 " + "\001(\t\022)\n\007operand\030\002 \003(\0132\030.milvus.grpc.Compa" + "reExpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra_params\030\004 " + "\003(\0132\031.milvus.grpc.KeyValuePair\"\236\001\n\013Vecto" + "rQuery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013query_boos" + "t\030\002 \001(\002\022\'\n\007records\030\003 \003(\0132\026.milvus.grpc.R" + "owRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extra_params\030\005" + " \003(\0132\031.milvus.grpc.KeyValuePair\"c\n\014Boole" + "anQuery\022!\n\005occur\030\001 \001(\0162\022.milvus.grpc.Occ" + "ur\0220\n\rgeneral_query\030\002 \003(\0132\031.milvus.grpc." + "GeneralQuery\"\333\001\n\014GeneralQuery\0222\n\rboolean" + "_query\030\001 \001(\0132\031.milvus.grpc.BooleanQueryH" + "\000\022,\n\nterm_query\030\002 \001(\0132\026.milvus.grpc.Term" + "QueryH\000\022.\n\013range_query\030\003 \001(\0132\027.milvus.gr" + "pc.RangeQueryH\000\0220\n\014vector_query\030\004 \001(\0132\030." + "milvus.grpc.VectorQueryH\000B\007\n\005query\"\247\001\n\014H" + "SearchParam\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023" + "partition_tag_array\030\002 \003(\t\0220\n\rgeneral_que" + "ry\030\003 \001(\0132\031.milvus.grpc.GeneralQuery\022/\n\014e" + "xtra_params\030\004 \003(\0132\031.milvus.grpc.KeyValue" + "Pair\"c\n\026HSearchInSegmentsParam\022\030\n\020segmen" + "t_id_array\030\001 \003(\t\022/\n\014search_param\030\002 \001(\0132\031" + ".milvus.grpc.HSearchParam\"\033\n\nAttrRecord\022" + "\r\n\005value\030\001 \003(\t\"\265\001\n\007HEntity\022#\n\006status\030\001 \001" + "(\0132\023.milvus.grpc.Status\022\021\n\tentity_id\030\002 \001" + "(\003\022\023\n\013field_names\030\003 \003(\t\022-\n\014attr_records\030" + "\004 \003(\0132\027.milvus.grpc.AttrRecord\022.\n\rresult" + "_values\030\005 \003(\0132\027.milvus.grpc.FieldValue\"\215" + "\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.milvus" + ".grpc.Status\022&\n\010entities\030\002 \003(\0132\024.milvus." + "grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005score\030\004" + " \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInsertParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\025\n\rpartition_ta" + "g\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milvus.grpc." + "HEntity\022\027\n\017entity_id_array\030\004 \003(\003\022/\n\014extr" + "a_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"6\n\017HEntityIdentity\022\027\n\017collection_name\030" + "\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022#\n\006statu" + "s\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017entity_i" + "d_array\030\002 \003(\003\"C\n\022HGetEntityIDsParam\022\027\n\017c" + "ollection_name\030\001 \001(\t\022\024\n\014segment_name\030\002 \001" + "(\t\"=\n\020HDeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HIndexPara" + "m\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" + "\n\017collection_name\030\002 \001(\t\022\022\n\nindex_type\030\003 " + "\001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc." + "KeyValuePair*\206\001\n\010DataType\022\010\n\004NULL\020\000\022\010\n\004I" + "NT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT64\020\004\022\n" + "\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022\n\n\006DOUBL" + "E\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n\017Compare" + "Operator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002GT\020" + "\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020\000" + "\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\0032\212\026\n" + "\rMilvusService\022H\n\020CreateCollection\022\035.mil" + "vus.grpc.CollectionSchema\032\023.milvus.grpc." + "Status\"\000\022F\n\rHasCollection\022\033.milvus.grpc." + "CollectionName\032\026.milvus.grpc.BoolReply\"\000" + "\022R\n\022DescribeCollection\022\033.milvus.grpc.Col" + "lectionName\032\035.milvus.grpc.CollectionSche" + "ma\"\000\022Q\n\017CountCollection\022\033.milvus.grpc.Co" + "llectionName\032\037.milvus.grpc.CollectionRow" + "Count\"\000\022J\n\017ShowCollections\022\024.milvus.grpc" + ".Command\032\037.milvus.grpc.CollectionNameLis" + "t\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.grpc." + "CollectionName\032\033.milvus.grpc.CollectionI" + "nfo\"\000\022D\n\016DropCollection\022\033.milvus.grpc.Co" + "llectionName\032\023.milvus.grpc.Status\"\000\022=\n\013C" + "reateIndex\022\027.milvus.grpc.IndexParam\032\023.mi" + "lvus.grpc.Status\"\000\022G\n\rDescribeIndex\022\033.mi" + "lvus.grpc.CollectionName\032\027.milvus.grpc.I" + "ndexParam\"\000\022\?\n\tDropIndex\022\033.milvus.grpc.C" + "ollectionName\032\023.milvus.grpc.Status\"\000\022E\n\017" + "CreatePartition\022\033.milvus.grpc.PartitionP" + "aram\032\023.milvus.grpc.Status\"\000\022K\n\016ShowParti" + "tions\022\033.milvus.grpc.CollectionName\032\032.mil" + "vus.grpc.PartitionList\"\000\022C\n\rDropPartitio" + "n\022\033.milvus.grpc.PartitionParam\032\023.milvus." + "grpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.In" + "sertParam\032\026.milvus.grpc.VectorIds\"\000\022G\n\rG" + "etVectorByID\022\033.milvus.grpc.VectorIdentit" + "y\032\027.milvus.grpc.VectorData\"\000\022H\n\014GetVecto" + "rIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026.m" + "ilvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.milvu" + "s.grpc.SearchParam\032\034.milvus.grpc.TopKQue" + "ryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc.S" + "earchByIDParam\032\034.milvus.grpc.TopKQueryRe" + "sult\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc.Se" + "archInFilesParam\032\034.milvus.grpc.TopKQuery" + "Result\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032\030." + "milvus.grpc.StringReply\"\000\022A\n\nDeleteByID\022" + "\034.milvus.grpc.DeleteByIDParam\032\023.milvus.g" + "rpc.Status\"\000\022G\n\021PreloadCollection\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushParam\032" + "\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\022E\n\026CreateHybridCollection\022\024.milvus" + ".grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L\n\023" + "HasHybridCollection\022\033.milvus.grpc.Collec" + "tionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024Dr" + "opHybridCollection\022\033.milvus.grpc.Collect" + "ionName\032\023.milvus.grpc.Status\"\000\022O\n\030Descri" + "beHybridCollection\022\033.milvus.grpc.Collect" + "ionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Count" + "HybridCollection\022\033.milvus.grpc.Collectio" + "nName\032\037.milvus.grpc.CollectionRowCount\"\000" + "\022I\n\025ShowHybridCollections\022\024.milvus.grpc." + "Command\032\030.milvus.grpc.MappingList\"\000\022V\n\030S" + "howHybridCollectionInfo\022\033.milvus.grpc.Co" + "llectionName\032\033.milvus.grpc.CollectionInf" + "o\"\000\022M\n\027PreloadHybridCollection\022\033.milvus." + "grpc.CollectionName\032\023.milvus.grpc.Status" + "\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInsert" + "Param\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hybr" + "idSearch\022\031.milvus.grpc.HSearchParam\032\034.mi" + "lvus.grpc.TopKQueryResult\"\000\022]\n\026HybridSea" + "rchInSegments\022#.milvus.grpc.HSearchInSeg" + "mentsParam\032\034.milvus.grpc.TopKQueryResult" + "\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEntit" + "yIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014Get" + "EntityIDs\022\037.milvus.grpc.HGetEntityIDsPar" + "am\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022DeleteE" + "ntitiesByID\022\035.milvus.grpc.HDeleteByIDPar" + "am\032\023.milvus.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[26] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[49] = { + &scc_info_AttrRecord_milvus_2eproto.base, &scc_info_BoolReply_milvus_2eproto.base, + &scc_info_BooleanQuery_milvus_2eproto.base, &scc_info_CollectionInfo_milvus_2eproto.base, &scc_info_CollectionName_milvus_2eproto.base, &scc_info_CollectionNameList_milvus_2eproto.base, &scc_info_CollectionRowCount_milvus_2eproto.base, &scc_info_CollectionSchema_milvus_2eproto.base, &scc_info_Command_milvus_2eproto.base, + &scc_info_CompareExpr_milvus_2eproto.base, &scc_info_DeleteByIDParam_milvus_2eproto.base, + &scc_info_FieldParam_milvus_2eproto.base, + &scc_info_FieldType_milvus_2eproto.base, + &scc_info_FieldValue_milvus_2eproto.base, &scc_info_FlushParam_milvus_2eproto.base, &scc_info_GetVectorIDsParam_milvus_2eproto.base, + &scc_info_HDeleteByIDParam_milvus_2eproto.base, + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_HEntityIDs_milvus_2eproto.base, + &scc_info_HEntityIdentity_milvus_2eproto.base, + &scc_info_HGetEntityIDsParam_milvus_2eproto.base, + &scc_info_HIndexParam_milvus_2eproto.base, + &scc_info_HInsertParam_milvus_2eproto.base, + &scc_info_HQueryResult_milvus_2eproto.base, + &scc_info_HSearchInSegmentsParam_milvus_2eproto.base, + &scc_info_HSearchParam_milvus_2eproto.base, &scc_info_IndexParam_milvus_2eproto.base, &scc_info_InsertParam_milvus_2eproto.base, &scc_info_KeyValuePair_milvus_2eproto.base, + &scc_info_Mapping_milvus_2eproto.base, + &scc_info_MappingList_milvus_2eproto.base, &scc_info_PartitionList_milvus_2eproto.base, &scc_info_PartitionParam_milvus_2eproto.base, &scc_info_PartitionStat_milvus_2eproto.base, + &scc_info_RangeQuery_milvus_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base, &scc_info_SearchByIDParam_milvus_2eproto.base, &scc_info_SearchInFilesParam_milvus_2eproto.base, &scc_info_SearchParam_milvus_2eproto.base, &scc_info_SegmentStat_milvus_2eproto.base, &scc_info_StringReply_milvus_2eproto.base, + &scc_info_TermQuery_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorData_milvus_2eproto.base, + &scc_info_VectorFieldParam_milvus_2eproto.base, + &scc_info_VectorFieldValue_milvus_2eproto.base, &scc_info_VectorIdentity_milvus_2eproto.base, &scc_info_VectorIds_milvus_2eproto.base, + &scc_info_VectorQuery_milvus_2eproto.base, }; 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", 4194, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 26, 1, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8393, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 49, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 26, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 50, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. static bool dynamic_init_dummy_milvus_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_milvus_2eproto), true); namespace milvus { namespace grpc { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[0]; +} +bool DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 20: + case 30: + case 40: + case 41: + case 100: + case 9999: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[1]; +} +bool CompareOperator_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[2]; +} +bool Occur_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + // =================================================================== @@ -10378,6 +11291,9462 @@ void GetVectorIDsParam::InternalSwap(GetVectorIDsParam* other) { } +// =================================================================== + +void VectorFieldParam::InitAsDefaultInstance() { +} +class VectorFieldParam::_Internal { + public: +}; + +VectorFieldParam::VectorFieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldParam) +} +VectorFieldParam::VectorFieldParam(const VectorFieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dimension_ = from.dimension_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldParam) +} + +void VectorFieldParam::SharedCtor() { + dimension_ = PROTOBUF_LONGLONG(0); +} + +VectorFieldParam::~VectorFieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldParam) + SharedDtor(); +} + +void VectorFieldParam::SharedDtor() { +} + +void VectorFieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldParam& VectorFieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dimension_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldParam::_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) { + // int64 dimension = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + 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 VectorFieldParam::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.VectorFieldParam) + 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)) { + // int64 dimension = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &dimension_))); + } 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.VectorFieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->dimension(), 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.VectorFieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->dimension(), 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.VectorFieldParam) + return target; +} + +size_t VectorFieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldParam) + 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; + + // int64 dimension = 1; + if (this->dimension() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->dimension()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldParam) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldParam) + MergeFrom(*source); + } +} + +void VectorFieldParam::MergeFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldParam) + 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.dimension() != 0) { + set_dimension(from.dimension()); + } +} + +void VectorFieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldParam::CopyFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldParam::IsInitialized() const { + return true; +} + +void VectorFieldParam::InternalSwap(VectorFieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(dimension_, other->dimension_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldType::InitAsDefaultInstance() { + ::milvus::grpc::_FieldType_default_instance_.data_type_ = 0; + ::milvus::grpc::_FieldType_default_instance_.vector_param_ = const_cast< ::milvus::grpc::VectorFieldParam*>( + ::milvus::grpc::VectorFieldParam::internal_default_instance()); +} +class FieldType::_Internal { + public: + static const ::milvus::grpc::VectorFieldParam& vector_param(const FieldType* msg); +}; + +const ::milvus::grpc::VectorFieldParam& +FieldType::_Internal::vector_param(const FieldType* msg) { + return *msg->value_.vector_param_; +} +void FieldType::set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_param, submessage_arena); + } + set_has_vector_param(); + value_.vector_param_ = vector_param; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldType.vector_param) +} +FieldType::FieldType() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldType) +} +FieldType::FieldType(const FieldType& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldType) +} + +void FieldType::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldType_milvus_2eproto.base); + clear_has_value(); +} + +FieldType::~FieldType() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldType) + SharedDtor(); +} + +void FieldType::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void FieldType::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldType& FieldType::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldType_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldType::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.FieldType) + switch (value_case()) { + case kDataType: { + // No need to clear + break; + } + case kVectorParam: { + delete value_.vector_param_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void FieldType::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldType::_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) { + // .milvus.grpc.DataType data_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_data_type(static_cast<::milvus::grpc::DataType>(val)); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_vector_param(), ptr); + 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 FieldType::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.FieldType) + 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)) { + // .milvus.grpc.DataType data_type = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_data_type(static_cast< ::milvus::grpc::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_param())); + } 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.FieldType) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldType) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldType::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->data_type(), output); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::vector_param(this), 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.FieldType) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldType::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->data_type(), target); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::vector_param(this), 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.FieldType) + return target; +} + +size_t FieldType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldType) + 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; + + switch (value_case()) { + // .milvus.grpc.DataType data_type = 1; + case kDataType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->data_type()); + break; + } + // .milvus.grpc.VectorFieldParam vector_param = 2; + case kVectorParam: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.vector_param_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + const FieldType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldType) + MergeFrom(*source); + } +} + +void FieldType::MergeFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void FieldType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldType::CopyFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldType::IsInitialized() const { + return true; +} + +void FieldType::InternalSwap(FieldType* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldType::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldParam::InitAsDefaultInstance() { + ::milvus::grpc::_FieldParam_default_instance_._instance.get_mutable()->type_ = const_cast< ::milvus::grpc::FieldType*>( + ::milvus::grpc::FieldType::internal_default_instance()); +} +class FieldParam::_Internal { + public: + static const ::milvus::grpc::FieldType& type(const FieldParam* msg); +}; + +const ::milvus::grpc::FieldType& +FieldParam::_Internal::type(const FieldParam* msg) { + return *msg->type_; +} +FieldParam::FieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldParam) +} +FieldParam::FieldParam(const FieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + type_ = new ::milvus::grpc::FieldType(*from.type_); + } else { + type_ = nullptr; + } + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldParam) +} + +void FieldParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldParam_milvus_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&type_, 0, static_cast( + reinterpret_cast(&id_) - + reinterpret_cast(&type_)) + sizeof(id_)); +} + +FieldParam::~FieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldParam) + SharedDtor(); +} + +void FieldParam::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete type_; +} + +void FieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldParam& FieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldParam::_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) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "milvus.grpc.FieldParam.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.FieldType type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 FieldParam::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.FieldParam) + 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)) { + // uint64 id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &id_))); + } else { + goto handle_unusual; + } + break; + } + + // string name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldParam.name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.FieldType type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_type())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.FieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->id(), output); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::type(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.FieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::type(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.FieldParam) + return target; +} + +size_t FieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + const FieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldParam) + MergeFrom(*source); + } +} + +void FieldParam::MergeFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + mutable_type()->::milvus::grpc::FieldType::MergeFrom(from.type()); + } + if (from.id() != 0) { + set_id(from.id()); + } +} + +void FieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldParam::CopyFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldParam::IsInitialized() const { + return true; +} + +void FieldParam::InternalSwap(FieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(type_, other->type_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorFieldValue::InitAsDefaultInstance() { +} +class VectorFieldValue::_Internal { + public: +}; + +VectorFieldValue::VectorFieldValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldValue) +} +VectorFieldValue::VectorFieldValue(const VectorFieldValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + value_(from.value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldValue) +} + +void VectorFieldValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldValue_milvus_2eproto.base); +} + +VectorFieldValue::~VectorFieldValue() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldValue) + SharedDtor(); +} + +void VectorFieldValue::SharedDtor() { +} + +void VectorFieldValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldValue& VectorFieldValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldValue_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldValue::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldValue::_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) { + // repeated .milvus.grpc.RowRecord value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_value(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } 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 VectorFieldValue::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.VectorFieldValue) + 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)) { + // repeated .milvus.grpc.RowRecord value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_value())); + } 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.VectorFieldValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->value(static_cast(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.VectorFieldValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->value(static_cast(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.VectorFieldValue) + return target; +} + +size_t VectorFieldValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldValue) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + { + unsigned int count = static_cast(this->value_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->value(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldValue) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldValue) + MergeFrom(*source); + } +} + +void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); +} + +void VectorFieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldValue::CopyFrom(const VectorFieldValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldValue::IsInitialized() const { + return true; +} + +void VectorFieldValue::InternalSwap(VectorFieldValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&value_)->InternalSwap(CastToBase(&other->value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldValue::InitAsDefaultInstance() { + ::milvus::grpc::_FieldValue_default_instance_.int32_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.int64_value_ = PROTOBUF_LONGLONG(0); + ::milvus::grpc::_FieldValue_default_instance_.float_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.double_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.string_value_.UnsafeSetDefault( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::milvus::grpc::_FieldValue_default_instance_.bool_value_ = false; + ::milvus::grpc::_FieldValue_default_instance_.vector_value_ = const_cast< ::milvus::grpc::VectorFieldValue*>( + ::milvus::grpc::VectorFieldValue::internal_default_instance()); +} +class FieldValue::_Internal { + public: + static const ::milvus::grpc::VectorFieldValue& vector_value(const FieldValue* msg); +}; + +const ::milvus::grpc::VectorFieldValue& +FieldValue::_Internal::vector_value(const FieldValue* msg) { + return *msg->value_.vector_value_; +} +void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (vector_value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_value, submessage_arena); + } + set_has_vector_value(); + value_.vector_value_ = vector_value; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.vector_value) +} +FieldValue::FieldValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldValue) +} +FieldValue::FieldValue(const FieldValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case kStringValue: { + set_string_value(from.string_value()); + break; + } + case kBoolValue: { + set_bool_value(from.bool_value()); + break; + } + case kVectorValue: { + mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldValue) +} + +void FieldValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldValue_milvus_2eproto.base); + clear_has_value(); +} + +FieldValue::~FieldValue() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldValue) + SharedDtor(); +} + +void FieldValue::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void FieldValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldValue& FieldValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldValue_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldValue::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.FieldValue) + switch (value_case()) { + case kInt32Value: { + // No need to clear + break; + } + case kInt64Value: { + // No need to clear + break; + } + case kFloatValue: { + // No need to clear + break; + } + case kDoubleValue: { + // No need to clear + break; + } + case kStringValue: { + value_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + break; + } + case kBoolValue: { + // No need to clear + break; + } + case kVectorValue: { + delete value_.vector_value_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void FieldValue::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldValue::_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) { + // int32 int32_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + set_int32_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 int64_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + set_int64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float float_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + set_float_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // double double_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) { + set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // string string_value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_string_value(), ptr, ctx, "milvus.grpc.FieldValue.string_value"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool bool_value = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorFieldValue vector_value = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(mutable_vector_value(), ptr); + 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 FieldValue::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.FieldValue) + 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)) { + // int32 int32_value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &value_.int32_value_))); + set_has_int32_value(); + } else { + goto handle_unusual; + } + break; + } + + // int64 int64_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &value_.int64_value_))); + set_has_int64_value(); + } else { + goto handle_unusual; + } + break; + } + + // float float_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &value_.float_value_))); + set_has_float_value(); + } else { + goto handle_unusual; + } + break; + } + + // double double_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (33 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, &value_.double_value_))); + set_has_double_value(); + } else { + goto handle_unusual; + } + break; + } + + // string string_value = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_string_value())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldValue.string_value")); + } else { + goto handle_unusual; + } + break; + } + + // bool bool_value = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &value_.bool_value_))); + set_has_bool_value(); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_value())); + } 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.FieldValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->int32_value(), output); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->int64_value(), output); + } + + // float float_value = 3; + if (has_float_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->float_value(), output); + } + + // double double_value = 4; + if (has_double_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(4, this->double_value(), output); + } + + // string string_value = 5; + if (has_string_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldValue.string_value"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->string_value(), output); + } + + // bool bool_value = 6; + if (has_bool_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->bool_value(), output); + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + if (has_vector_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, _Internal::vector_value(this), 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.FieldValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->int32_value(), target); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->int64_value(), target); + } + + // float float_value = 3; + if (has_float_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->float_value(), target); + } + + // double double_value = 4; + if (has_double_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->double_value(), target); + } + + // string string_value = 5; + if (has_string_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldValue.string_value"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 5, this->string_value(), target); + } + + // bool bool_value = 6; + if (has_bool_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->bool_value(), target); + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + if (has_vector_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 7, _Internal::vector_value(this), 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.FieldValue) + return target; +} + +size_t FieldValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldValue) + 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; + + switch (value_case()) { + // int32 int32_value = 1; + case kInt32Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->int32_value()); + break; + } + // int64 int64_value = 2; + case kInt64Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->int64_value()); + break; + } + // float float_value = 3; + case kFloatValue: { + total_size += 1 + 4; + break; + } + // double double_value = 4; + case kDoubleValue: { + total_size += 1 + 8; + break; + } + // string string_value = 5; + case kStringValue: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->string_value()); + break; + } + // bool bool_value = 6; + case kBoolValue: { + total_size += 1 + 1; + break; + } + // .milvus.grpc.VectorFieldValue vector_value = 7; + case kVectorValue: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.vector_value_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + const FieldValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldValue) + MergeFrom(*source); + } +} + +void FieldValue::MergeFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case kStringValue: { + set_string_value(from.string_value()); + break; + } + case kBoolValue: { + set_bool_value(from.bool_value()); + break; + } + case kVectorValue: { + mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void FieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldValue::CopyFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldValue::IsInitialized() const { + return true; +} + +void FieldValue::InternalSwap(FieldValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Mapping::InitAsDefaultInstance() { + ::milvus::grpc::_Mapping_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class Mapping::_Internal { + public: + static const ::milvus::grpc::Status& status(const Mapping* msg); +}; + +const ::milvus::grpc::Status& +Mapping::_Internal::status(const Mapping* msg) { + return *msg->status_; +} +void Mapping::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +Mapping::Mapping() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Mapping) +} +Mapping::Mapping(const Mapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + fields_(from.fields_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + collection_id_ = from.collection_id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Mapping) +} + +void Mapping::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Mapping_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&collection_id_) - + reinterpret_cast(&status_)) + sizeof(collection_id_)); +} + +Mapping::~Mapping() { + // @@protoc_insertion_point(destructor:milvus.grpc.Mapping) + SharedDtor(); +} + +void Mapping::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void Mapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Mapping& Mapping::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Mapping_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void Mapping::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + collection_id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Mapping::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 collection_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + collection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.Mapping.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.FieldParam fields = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 Mapping::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.Mapping) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // uint64 collection_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &collection_id_))); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.Mapping.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.FieldParam fields = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_fields())); + } 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.Mapping) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Mapping) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Mapping::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->collection_id(), output); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->collection_name(), output); + } + + // repeated .milvus.grpc.FieldParam fields = 4; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->fields(static_cast(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.Mapping) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Mapping::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->collection_id(), target); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->collection_name(), target); + } + + // repeated .milvus.grpc.FieldParam fields = 4; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->fields(static_cast(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.Mapping) + return target; +} + +size_t Mapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Mapping) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.FieldParam fields = 4; + { + unsigned int count = static_cast(this->fields_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->fields(static_cast(i))); + } + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->collection_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Mapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + const Mapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Mapping) + MergeFrom(*source); + } +} + +void Mapping::MergeFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.collection_id() != 0) { + set_collection_id(from.collection_id()); + } +} + +void Mapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Mapping::CopyFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Mapping::IsInitialized() const { + return true; +} + +void Mapping::InternalSwap(Mapping* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&fields_)->InternalSwap(CastToBase(&other->fields_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); + swap(collection_id_, other->collection_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Mapping::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void MappingList::InitAsDefaultInstance() { + ::milvus::grpc::_MappingList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class MappingList::_Internal { + public: + static const ::milvus::grpc::Status& status(const MappingList* msg); +}; + +const ::milvus::grpc::Status& +MappingList::_Internal::status(const MappingList* msg) { + return *msg->status_; +} +void MappingList::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +MappingList::MappingList() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.MappingList) +} +MappingList::MappingList(const MappingList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + mapping_list_(from.mapping_list_) { + _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.MappingList) +} + +void MappingList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MappingList_milvus_2eproto.base); + status_ = nullptr; +} + +MappingList::~MappingList() { + // @@protoc_insertion_point(destructor:milvus.grpc.MappingList) + SharedDtor(); +} + +void MappingList::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void MappingList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const MappingList& MappingList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MappingList_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void MappingList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mapping_list_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* MappingList::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_mapping_list(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool MappingList::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.MappingList) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_mapping_list())); + } 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.MappingList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.MappingList) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void MappingList::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->mapping_list(static_cast(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.MappingList) +} + +::PROTOBUF_NAMESPACE_ID::uint8* MappingList::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->mapping_list(static_cast(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.MappingList) + return target; +} + +size_t MappingList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.MappingList) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.Mapping mapping_list = 2; + { + unsigned int count = static_cast(this->mapping_list_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->mapping_list(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MappingList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + const MappingList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.MappingList) + MergeFrom(*source); + } +} + +void MappingList::MergeFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + mapping_list_.MergeFrom(from.mapping_list_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void MappingList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MappingList::CopyFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MappingList::IsInitialized() const { + return true; +} + +void MappingList::InternalSwap(MappingList* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&mapping_list_)->InternalSwap(CastToBase(&other->mapping_list_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MappingList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TermQuery::InitAsDefaultInstance() { +} +class TermQuery::_Internal { + public: +}; + +TermQuery::TermQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.TermQuery) +} +TermQuery::TermQuery(const TermQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + values_(from.values_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + boost_ = from.boost_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.TermQuery) +} + +void TermQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; +} + +TermQuery::~TermQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.TermQuery) + SharedDtor(); +} + +void TermQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TermQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TermQuery& TermQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TermQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void TermQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + values_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TermQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.TermQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string values = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_values(), ptr, ctx, "milvus.grpc.TermQuery.values"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // float boost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 TermQuery::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.TermQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.TermQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string values = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_values())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(this->values_size() - 1).data(), + static_cast(this->values(this->values_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.TermQuery.values")); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.TermQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.TermQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TermQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated string values = 2; + for (int i = 0, n = this->values_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(i).data(), static_cast(this->values(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.values"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->values(i), output); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.TermQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TermQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated string values = 2; + for (int i = 0, n = this->values_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(i).data(), static_cast(this->values(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.values"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->values(i), target); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.TermQuery) + return target; +} + +size_t TermQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TermQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string values = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->values_size()); + for (int i = 0, n = this->values_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->values(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TermQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + const TermQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TermQuery) + MergeFrom(*source); + } +} + +void TermQuery::MergeFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + values_.MergeFrom(from.values_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void TermQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TermQuery::CopyFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TermQuery::IsInitialized() const { + return true; +} + +void TermQuery::InternalSwap(TermQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + values_.InternalSwap(CastToBase(&other->values_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TermQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CompareExpr::InitAsDefaultInstance() { +} +class CompareExpr::_Internal { + public: +}; + +CompareExpr::CompareExpr() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CompareExpr) +} +CompareExpr::CompareExpr(const CompareExpr& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.operand().empty()) { + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + operator__ = from.operator__; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CompareExpr) +} + +void CompareExpr::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompareExpr_milvus_2eproto.base); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; +} + +CompareExpr::~CompareExpr() { + // @@protoc_insertion_point(destructor:milvus.grpc.CompareExpr) + SharedDtor(); +} + +void CompareExpr::SharedDtor() { + operand_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CompareExpr::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CompareExpr& CompareExpr::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompareExpr_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void CompareExpr::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CompareExpr::_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) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_operator_(static_cast<::milvus::grpc::CompareOperator>(val)); + } else goto handle_unusual; + continue; + // string operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_operand(), ptr, ctx, "milvus.grpc.CompareExpr.operand"); + 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 CompareExpr::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.CompareExpr) + 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)) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_operator_(static_cast< ::milvus::grpc::CompareOperator >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_operand())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CompareExpr.operand")); + } 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.CompareExpr) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CompareExpr) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CompareExpr::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->operator_(), output); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->operand(), 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.CompareExpr) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CompareExpr::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->operator_(), target); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->operand(), 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.CompareExpr) + return target; +} + +size_t CompareExpr::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CompareExpr) + 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 operand = 2; + if (this->operand().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->operand()); + } + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->operator_()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CompareExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CompareExpr) + GOOGLE_DCHECK_NE(&from, this); + const CompareExpr* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CompareExpr) + MergeFrom(*source); + } +} + +void CompareExpr::MergeFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CompareExpr) + 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.operand().size() > 0) { + + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + if (from.operator_() != 0) { + set_operator_(from.operator_()); + } +} + +void CompareExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CompareExpr::CopyFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CompareExpr::IsInitialized() const { + return true; +} + +void CompareExpr::InternalSwap(CompareExpr* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + operand_.Swap(&other->operand_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(operator__, other->operator__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CompareExpr::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RangeQuery::InitAsDefaultInstance() { +} +class RangeQuery::_Internal { + public: +}; + +RangeQuery::RangeQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.RangeQuery) +} +RangeQuery::RangeQuery(const RangeQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + operand_(from.operand_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + boost_ = from.boost_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.RangeQuery) +} + +void RangeQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RangeQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; +} + +RangeQuery::~RangeQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.RangeQuery) + SharedDtor(); +} + +void RangeQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RangeQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeQuery& RangeQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RangeQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void RangeQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RangeQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.RangeQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_operand(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // float boost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 RangeQuery::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.RangeQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.RangeQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_operand())); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.RangeQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.RangeQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RangeQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->operand(static_cast(i)), + output); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.RangeQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RangeQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->operand(static_cast(i)), target); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.RangeQuery) + return target; +} + +size_t RangeQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.RangeQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.CompareExpr operand = 2; + { + unsigned int count = static_cast(this->operand_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->operand(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + const RangeQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.RangeQuery) + MergeFrom(*source); + } +} + +void RangeQuery::MergeFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + operand_.MergeFrom(from.operand_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void RangeQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RangeQuery::CopyFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeQuery::IsInitialized() const { + return true; +} + +void RangeQuery::InternalSwap(RangeQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&operand_)->InternalSwap(CastToBase(&other->operand_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RangeQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorQuery::InitAsDefaultInstance() { +} +class VectorQuery::_Internal { + public: +}; + +VectorQuery::VectorQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorQuery) +} +VectorQuery::VectorQuery(const VectorQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + records_(from.records_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + ::memcpy(&topk_, &from.topk_, + static_cast(reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorQuery) +} + +void VectorQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); +} + +VectorQuery::~VectorQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorQuery) + SharedDtor(); +} + +void VectorQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VectorQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorQuery& VectorQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + records_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.VectorQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float query_boost = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + query_boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.RowRecord records = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // int64 topk = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 VectorQuery::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.VectorQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.VectorQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // float query_boost = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &query_boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.RowRecord records = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_records())); + } else { + goto handle_unusual; + } + break; + } + + // int64 topk = 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>( + input, &topk_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.VectorQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->query_boost(), output); + } + + // repeated .milvus.grpc.RowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, + this->records(static_cast(i)), + output); + } + + // int64 topk = 4; + if (this->topk() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->topk(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(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.VectorQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->query_boost(), target); + } + + // repeated .milvus.grpc.RowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, this->records(static_cast(i)), target); + } + + // int64 topk = 4; + if (this->topk() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->topk(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(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.VectorQuery) + return target; +} + +size_t VectorQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord records = 3; + { + unsigned int count = static_cast(this->records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->records(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // int64 topk = 4; + if (this->topk() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->topk()); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + const VectorQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorQuery) + MergeFrom(*source); + } +} + +void VectorQuery::MergeFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + records_.MergeFrom(from.records_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.topk() != 0) { + set_topk(from.topk()); + } + if (!(from.query_boost() <= 0 && from.query_boost() >= 0)) { + set_query_boost(from.query_boost()); + } +} + +void VectorQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorQuery::CopyFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorQuery::IsInitialized() const { + return true; +} + +void VectorQuery::InternalSwap(VectorQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&records_)->InternalSwap(CastToBase(&other->records_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(topk_, other->topk_); + swap(query_boost_, other->query_boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BooleanQuery::InitAsDefaultInstance() { +} +class BooleanQuery::_Internal { + public: +}; + +BooleanQuery::BooleanQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.BooleanQuery) +} +BooleanQuery::BooleanQuery(const BooleanQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + general_query_(from.general_query_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + occur_ = from.occur_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.BooleanQuery) +} + +void BooleanQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_milvus_2eproto.base); + occur_ = 0; +} + +BooleanQuery::~BooleanQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.BooleanQuery) + SharedDtor(); +} + +void BooleanQuery::SharedDtor() { +} + +void BooleanQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BooleanQuery& BooleanQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void BooleanQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + general_query_.Clear(); + occur_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BooleanQuery::_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) { + // .milvus.grpc.Occur occur = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_occur(static_cast<::milvus::grpc::Occur>(val)); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_general_query(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BooleanQuery::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.BooleanQuery) + 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)) { + // .milvus.grpc.Occur occur = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_occur(static_cast< ::milvus::grpc::Occur >(value)); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_general_query())); + } 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.BooleanQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.BooleanQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BooleanQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->occur(), output); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->general_query(static_cast(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.BooleanQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BooleanQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->occur(), target); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->general_query(static_cast(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.BooleanQuery) + return target; +} + +size_t BooleanQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.BooleanQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + { + unsigned int count = static_cast(this->general_query_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->general_query(static_cast(i))); + } + } + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->occur()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BooleanQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + const BooleanQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.BooleanQuery) + MergeFrom(*source); + } +} + +void BooleanQuery::MergeFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + general_query_.MergeFrom(from.general_query_); + if (from.occur() != 0) { + set_occur(from.occur()); + } +} + +void BooleanQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BooleanQuery::CopyFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BooleanQuery::IsInitialized() const { + return true; +} + +void BooleanQuery::InternalSwap(BooleanQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&general_query_)->InternalSwap(CastToBase(&other->general_query_)); + swap(occur_, other->occur_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BooleanQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GeneralQuery::InitAsDefaultInstance() { + ::milvus::grpc::_GeneralQuery_default_instance_.boolean_query_ = const_cast< ::milvus::grpc::BooleanQuery*>( + ::milvus::grpc::BooleanQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.term_query_ = const_cast< ::milvus::grpc::TermQuery*>( + ::milvus::grpc::TermQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.range_query_ = const_cast< ::milvus::grpc::RangeQuery*>( + ::milvus::grpc::RangeQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.vector_query_ = const_cast< ::milvus::grpc::VectorQuery*>( + ::milvus::grpc::VectorQuery::internal_default_instance()); +} +class GeneralQuery::_Internal { + public: + static const ::milvus::grpc::BooleanQuery& boolean_query(const GeneralQuery* msg); + static const ::milvus::grpc::TermQuery& term_query(const GeneralQuery* msg); + static const ::milvus::grpc::RangeQuery& range_query(const GeneralQuery* msg); + static const ::milvus::grpc::VectorQuery& vector_query(const GeneralQuery* msg); +}; + +const ::milvus::grpc::BooleanQuery& +GeneralQuery::_Internal::boolean_query(const GeneralQuery* msg) { + return *msg->query_.boolean_query_; +} +const ::milvus::grpc::TermQuery& +GeneralQuery::_Internal::term_query(const GeneralQuery* msg) { + return *msg->query_.term_query_; +} +const ::milvus::grpc::RangeQuery& +GeneralQuery::_Internal::range_query(const GeneralQuery* msg) { + return *msg->query_.range_query_; +} +const ::milvus::grpc::VectorQuery& +GeneralQuery::_Internal::vector_query(const GeneralQuery* msg) { + return *msg->query_.vector_query_; +} +void GeneralQuery::set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + boolean_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, boolean_query, submessage_arena); + } + set_has_boolean_query(); + query_.boolean_query_ = boolean_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.boolean_query) +} +void GeneralQuery::set_allocated_term_query(::milvus::grpc::TermQuery* term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + term_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, term_query, submessage_arena); + } + set_has_term_query(); + query_.term_query_ = term_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.term_query) +} +void GeneralQuery::set_allocated_range_query(::milvus::grpc::RangeQuery* range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + range_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, range_query, submessage_arena); + } + set_has_range_query(); + query_.range_query_ = range_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.range_query) +} +void GeneralQuery::set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_query, submessage_arena); + } + set_has_vector_query(); + query_.vector_query_ = vector_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.vector_query) +} +GeneralQuery::GeneralQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.GeneralQuery) +} +GeneralQuery::GeneralQuery(const GeneralQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_query(); + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.GeneralQuery) +} + +void GeneralQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_milvus_2eproto.base); + clear_has_query(); +} + +GeneralQuery::~GeneralQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.GeneralQuery) + SharedDtor(); +} + +void GeneralQuery::SharedDtor() { + if (has_query()) { + clear_query(); + } +} + +void GeneralQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GeneralQuery& GeneralQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void GeneralQuery::clear_query() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.GeneralQuery) + switch (query_case()) { + case kBooleanQuery: { + delete query_.boolean_query_; + break; + } + case kTermQuery: { + delete query_.term_query_; + break; + } + case kRangeQuery: { + delete query_.range_query_; + break; + } + case kVectorQuery: { + delete query_.vector_query_; + break; + } + case QUERY_NOT_SET: { + break; + } + } + _oneof_case_[0] = QUERY_NOT_SET; +} + + +void GeneralQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_query(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* GeneralQuery::_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) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_boolean_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.TermQuery term_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_term_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.RangeQuery range_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_range_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(mutable_vector_query(), ptr); + 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 GeneralQuery::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.GeneralQuery) + 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)) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_boolean_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.TermQuery term_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_term_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.RangeQuery range_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_range_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_query())); + } 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.GeneralQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.GeneralQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void GeneralQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::boolean_query(this), output); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::term_query(this), output); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::range_query(this), output); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, _Internal::vector_query(this), 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.GeneralQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* GeneralQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::boolean_query(this), target); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::term_query(this), target); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::range_query(this), target); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, _Internal::vector_query(this), 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.GeneralQuery) + return target; +} + +size_t GeneralQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.GeneralQuery) + 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; + + switch (query_case()) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case kBooleanQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.boolean_query_); + break; + } + // .milvus.grpc.TermQuery term_query = 2; + case kTermQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.term_query_); + break; + } + // .milvus.grpc.RangeQuery range_query = 3; + case kRangeQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.range_query_); + break; + } + // .milvus.grpc.VectorQuery vector_query = 4; + case kVectorQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.vector_query_); + break; + } + case QUERY_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GeneralQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + const GeneralQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.GeneralQuery) + MergeFrom(*source); + } +} + +void GeneralQuery::MergeFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } +} + +void GeneralQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GeneralQuery::CopyFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GeneralQuery::IsInitialized() const { + return true; +} + +void GeneralQuery::InternalSwap(GeneralQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(query_, other->query_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GeneralQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HSearchParam::InitAsDefaultInstance() { + ::milvus::grpc::_HSearchParam_default_instance_._instance.get_mutable()->general_query_ = const_cast< ::milvus::grpc::GeneralQuery*>( + ::milvus::grpc::GeneralQuery::internal_default_instance()); +} +class HSearchParam::_Internal { + public: + static const ::milvus::grpc::GeneralQuery& general_query(const HSearchParam* msg); +}; + +const ::milvus::grpc::GeneralQuery& +HSearchParam::_Internal::general_query(const HSearchParam* msg) { + return *msg->general_query_; +} +HSearchParam::HSearchParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HSearchParam) +} +HSearchParam::HSearchParam(const HSearchParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + partition_tag_array_(from.partition_tag_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + general_query_ = new ::milvus::grpc::GeneralQuery(*from.general_query_); + } else { + general_query_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HSearchParam) +} + +void HSearchParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HSearchParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + general_query_ = nullptr; +} + +HSearchParam::~HSearchParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HSearchParam) + SharedDtor(); +} + +void HSearchParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete general_query_; +} + +void HSearchParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HSearchParam& HSearchParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HSearchParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HSearchParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HSearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HSearchParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag_array(), ptr, ctx, "milvus.grpc.HSearchParam.partition_tag_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_general_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 HSearchParam::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.HSearchParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(this->partition_tag_array_size() - 1).data(), + static_cast(this->partition_tag_array(this->partition_tag_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchParam.partition_tag_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_general_query())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HSearchParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HSearchParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HSearchParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.partition_tag_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->partition_tag_array(i), output); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::general_query(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.HSearchParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HSearchParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.partition_tag_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->partition_tag_array(i), target); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::general_query(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.HSearchParam) + return target; +} + +size_t HSearchParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HSearchParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string partition_tag_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_array_size()); + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag_array(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *general_query_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HSearchParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HSearchParam) + GOOGLE_DCHECK_NE(&from, this); + const HSearchParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HSearchParam) + MergeFrom(*source); + } +} + +void HSearchParam::MergeFrom(const HSearchParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HSearchParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partition_tag_array_.MergeFrom(from.partition_tag_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + mutable_general_query()->::milvus::grpc::GeneralQuery::MergeFrom(from.general_query()); + } +} + +void HSearchParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HSearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HSearchParam::CopyFrom(const HSearchParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HSearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HSearchParam::IsInitialized() const { + return true; +} + +void HSearchParam::InternalSwap(HSearchParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(general_query_, other->general_query_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HSearchParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HSearchInSegmentsParam::InitAsDefaultInstance() { + ::milvus::grpc::_HSearchInSegmentsParam_default_instance_._instance.get_mutable()->search_param_ = const_cast< ::milvus::grpc::HSearchParam*>( + ::milvus::grpc::HSearchParam::internal_default_instance()); +} +class HSearchInSegmentsParam::_Internal { + public: + static const ::milvus::grpc::HSearchParam& search_param(const HSearchInSegmentsParam* msg); +}; + +const ::milvus::grpc::HSearchParam& +HSearchInSegmentsParam::_Internal::search_param(const HSearchInSegmentsParam* msg) { + return *msg->search_param_; +} +HSearchInSegmentsParam::HSearchInSegmentsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HSearchInSegmentsParam) +} +HSearchInSegmentsParam::HSearchInSegmentsParam(const HSearchInSegmentsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_id_array_(from.segment_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_search_param()) { + search_param_ = new ::milvus::grpc::HSearchParam(*from.search_param_); + } else { + search_param_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HSearchInSegmentsParam) +} + +void HSearchInSegmentsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HSearchInSegmentsParam_milvus_2eproto.base); + search_param_ = nullptr; +} + +HSearchInSegmentsParam::~HSearchInSegmentsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HSearchInSegmentsParam) + SharedDtor(); +} + +void HSearchInSegmentsParam::SharedDtor() { + if (this != internal_default_instance()) delete search_param_; +} + +void HSearchInSegmentsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HSearchInSegmentsParam& HSearchInSegmentsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HSearchInSegmentsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HSearchInSegmentsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HSearchInSegmentsParam::_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) { + // repeated string segment_id_array = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_segment_id_array(), ptr, ctx, "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + // .milvus.grpc.HSearchParam search_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_search_param(), ptr); + 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 HSearchInSegmentsParam::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.HSearchInSegmentsParam) + 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)) { + // repeated string segment_id_array = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_segment_id_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(this->segment_id_array_size() - 1).data(), + static_cast(this->segment_id_array(this->segment_id_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.HSearchParam search_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_search_param())); + } 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.HSearchInSegmentsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HSearchInSegmentsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HSearchInSegmentsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->segment_id_array(i), output); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::search_param(this), 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.HSearchInSegmentsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HSearchInSegmentsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->segment_id_array(i), target); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::search_param(this), 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.HSearchInSegmentsParam) + return target; +} + +size_t HSearchInSegmentsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HSearchInSegmentsParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->segment_id_array_size()); + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_id_array(i)); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *search_param_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HSearchInSegmentsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HSearchInSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + const HSearchInSegmentsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HSearchInSegmentsParam) + MergeFrom(*source); + } +} + +void HSearchInSegmentsParam::MergeFrom(const HSearchInSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HSearchInSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_id_array_.MergeFrom(from.segment_id_array_); + if (from.has_search_param()) { + mutable_search_param()->::milvus::grpc::HSearchParam::MergeFrom(from.search_param()); + } +} + +void HSearchInSegmentsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HSearchInSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HSearchInSegmentsParam::CopyFrom(const HSearchInSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HSearchInSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HSearchInSegmentsParam::IsInitialized() const { + return true; +} + +void HSearchInSegmentsParam::InternalSwap(HSearchInSegmentsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_id_array_.InternalSwap(CastToBase(&other->segment_id_array_)); + swap(search_param_, other->search_param_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HSearchInSegmentsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void AttrRecord::InitAsDefaultInstance() { +} +class AttrRecord::_Internal { + public: +}; + +AttrRecord::AttrRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.AttrRecord) +} +AttrRecord::AttrRecord(const AttrRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + value_(from.value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.AttrRecord) +} + +void AttrRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttrRecord_milvus_2eproto.base); +} + +AttrRecord::~AttrRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.AttrRecord) + SharedDtor(); +} + +void AttrRecord::SharedDtor() { +} + +void AttrRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const AttrRecord& AttrRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttrRecord_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void AttrRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* AttrRecord::_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) { + // repeated string value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_value(), ptr, ctx, "milvus.grpc.AttrRecord.value"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } 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 AttrRecord::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.AttrRecord) + 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)) { + // repeated string value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_value())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(this->value_size() - 1).data(), + static_cast(this->value(this->value_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.AttrRecord.value")); + } 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.AttrRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.AttrRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void AttrRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string value = 1; + for (int i = 0, n = this->value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(i).data(), static_cast(this->value(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.AttrRecord.value"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->value(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.AttrRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* AttrRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string value = 1; + for (int i = 0, n = this->value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(i).data(), static_cast(this->value(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.AttrRecord.value"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->value(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.AttrRecord) + return target; +} + +size_t AttrRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.AttrRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string value = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->value_size()); + for (int i = 0, n = this->value_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->value(i)); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AttrRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + const AttrRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.AttrRecord) + MergeFrom(*source); + } +} + +void AttrRecord::MergeFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); +} + +void AttrRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttrRecord::CopyFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttrRecord::IsInitialized() const { + return true; +} + +void AttrRecord::InternalSwap(AttrRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + value_.InternalSwap(CastToBase(&other->value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AttrRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntity::InitAsDefaultInstance() { + ::milvus::grpc::_HEntity_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HEntity::_Internal { + public: + static const ::milvus::grpc::Status& status(const HEntity* msg); +}; + +const ::milvus::grpc::Status& +HEntity::_Internal::status(const HEntity* msg) { + return *msg->status_; +} +void HEntity::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HEntity::HEntity() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntity) +} +HEntity::HEntity(const HEntity& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + field_names_(from.field_names_), + attr_records_(from.attr_records_), + result_values_(from.result_values_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + entity_id_ = from.entity_id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntity) +} + +void HEntity::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntity_milvus_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&entity_id_) - + reinterpret_cast(&status_)) + sizeof(entity_id_)); +} + +HEntity::~HEntity() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntity) + SharedDtor(); +} + +void HEntity::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HEntity::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntity& HEntity::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntity_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntity::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_names_.Clear(); + attr_records_.Clear(); + result_values_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + entity_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntity::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 entity_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + entity_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string field_names = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_field_names(), ptr, ctx, "milvus.grpc.HEntity.field_names"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.AttrRecord attr_records = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_attr_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.FieldValue result_values = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_result_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 HEntity::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.HEntity) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // int64 entity_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &entity_id_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated string field_names = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_field_names())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(this->field_names_size() - 1).data(), + static_cast(this->field_names(this->field_names_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HEntity.field_names")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_attr_records())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_result_values())); + } 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.HEntity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntity) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntity::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->entity_id(), output); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntity.field_names"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 3, this->field_names(i), output); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + for (unsigned int i = 0, + n = static_cast(this->attr_records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->attr_records(static_cast(i)), + output); + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + for (unsigned int i = 0, + n = static_cast(this->result_values_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->result_values(static_cast(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.HEntity) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntity::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->entity_id(), target); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntity.field_names"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(3, this->field_names(i), target); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + for (unsigned int i = 0, + n = static_cast(this->attr_records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->attr_records(static_cast(i)), target); + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + for (unsigned int i = 0, + n = static_cast(this->result_values_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->result_values(static_cast(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.HEntity) + return target; +} + +size_t HEntity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntity) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string field_names = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->field_names_size()); + for (int i = 0, n = this->field_names_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_names(i)); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + { + unsigned int count = static_cast(this->attr_records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->attr_records(static_cast(i))); + } + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + { + unsigned int count = static_cast(this->result_values_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->result_values(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->entity_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntity::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntity) + GOOGLE_DCHECK_NE(&from, this); + const HEntity* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntity) + MergeFrom(*source); + } +} + +void HEntity::MergeFrom(const HEntity& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntity) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + field_names_.MergeFrom(from.field_names_); + attr_records_.MergeFrom(from.attr_records_); + result_values_.MergeFrom(from.result_values_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.entity_id() != 0) { + set_entity_id(from.entity_id()); + } +} + +void HEntity::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntity::CopyFrom(const HEntity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntity::IsInitialized() const { + return true; +} + +void HEntity::InternalSwap(HEntity* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + field_names_.InternalSwap(CastToBase(&other->field_names_)); + CastToBase(&attr_records_)->InternalSwap(CastToBase(&other->attr_records_)); + CastToBase(&result_values_)->InternalSwap(CastToBase(&other->result_values_)); + swap(status_, other->status_); + swap(entity_id_, other->entity_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntity::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HQueryResult::InitAsDefaultInstance() { + ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HQueryResult::_Internal { + public: + static const ::milvus::grpc::Status& status(const HQueryResult* msg); +}; + +const ::milvus::grpc::Status& +HQueryResult::_Internal::status(const HQueryResult* msg) { + return *msg->status_; +} +void HQueryResult::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HQueryResult::HQueryResult() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HQueryResult) +} +HQueryResult::HQueryResult(const HQueryResult& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entities_(from.entities_), + score_(from.score_), + distance_(from.distance_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + row_num_ = from.row_num_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HQueryResult) +} + +void HQueryResult::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HQueryResult_milvus_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&row_num_) - + reinterpret_cast(&status_)) + sizeof(row_num_)); +} + +HQueryResult::~HQueryResult() { + // @@protoc_insertion_point(destructor:milvus.grpc.HQueryResult) + SharedDtor(); +} + +void HQueryResult::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HQueryResult::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HQueryResult& HQueryResult::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HQueryResult_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HQueryResult::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entities_.Clear(); + score_.Clear(); + distance_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + row_num_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HQueryResult::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.HEntity entities = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_entities(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // int64 row_num = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + row_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated float score = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_score(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) { + add_score(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float distance = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_distance(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45) { + add_distance(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } 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 HQueryResult::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.HQueryResult) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.HEntity entities = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_entities())); + } else { + goto handle_unusual; + } + break; + } + + // int64 row_num = 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>( + input, &row_num_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float score = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_score()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 34u, input, this->mutable_score()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float distance = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_distance()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 42u, input, this->mutable_distance()))); + } 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.HQueryResult) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HQueryResult) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HQueryResult::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.grpc.HEntity entities = 2; + for (unsigned int i = 0, + n = static_cast(this->entities_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->entities(static_cast(i)), + output); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->row_num(), output); + } + + // repeated float score = 4; + if (this->score_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_score_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->score().data(), this->score_size(), output); + } + + // repeated float distance = 5; + if (this->distance_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(5, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_distance_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->distance().data(), this->distance_size(), 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.HQueryResult) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HQueryResult::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.grpc.HEntity entities = 2; + for (unsigned int i = 0, + n = static_cast(this->entities_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->entities(static_cast(i)), target); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->row_num(), target); + } + + // repeated float score = 4; + if (this->score_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _score_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->score_, target); + } + + // repeated float distance = 5; + if (this->distance_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 5, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _distance_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->distance_, 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.HQueryResult) + return target; +} + +size_t HQueryResult::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HQueryResult) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.HEntity entities = 2; + { + unsigned int count = static_cast(this->entities_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->entities(static_cast(i))); + } + } + + // repeated float score = 4; + { + unsigned int count = static_cast(this->score_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _score_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float distance = 5; + { + unsigned int count = static_cast(this->distance_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _distance_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->row_num()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HQueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HQueryResult) + GOOGLE_DCHECK_NE(&from, this); + const HQueryResult* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HQueryResult) + MergeFrom(*source); + } +} + +void HQueryResult::MergeFrom(const HQueryResult& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HQueryResult) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entities_.MergeFrom(from.entities_); + score_.MergeFrom(from.score_); + distance_.MergeFrom(from.distance_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.row_num() != 0) { + set_row_num(from.row_num()); + } +} + +void HQueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HQueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HQueryResult::CopyFrom(const HQueryResult& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HQueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HQueryResult::IsInitialized() const { + return true; +} + +void HQueryResult::InternalSwap(HQueryResult* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&entities_)->InternalSwap(CastToBase(&other->entities_)); + score_.InternalSwap(&other->score_); + distance_.InternalSwap(&other->distance_); + swap(status_, other->status_); + swap(row_num_, other->row_num_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HQueryResult::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HInsertParam::InitAsDefaultInstance() { + ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entities_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::HEntity::internal_default_instance()); +} +class HInsertParam::_Internal { + public: + static const ::milvus::grpc::HEntity& entities(const HInsertParam* msg); +}; + +const ::milvus::grpc::HEntity& +HInsertParam::_Internal::entities(const HInsertParam* msg) { + return *msg->entities_; +} +HInsertParam::HInsertParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HInsertParam) +} +HInsertParam::HInsertParam(const HInsertParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entity_id_array_(from.entity_id_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_entities()) { + entities_ = new ::milvus::grpc::HEntity(*from.entities_); + } else { + entities_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HInsertParam) +} + +void HInsertParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HInsertParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + entities_ = nullptr; +} + +HInsertParam::~HInsertParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HInsertParam) + SharedDtor(); +} + +void HInsertParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete entities_; +} + +void HInsertParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HInsertParam& HInsertParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HInsertParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HInsertParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entity_id_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HInsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HInsertParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "milvus.grpc.HInsertParam.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.HEntity entities = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_entities(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 HInsertParam::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.HInsertParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HInsertParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HInsertParam.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.HEntity entities = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_entities())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 34u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HInsertParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HInsertParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HInsertParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->partition_tag(), output); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::entities(this), output); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(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.HInsertParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HInsertParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->partition_tag(), target); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::entities(this), target); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(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.HInsertParam) + return target; +} + +size_t HInsertParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HInsertParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 entity_id_array = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *entities_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HInsertParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HInsertParam) + GOOGLE_DCHECK_NE(&from, this); + const HInsertParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HInsertParam) + MergeFrom(*source); + } +} + +void HInsertParam::MergeFrom(const HInsertParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HInsertParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entity_id_array_.MergeFrom(from.entity_id_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_entities()) { + mutable_entities()->::milvus::grpc::HEntity::MergeFrom(from.entities()); + } +} + +void HInsertParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HInsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HInsertParam::CopyFrom(const HInsertParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HInsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HInsertParam::IsInitialized() const { + return true; +} + +void HInsertParam::InternalSwap(HInsertParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_array_.InternalSwap(&other->entity_id_array_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(entities_, other->entities_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HInsertParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntityIdentity::InitAsDefaultInstance() { +} +class HEntityIdentity::_Internal { + public: +}; + +HEntityIdentity::HEntityIdentity() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntityIdentity) +} +HEntityIdentity::HEntityIdentity(const HEntityIdentity& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntityIdentity) +} + +void HEntityIdentity::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntityIdentity_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + id_ = PROTOBUF_LONGLONG(0); +} + +HEntityIdentity::~HEntityIdentity() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntityIdentity) + SharedDtor(); +} + +void HEntityIdentity::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HEntityIdentity::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntityIdentity& HEntityIdentity::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntityIdentity_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntityIdentity::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntityIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HEntityIdentity.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + 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 HEntityIdentity::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.HEntityIdentity) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HEntityIdentity.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // int64 id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &id_))); + } 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.HEntityIdentity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntityIdentity) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntityIdentity::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntityIdentity.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // int64 id = 2; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->id(), 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.HEntityIdentity) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntityIdentity::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntityIdentity.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // int64 id = 2; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->id(), 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.HEntityIdentity) + return target; +} + +size_t HEntityIdentity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntityIdentity) + 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 collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // int64 id = 2; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntityIdentity::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntityIdentity) + GOOGLE_DCHECK_NE(&from, this); + const HEntityIdentity* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntityIdentity) + MergeFrom(*source); + } +} + +void HEntityIdentity::MergeFrom(const HEntityIdentity& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntityIdentity) + 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.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.id() != 0) { + set_id(from.id()); + } +} + +void HEntityIdentity::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntityIdentity::CopyFrom(const HEntityIdentity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntityIdentity::IsInitialized() const { + return true; +} + +void HEntityIdentity::InternalSwap(HEntityIdentity* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntityIdentity::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntityIDs::InitAsDefaultInstance() { + ::milvus::grpc::_HEntityIDs_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HEntityIDs::_Internal { + public: + static const ::milvus::grpc::Status& status(const HEntityIDs* msg); +}; + +const ::milvus::grpc::Status& +HEntityIDs::_Internal::status(const HEntityIDs* msg) { + return *msg->status_; +} +void HEntityIDs::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HEntityIDs::HEntityIDs() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntityIDs) +} +HEntityIDs::HEntityIDs(const HEntityIDs& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entity_id_array_(from.entity_id_array_) { + _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.HEntityIDs) +} + +void HEntityIDs::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntityIDs_milvus_2eproto.base); + status_ = nullptr; +} + +HEntityIDs::~HEntityIDs() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntityIDs) + SharedDtor(); +} + +void HEntityIDs::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HEntityIDs::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntityIDs& HEntityIDs::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntityIDs_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntityIDs::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entity_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntityIDs::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + 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 HEntityIDs::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.HEntityIDs) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HEntityIDs) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntityIDs) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntityIDs::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HEntityIDs) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntityIDs::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, 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.HEntityIDs) + return target; +} + +size_t HEntityIDs::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntityIDs) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 entity_id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntityIDs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntityIDs) + GOOGLE_DCHECK_NE(&from, this); + const HEntityIDs* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntityIDs) + MergeFrom(*source); + } +} + +void HEntityIDs::MergeFrom(const HEntityIDs& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntityIDs) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entity_id_array_.MergeFrom(from.entity_id_array_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void HEntityIDs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntityIDs) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntityIDs::CopyFrom(const HEntityIDs& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntityIDs) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntityIDs::IsInitialized() const { + return true; +} + +void HEntityIDs::InternalSwap(HEntityIDs* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_array_.InternalSwap(&other->entity_id_array_); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntityIDs::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HGetEntityIDsParam::InitAsDefaultInstance() { +} +class HGetEntityIDsParam::_Internal { + public: +}; + +HGetEntityIDsParam::HGetEntityIDsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HGetEntityIDsParam) +} +HGetEntityIDsParam::HGetEntityIDsParam(const HGetEntityIDsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.segment_name().empty()) { + segment_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.segment_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HGetEntityIDsParam) +} + +void HGetEntityIDsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HGetEntityIDsParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HGetEntityIDsParam::~HGetEntityIDsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HGetEntityIDsParam) + SharedDtor(); +} + +void HGetEntityIDsParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HGetEntityIDsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HGetEntityIDsParam& HGetEntityIDsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HGetEntityIDsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HGetEntityIDsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HGetEntityIDsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HGetEntityIDsParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string segment_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_segment_name(), ptr, ctx, "milvus.grpc.HGetEntityIDsParam.segment_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 HGetEntityIDsParam::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.HGetEntityIDsParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HGetEntityIDsParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string segment_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_segment_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HGetEntityIDsParam.segment_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.HGetEntityIDsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HGetEntityIDsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HGetEntityIDsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.segment_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->segment_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.HGetEntityIDsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HGetEntityIDsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.segment_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->segment_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.HGetEntityIDsParam) + return target; +} + +size_t HGetEntityIDsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HGetEntityIDsParam) + 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 collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HGetEntityIDsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HGetEntityIDsParam) + GOOGLE_DCHECK_NE(&from, this); + const HGetEntityIDsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HGetEntityIDsParam) + MergeFrom(*source); + } +} + +void HGetEntityIDsParam::MergeFrom(const HGetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HGetEntityIDsParam) + 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.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.segment_name().size() > 0) { + + segment_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.segment_name_); + } +} + +void HGetEntityIDsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HGetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HGetEntityIDsParam::CopyFrom(const HGetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HGetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HGetEntityIDsParam::IsInitialized() const { + return true; +} + +void HGetEntityIDsParam::InternalSwap(HGetEntityIDsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + segment_name_.Swap(&other->segment_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HGetEntityIDsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HDeleteByIDParam::InitAsDefaultInstance() { +} +class HDeleteByIDParam::_Internal { + public: +}; + +HDeleteByIDParam::HDeleteByIDParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HDeleteByIDParam) +} +HDeleteByIDParam::HDeleteByIDParam(const HDeleteByIDParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + id_array_(from.id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HDeleteByIDParam) +} + +void HDeleteByIDParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HDeleteByIDParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HDeleteByIDParam::~HDeleteByIDParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HDeleteByIDParam) + SharedDtor(); +} + +void HDeleteByIDParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HDeleteByIDParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HDeleteByIDParam& HDeleteByIDParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HDeleteByIDParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HDeleteByIDParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_array_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HDeleteByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HDeleteByIDParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + 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 HDeleteByIDParam::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.HDeleteByIDParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HDeleteByIDParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HDeleteByIDParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HDeleteByIDParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HDeleteByIDParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HDeleteByIDParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HDeleteByIDParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HDeleteByIDParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HDeleteByIDParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_array_, 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.HDeleteByIDParam) + return target; +} + +size_t HDeleteByIDParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HDeleteByIDParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HDeleteByIDParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HDeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + const HDeleteByIDParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HDeleteByIDParam) + MergeFrom(*source); + } +} + +void HDeleteByIDParam::MergeFrom(const HDeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HDeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + id_array_.MergeFrom(from.id_array_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void HDeleteByIDParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HDeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HDeleteByIDParam::CopyFrom(const HDeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HDeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HDeleteByIDParam::IsInitialized() const { + return true; +} + +void HDeleteByIDParam::InternalSwap(HDeleteByIDParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + id_array_.InternalSwap(&other->id_array_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HDeleteByIDParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HIndexParam::InitAsDefaultInstance() { + ::milvus::grpc::_HIndexParam_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HIndexParam::_Internal { + public: + static const ::milvus::grpc::Status& status(const HIndexParam* msg); +}; + +const ::milvus::grpc::Status& +HIndexParam::_Internal::status(const HIndexParam* msg) { + return *msg->status_; +} +void HIndexParam::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HIndexParam::HIndexParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HIndexParam) +} +HIndexParam::HIndexParam(const HIndexParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + index_type_ = from.index_type_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HIndexParam) +} + +void HIndexParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HIndexParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&index_type_) - + reinterpret_cast(&status_)) + sizeof(index_type_)); +} + +HIndexParam::~HIndexParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HIndexParam) + SharedDtor(); +} + +void HIndexParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void HIndexParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HIndexParam& HIndexParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HIndexParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HIndexParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + index_type_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HIndexParam::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HIndexParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 index_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + index_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 HIndexParam::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.HIndexParam) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HIndexParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // int32 index_type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &index_type_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HIndexParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HIndexParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HIndexParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HIndexParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->collection_name(), output); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(3, this->index_type(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.HIndexParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HIndexParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HIndexParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->collection_name(), target); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->index_type(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.HIndexParam) + return target; +} + +size_t HIndexParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HIndexParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->index_type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HIndexParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HIndexParam) + GOOGLE_DCHECK_NE(&from, this); + const HIndexParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HIndexParam) + MergeFrom(*source); + } +} + +void HIndexParam::MergeFrom(const HIndexParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HIndexParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.index_type() != 0) { + set_index_type(from.index_type()); + } +} + +void HIndexParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HIndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HIndexParam::CopyFrom(const HIndexParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HIndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HIndexParam::IsInitialized() const { + return true; +} + +void HIndexParam::InternalSwap(HIndexParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); + swap(index_type_, other->index_type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HIndexParam::GetMetadata() const { + return GetMetadataStatic(); +} + + // @@protoc_insertion_point(namespace_scope) } // namespace grpc } // namespace milvus @@ -10460,6 +20829,78 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorData* Arena::CreateMaybeMessa template<> PROTOBUF_NOINLINE ::milvus::grpc::GetVectorIDsParam* Arena::CreateMaybeMessage< ::milvus::grpc::GetVectorIDsParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::GetVectorIDsParam >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldType* Arena::CreateMaybeMessage< ::milvus::grpc::FieldType >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldType >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::FieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldValue >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::FieldValue >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldValue >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Mapping* Arena::CreateMaybeMessage< ::milvus::grpc::Mapping >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Mapping >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::MappingList* Arena::CreateMaybeMessage< ::milvus::grpc::MappingList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::MappingList >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage< ::milvus::grpc::TermQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::TermQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage< ::milvus::grpc::CompareExpr >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CompareExpr >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage< ::milvus::grpc::RangeQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::RangeQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage< ::milvus::grpc::VectorQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage< ::milvus::grpc::BooleanQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::BooleanQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage< ::milvus::grpc::GeneralQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::GeneralQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HSearchParam* Arena::CreateMaybeMessage< ::milvus::grpc::HSearchParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HSearchParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HSearchInSegmentsParam* Arena::CreateMaybeMessage< ::milvus::grpc::HSearchInSegmentsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HSearchInSegmentsParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::AttrRecord* Arena::CreateMaybeMessage< ::milvus::grpc::AttrRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::AttrRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntity* Arena::CreateMaybeMessage< ::milvus::grpc::HEntity >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntity >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HQueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::HQueryResult >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HQueryResult >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HInsertParam* Arena::CreateMaybeMessage< ::milvus::grpc::HInsertParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HInsertParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntityIdentity* Arena::CreateMaybeMessage< ::milvus::grpc::HEntityIdentity >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntityIdentity >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntityIDs* Arena::CreateMaybeMessage< ::milvus::grpc::HEntityIDs >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntityIDs >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HGetEntityIDsParam* Arena::CreateMaybeMessage< ::milvus::grpc::HGetEntityIDsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HGetEntityIDsParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HDeleteByIDParam* Arena::CreateMaybeMessage< ::milvus::grpc::HDeleteByIDParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HDeleteByIDParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HIndexParam* Arena::CreateMaybeMessage< ::milvus::grpc::HIndexParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HIndexParam >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/core/src/grpc/gen-milvus/milvus.pb.h b/core/src/grpc/gen-milvus/milvus.pb.h index 88113f73f7..0bd2527120 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.h +++ b/core/src/grpc/gen-milvus/milvus.pb.h @@ -31,6 +31,7 @@ #include #include // IWYU pragma: export #include // IWYU pragma: export +#include #include #include "status.pb.h" // @@protoc_insertion_point(includes) @@ -48,7 +49,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[50] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -57,9 +58,15 @@ struct TableStruct_milvus_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto; namespace milvus { namespace grpc { +class AttrRecord; +class AttrRecordDefaultTypeInternal; +extern AttrRecordDefaultTypeInternal _AttrRecord_default_instance_; class BoolReply; class BoolReplyDefaultTypeInternal; extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_; +class BooleanQuery; +class BooleanQueryDefaultTypeInternal; +extern BooleanQueryDefaultTypeInternal _BooleanQuery_default_instance_; class CollectionInfo; class CollectionInfoDefaultTypeInternal; extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_; @@ -78,15 +85,60 @@ extern CollectionSchemaDefaultTypeInternal _CollectionSchema_default_instance_; class Command; class CommandDefaultTypeInternal; extern CommandDefaultTypeInternal _Command_default_instance_; +class CompareExpr; +class CompareExprDefaultTypeInternal; +extern CompareExprDefaultTypeInternal _CompareExpr_default_instance_; class DeleteByIDParam; class DeleteByIDParamDefaultTypeInternal; extern DeleteByIDParamDefaultTypeInternal _DeleteByIDParam_default_instance_; +class FieldParam; +class FieldParamDefaultTypeInternal; +extern FieldParamDefaultTypeInternal _FieldParam_default_instance_; +class FieldType; +class FieldTypeDefaultTypeInternal; +extern FieldTypeDefaultTypeInternal _FieldType_default_instance_; +class FieldValue; +class FieldValueDefaultTypeInternal; +extern FieldValueDefaultTypeInternal _FieldValue_default_instance_; class FlushParam; class FlushParamDefaultTypeInternal; extern FlushParamDefaultTypeInternal _FlushParam_default_instance_; +class GeneralQuery; +class GeneralQueryDefaultTypeInternal; +extern GeneralQueryDefaultTypeInternal _GeneralQuery_default_instance_; class GetVectorIDsParam; class GetVectorIDsParamDefaultTypeInternal; extern GetVectorIDsParamDefaultTypeInternal _GetVectorIDsParam_default_instance_; +class HDeleteByIDParam; +class HDeleteByIDParamDefaultTypeInternal; +extern HDeleteByIDParamDefaultTypeInternal _HDeleteByIDParam_default_instance_; +class HEntity; +class HEntityDefaultTypeInternal; +extern HEntityDefaultTypeInternal _HEntity_default_instance_; +class HEntityIDs; +class HEntityIDsDefaultTypeInternal; +extern HEntityIDsDefaultTypeInternal _HEntityIDs_default_instance_; +class HEntityIdentity; +class HEntityIdentityDefaultTypeInternal; +extern HEntityIdentityDefaultTypeInternal _HEntityIdentity_default_instance_; +class HGetEntityIDsParam; +class HGetEntityIDsParamDefaultTypeInternal; +extern HGetEntityIDsParamDefaultTypeInternal _HGetEntityIDsParam_default_instance_; +class HIndexParam; +class HIndexParamDefaultTypeInternal; +extern HIndexParamDefaultTypeInternal _HIndexParam_default_instance_; +class HInsertParam; +class HInsertParamDefaultTypeInternal; +extern HInsertParamDefaultTypeInternal _HInsertParam_default_instance_; +class HQueryResult; +class HQueryResultDefaultTypeInternal; +extern HQueryResultDefaultTypeInternal _HQueryResult_default_instance_; +class HSearchInSegmentsParam; +class HSearchInSegmentsParamDefaultTypeInternal; +extern HSearchInSegmentsParamDefaultTypeInternal _HSearchInSegmentsParam_default_instance_; +class HSearchParam; +class HSearchParamDefaultTypeInternal; +extern HSearchParamDefaultTypeInternal _HSearchParam_default_instance_; class IndexParam; class IndexParamDefaultTypeInternal; extern IndexParamDefaultTypeInternal _IndexParam_default_instance_; @@ -96,6 +148,12 @@ extern InsertParamDefaultTypeInternal _InsertParam_default_instance_; class KeyValuePair; class KeyValuePairDefaultTypeInternal; extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_; +class Mapping; +class MappingDefaultTypeInternal; +extern MappingDefaultTypeInternal _Mapping_default_instance_; +class MappingList; +class MappingListDefaultTypeInternal; +extern MappingListDefaultTypeInternal _MappingList_default_instance_; class PartitionList; class PartitionListDefaultTypeInternal; extern PartitionListDefaultTypeInternal _PartitionList_default_instance_; @@ -105,6 +163,9 @@ extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_; class PartitionStat; class PartitionStatDefaultTypeInternal; extern PartitionStatDefaultTypeInternal _PartitionStat_default_instance_; +class RangeQuery; +class RangeQueryDefaultTypeInternal; +extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_; class RowRecord; class RowRecordDefaultTypeInternal; extern RowRecordDefaultTypeInternal _RowRecord_default_instance_; @@ -123,51 +184,177 @@ extern SegmentStatDefaultTypeInternal _SegmentStat_default_instance_; class StringReply; class StringReplyDefaultTypeInternal; extern StringReplyDefaultTypeInternal _StringReply_default_instance_; +class TermQuery; +class TermQueryDefaultTypeInternal; +extern TermQueryDefaultTypeInternal _TermQuery_default_instance_; class TopKQueryResult; class TopKQueryResultDefaultTypeInternal; extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; class VectorData; class VectorDataDefaultTypeInternal; extern VectorDataDefaultTypeInternal _VectorData_default_instance_; +class VectorFieldParam; +class VectorFieldParamDefaultTypeInternal; +extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_; +class VectorFieldValue; +class VectorFieldValueDefaultTypeInternal; +extern VectorFieldValueDefaultTypeInternal _VectorFieldValue_default_instance_; class VectorIdentity; class VectorIdentityDefaultTypeInternal; extern VectorIdentityDefaultTypeInternal _VectorIdentity_default_instance_; class VectorIds; class VectorIdsDefaultTypeInternal; extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; +class VectorQuery; +class VectorQueryDefaultTypeInternal; +extern VectorQueryDefaultTypeInternal _VectorQuery_default_instance_; } // namespace grpc } // namespace milvus PROTOBUF_NAMESPACE_OPEN +template<> ::milvus::grpc::AttrRecord* Arena::CreateMaybeMessage<::milvus::grpc::AttrRecord>(Arena*); template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*); +template<> ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage<::milvus::grpc::BooleanQuery>(Arena*); template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*); template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*); template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*); template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*); template<> ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage<::milvus::grpc::CollectionSchema>(Arena*); template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*); +template<> ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage<::milvus::grpc::CompareExpr>(Arena*); template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*); +template<> ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage<::milvus::grpc::FieldParam>(Arena*); +template<> ::milvus::grpc::FieldType* Arena::CreateMaybeMessage<::milvus::grpc::FieldType>(Arena*); +template<> ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage<::milvus::grpc::FieldValue>(Arena*); template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*); +template<> ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage<::milvus::grpc::GeneralQuery>(Arena*); template<> ::milvus::grpc::GetVectorIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::GetVectorIDsParam>(Arena*); +template<> ::milvus::grpc::HDeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::HDeleteByIDParam>(Arena*); +template<> ::milvus::grpc::HEntity* Arena::CreateMaybeMessage<::milvus::grpc::HEntity>(Arena*); +template<> ::milvus::grpc::HEntityIDs* Arena::CreateMaybeMessage<::milvus::grpc::HEntityIDs>(Arena*); +template<> ::milvus::grpc::HEntityIdentity* Arena::CreateMaybeMessage<::milvus::grpc::HEntityIdentity>(Arena*); +template<> ::milvus::grpc::HGetEntityIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::HGetEntityIDsParam>(Arena*); +template<> ::milvus::grpc::HIndexParam* Arena::CreateMaybeMessage<::milvus::grpc::HIndexParam>(Arena*); +template<> ::milvus::grpc::HInsertParam* Arena::CreateMaybeMessage<::milvus::grpc::HInsertParam>(Arena*); +template<> ::milvus::grpc::HQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::HQueryResult>(Arena*); +template<> ::milvus::grpc::HSearchInSegmentsParam* Arena::CreateMaybeMessage<::milvus::grpc::HSearchInSegmentsParam>(Arena*); +template<> ::milvus::grpc::HSearchParam* Arena::CreateMaybeMessage<::milvus::grpc::HSearchParam>(Arena*); template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*); template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*); template<> ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage<::milvus::grpc::KeyValuePair>(Arena*); +template<> ::milvus::grpc::Mapping* Arena::CreateMaybeMessage<::milvus::grpc::Mapping>(Arena*); +template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc::MappingList>(Arena*); template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*); template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*); template<> ::milvus::grpc::PartitionStat* Arena::CreateMaybeMessage<::milvus::grpc::PartitionStat>(Arena*); +template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*); template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*); template<> ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchByIDParam>(Arena*); template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*); template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*); template<> ::milvus::grpc::SegmentStat* Arena::CreateMaybeMessage<::milvus::grpc::SegmentStat>(Arena*); template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*); +template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorData* Arena::CreateMaybeMessage<::milvus::grpc::VectorData>(Arena*); +template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*); +template<> ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldValue>(Arena*); template<> ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage<::milvus::grpc::VectorIdentity>(Arena*); template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*); +template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace milvus { namespace grpc { +enum DataType : int { + NULL_ = 0, + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + STRING = 20, + BOOL = 30, + FLOAT = 40, + DOUBLE = 41, + VECTOR = 100, + UNKNOWN = 9999, + DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DataType_IsValid(int value); +constexpr DataType DataType_MIN = NULL_; +constexpr DataType DataType_MAX = UNKNOWN; +constexpr int DataType_ARRAYSIZE = DataType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor(); +template +inline const std::string& DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DataType_descriptor(), enum_t_value); +} +inline bool DataType_Parse( + const std::string& name, DataType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DataType_descriptor(), name, value); +} +enum CompareOperator : int { + LT = 0, + LTE = 1, + EQ = 2, + GT = 3, + GTE = 4, + NE = 5, + CompareOperator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + CompareOperator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool CompareOperator_IsValid(int value); +constexpr CompareOperator CompareOperator_MIN = LT; +constexpr CompareOperator CompareOperator_MAX = NE; +constexpr int CompareOperator_ARRAYSIZE = CompareOperator_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor(); +template +inline const std::string& CompareOperator_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CompareOperator_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + CompareOperator_descriptor(), enum_t_value); +} +inline bool CompareOperator_Parse( + const std::string& name, CompareOperator* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + CompareOperator_descriptor(), name, value); +} +enum Occur : int { + INVALID = 0, + MUST = 1, + SHOULD = 2, + MUST_NOT = 3, + Occur_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Occur_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Occur_IsValid(int value); +constexpr Occur Occur_MIN = INVALID; +constexpr Occur Occur_MAX = MUST_NOT; +constexpr int Occur_ARRAYSIZE = Occur_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor(); +template +inline const std::string& Occur_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Occur_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Occur_descriptor(), enum_t_value); +} +inline bool Occur_Parse( + const std::string& name, Occur* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Occur_descriptor(), name, value); +} // =================================================================== class KeyValuePair : @@ -4215,6 +4402,3932 @@ class GetVectorIDsParam : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; +// ------------------------------------------------------------------- + +class VectorFieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldParam) */ { + public: + VectorFieldParam(); + virtual ~VectorFieldParam(); + + VectorFieldParam(const VectorFieldParam& from); + VectorFieldParam(VectorFieldParam&& from) noexcept + : VectorFieldParam() { + *this = ::std::move(from); + } + + inline VectorFieldParam& operator=(const VectorFieldParam& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldParam& operator=(VectorFieldParam&& 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 VectorFieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldParam* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(VectorFieldParam& a, VectorFieldParam& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldParam& from); + void MergeFrom(const VectorFieldParam& 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(VectorFieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldParam"; + } + 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 { + kDimensionFieldNumber = 1, + }; + // int64 dimension = 1; + void clear_dimension(); + ::PROTOBUF_NAMESPACE_ID::int64 dimension() const; + void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 dimension_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldType : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldType) */ { + public: + FieldType(); + virtual ~FieldType(); + + FieldType(const FieldType& from); + FieldType(FieldType&& from) noexcept + : FieldType() { + *this = ::std::move(from); + } + + inline FieldType& operator=(const FieldType& from) { + CopyFrom(from); + return *this; + } + inline FieldType& operator=(FieldType&& 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 FieldType& default_instance(); + + enum ValueCase { + kDataType = 1, + kVectorParam = 2, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldType* internal_default_instance() { + return reinterpret_cast( + &_FieldType_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(FieldType& a, FieldType& b) { + a.Swap(&b); + } + inline void Swap(FieldType* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldType* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldType& from); + void MergeFrom(const FieldType& 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(FieldType* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldType"; + } + 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 { + kDataTypeFieldNumber = 1, + kVectorParamFieldNumber = 2, + }; + // .milvus.grpc.DataType data_type = 1; + private: + bool has_data_type() const; + public: + void clear_data_type(); + ::milvus::grpc::DataType data_type() const; + void set_data_type(::milvus::grpc::DataType value); + + // .milvus.grpc.VectorFieldParam vector_param = 2; + bool has_vector_param() const; + void clear_vector_param(); + const ::milvus::grpc::VectorFieldParam& vector_param() const; + ::milvus::grpc::VectorFieldParam* release_vector_param(); + ::milvus::grpc::VectorFieldParam* mutable_vector_param(); + void set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldType) + private: + class _Internal; + void set_has_data_type(); + void set_has_vector_param(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + int data_type_; + ::milvus::grpc::VectorFieldParam* vector_param_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldParam) */ { + public: + FieldParam(); + virtual ~FieldParam(); + + FieldParam(const FieldParam& from); + FieldParam(FieldParam&& from) noexcept + : FieldParam() { + *this = ::std::move(from); + } + + inline FieldParam& operator=(const FieldParam& from) { + CopyFrom(from); + return *this; + } + inline FieldParam& operator=(FieldParam&& 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 FieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldParam* internal_default_instance() { + return reinterpret_cast( + &_FieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(FieldParam& a, FieldParam& b) { + a.Swap(&b); + } + inline void Swap(FieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldParam& from); + void MergeFrom(const FieldParam& 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(FieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldParam"; + } + 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 { + kExtraParamsFieldNumber = 4, + kNameFieldNumber = 2, + kTypeFieldNumber = 3, + kIdFieldNumber = 1, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string name = 2; + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + + // .milvus.grpc.FieldType type = 3; + bool has_type() const; + void clear_type(); + const ::milvus::grpc::FieldType& type() const; + ::milvus::grpc::FieldType* release_type(); + ::milvus::grpc::FieldType* mutable_type(); + void set_allocated_type(::milvus::grpc::FieldType* type); + + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::milvus::grpc::FieldType* type_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorFieldValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldValue) */ { + public: + VectorFieldValue(); + virtual ~VectorFieldValue(); + + VectorFieldValue(const VectorFieldValue& from); + VectorFieldValue(VectorFieldValue&& from) noexcept + : VectorFieldValue() { + *this = ::std::move(from); + } + + inline VectorFieldValue& operator=(const VectorFieldValue& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldValue& operator=(VectorFieldValue&& 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 VectorFieldValue& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldValue* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(VectorFieldValue& a, VectorFieldValue& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldValue& from); + void MergeFrom(const VectorFieldValue& 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(VectorFieldValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldValue"; + } + 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 { + kValueFieldNumber = 1, + }; + // repeated .milvus.grpc.RowRecord value = 1; + int value_size() const; + void clear_value(); + ::milvus::grpc::RowRecord* mutable_value(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* + mutable_value(); + const ::milvus::grpc::RowRecord& value(int index) const; + ::milvus::grpc::RowRecord* add_value(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& + value() const; + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldValue) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldValue) */ { + public: + FieldValue(); + virtual ~FieldValue(); + + FieldValue(const FieldValue& from); + FieldValue(FieldValue&& from) noexcept + : FieldValue() { + *this = ::std::move(from); + } + + inline FieldValue& operator=(const FieldValue& from) { + CopyFrom(from); + return *this; + } + inline FieldValue& operator=(FieldValue&& 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 FieldValue& default_instance(); + + enum ValueCase { + kInt32Value = 1, + kInt64Value = 2, + kFloatValue = 3, + kDoubleValue = 4, + kStringValue = 5, + kBoolValue = 6, + kVectorValue = 7, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldValue* internal_default_instance() { + return reinterpret_cast( + &_FieldValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(FieldValue& a, FieldValue& b) { + a.Swap(&b); + } + inline void Swap(FieldValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldValue& from); + void MergeFrom(const FieldValue& 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(FieldValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldValue"; + } + 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 { + kInt32ValueFieldNumber = 1, + kInt64ValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kDoubleValueFieldNumber = 4, + kStringValueFieldNumber = 5, + kBoolValueFieldNumber = 6, + kVectorValueFieldNumber = 7, + }; + // int32 int32_value = 1; + private: + bool has_int32_value() const; + public: + void clear_int32_value(); + ::PROTOBUF_NAMESPACE_ID::int32 int32_value() const; + void set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value); + + // int64 int64_value = 2; + private: + bool has_int64_value() const; + public: + void clear_int64_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int64_value() const; + void set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float float_value = 3; + private: + bool has_float_value() const; + public: + void clear_float_value(); + float float_value() const; + void set_float_value(float value); + + // double double_value = 4; + private: + bool has_double_value() const; + public: + void clear_double_value(); + double double_value() const; + void set_double_value(double value); + + // string string_value = 5; + private: + bool has_string_value() const; + public: + void clear_string_value(); + const std::string& string_value() const; + void set_string_value(const std::string& value); + void set_string_value(std::string&& value); + void set_string_value(const char* value); + void set_string_value(const char* value, size_t size); + std::string* mutable_string_value(); + std::string* release_string_value(); + void set_allocated_string_value(std::string* string_value); + + // bool bool_value = 6; + private: + bool has_bool_value() const; + public: + void clear_bool_value(); + bool bool_value() const; + void set_bool_value(bool value); + + // .milvus.grpc.VectorFieldValue vector_value = 7; + bool has_vector_value() const; + void clear_vector_value(); + const ::milvus::grpc::VectorFieldValue& vector_value() const; + ::milvus::grpc::VectorFieldValue* release_vector_value(); + ::milvus::grpc::VectorFieldValue* mutable_vector_value(); + void set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldValue) + private: + class _Internal; + void set_has_int32_value(); + void set_has_int64_value(); + void set_has_float_value(); + void set_has_double_value(); + void set_has_string_value(); + void set_has_bool_value(); + void set_has_vector_value(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_; + bool bool_value_; + ::milvus::grpc::VectorFieldValue* vector_value_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class Mapping : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Mapping) */ { + public: + Mapping(); + virtual ~Mapping(); + + Mapping(const Mapping& from); + Mapping(Mapping&& from) noexcept + : Mapping() { + *this = ::std::move(from); + } + + inline Mapping& operator=(const Mapping& from) { + CopyFrom(from); + return *this; + } + inline Mapping& operator=(Mapping&& 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 Mapping& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Mapping* internal_default_instance() { + return reinterpret_cast( + &_Mapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(Mapping& a, Mapping& b) { + a.Swap(&b); + } + inline void Swap(Mapping* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Mapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Mapping& from); + void MergeFrom(const Mapping& 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(Mapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Mapping"; + } + 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 { + kFieldsFieldNumber = 4, + kCollectionNameFieldNumber = 3, + kStatusFieldNumber = 1, + kCollectionIdFieldNumber = 2, + }; + // repeated .milvus.grpc.FieldParam fields = 4; + int fields_size() const; + void clear_fields(); + ::milvus::grpc::FieldParam* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >* + mutable_fields(); + const ::milvus::grpc::FieldParam& fields(int index) const; + ::milvus::grpc::FieldParam* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >& + fields() const; + + // string collection_name = 3; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .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); + + // uint64 collection_id = 2; + void clear_collection_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id() const; + void set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Mapping) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam > fields_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class MappingList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.MappingList) */ { + public: + MappingList(); + virtual ~MappingList(); + + MappingList(const MappingList& from); + MappingList(MappingList&& from) noexcept + : MappingList() { + *this = ::std::move(from); + } + + inline MappingList& operator=(const MappingList& from) { + CopyFrom(from); + return *this; + } + inline MappingList& operator=(MappingList&& 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 MappingList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const MappingList* internal_default_instance() { + return reinterpret_cast( + &_MappingList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(MappingList& a, MappingList& b) { + a.Swap(&b); + } + inline void Swap(MappingList* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MappingList* New() const final { + return CreateMaybeMessage(nullptr); + } + + MappingList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MappingList& from); + void MergeFrom(const MappingList& 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(MappingList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.MappingList"; + } + 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 { + kMappingListFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated .milvus.grpc.Mapping mapping_list = 2; + int mapping_list_size() const; + void clear_mapping_list(); + ::milvus::grpc::Mapping* mutable_mapping_list(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* + mutable_mapping_list(); + const ::milvus::grpc::Mapping& mapping_list(int index) const; + ::milvus::grpc::Mapping* add_mapping_list(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& + mapping_list() const; + + // .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); + + // @@protoc_insertion_point(class_scope:milvus.grpc.MappingList) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping > mapping_list_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class TermQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TermQuery) */ { + public: + TermQuery(); + virtual ~TermQuery(); + + TermQuery(const TermQuery& from); + TermQuery(TermQuery&& from) noexcept + : TermQuery() { + *this = ::std::move(from); + } + + inline TermQuery& operator=(const TermQuery& from) { + CopyFrom(from); + return *this; + } + inline TermQuery& operator=(TermQuery&& 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 TermQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TermQuery* internal_default_instance() { + return reinterpret_cast( + &_TermQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(TermQuery& a, TermQuery& b) { + a.Swap(&b); + } + inline void Swap(TermQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TermQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + TermQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const TermQuery& from); + void MergeFrom(const TermQuery& 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(TermQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.TermQuery"; + } + 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 { + kValuesFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kFieldNameFieldNumber = 1, + kBoostFieldNumber = 3, + }; + // repeated string values = 2; + int values_size() const; + void clear_values(); + const std::string& values(int index) const; + std::string* mutable_values(int index); + void set_values(int index, const std::string& value); + void set_values(int index, std::string&& value); + void set_values(int index, const char* value); + void set_values(int index, const char* value, size_t size); + std::string* add_values(); + void add_values(const std::string& value); + void add_values(std::string&& value); + void add_values(const char* value); + void add_values(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_values(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // float boost = 3; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.TermQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField values_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class CompareExpr : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompareExpr) */ { + public: + CompareExpr(); + virtual ~CompareExpr(); + + CompareExpr(const CompareExpr& from); + CompareExpr(CompareExpr&& from) noexcept + : CompareExpr() { + *this = ::std::move(from); + } + + inline CompareExpr& operator=(const CompareExpr& from) { + CopyFrom(from); + return *this; + } + inline CompareExpr& operator=(CompareExpr&& 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 CompareExpr& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CompareExpr* internal_default_instance() { + return reinterpret_cast( + &_CompareExpr_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(CompareExpr& a, CompareExpr& b) { + a.Swap(&b); + } + inline void Swap(CompareExpr* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CompareExpr* New() const final { + return CreateMaybeMessage(nullptr); + } + + CompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CompareExpr& from); + void MergeFrom(const CompareExpr& 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(CompareExpr* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CompareExpr"; + } + 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 { + kOperandFieldNumber = 2, + kOperatorFieldNumber = 1, + }; + // string operand = 2; + void clear_operand(); + const std::string& operand() const; + void set_operand(const std::string& value); + void set_operand(std::string&& value); + void set_operand(const char* value); + void set_operand(const char* value, size_t size); + std::string* mutable_operand(); + std::string* release_operand(); + void set_allocated_operand(std::string* operand); + + // .milvus.grpc.CompareOperator operator = 1; + void clear_operator_(); + ::milvus::grpc::CompareOperator operator_() const; + void set_operator_(::milvus::grpc::CompareOperator value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CompareExpr) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand_; + int operator__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class RangeQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RangeQuery) */ { + public: + RangeQuery(); + virtual ~RangeQuery(); + + RangeQuery(const RangeQuery& from); + RangeQuery(RangeQuery&& from) noexcept + : RangeQuery() { + *this = ::std::move(from); + } + + inline RangeQuery& operator=(const RangeQuery& from) { + CopyFrom(from); + return *this; + } + inline RangeQuery& operator=(RangeQuery&& 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 RangeQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeQuery* internal_default_instance() { + return reinterpret_cast( + &_RangeQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(RangeQuery& a, RangeQuery& b) { + a.Swap(&b); + } + inline void Swap(RangeQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RangeQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + RangeQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RangeQuery& from); + void MergeFrom(const RangeQuery& 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(RangeQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.RangeQuery"; + } + 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 { + kOperandFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kFieldNameFieldNumber = 1, + kBoostFieldNumber = 3, + }; + // repeated .milvus.grpc.CompareExpr operand = 2; + int operand_size() const; + void clear_operand(); + ::milvus::grpc::CompareExpr* mutable_operand(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* + mutable_operand(); + const ::milvus::grpc::CompareExpr& operand(int index) const; + ::milvus::grpc::CompareExpr* add_operand(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& + operand() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // float boost = 3; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.RangeQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr > operand_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorQuery) */ { + public: + VectorQuery(); + virtual ~VectorQuery(); + + VectorQuery(const VectorQuery& from); + VectorQuery(VectorQuery&& from) noexcept + : VectorQuery() { + *this = ::std::move(from); + } + + inline VectorQuery& operator=(const VectorQuery& from) { + CopyFrom(from); + return *this; + } + inline VectorQuery& operator=(VectorQuery&& 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 VectorQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorQuery* internal_default_instance() { + return reinterpret_cast( + &_VectorQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(VectorQuery& a, VectorQuery& b) { + a.Swap(&b); + } + inline void Swap(VectorQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorQuery& from); + void MergeFrom(const VectorQuery& 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(VectorQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorQuery"; + } + 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 { + kRecordsFieldNumber = 3, + kExtraParamsFieldNumber = 5, + kFieldNameFieldNumber = 1, + kTopkFieldNumber = 4, + kQueryBoostFieldNumber = 2, + }; + // repeated .milvus.grpc.RowRecord records = 3; + int records_size() const; + void clear_records(); + ::milvus::grpc::RowRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* + mutable_records(); + const ::milvus::grpc::RowRecord& records(int index) const; + ::milvus::grpc::RowRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& + records() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // int64 topk = 4; + void clear_topk(); + ::PROTOBUF_NAMESPACE_ID::int64 topk() const; + void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float query_boost = 2; + void clear_query_boost(); + float query_boost() const; + void set_query_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::int64 topk_; + float query_boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class BooleanQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BooleanQuery) */ { + public: + BooleanQuery(); + virtual ~BooleanQuery(); + + BooleanQuery(const BooleanQuery& from); + BooleanQuery(BooleanQuery&& from) noexcept + : BooleanQuery() { + *this = ::std::move(from); + } + + inline BooleanQuery& operator=(const BooleanQuery& from) { + CopyFrom(from); + return *this; + } + inline BooleanQuery& operator=(BooleanQuery&& 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 BooleanQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BooleanQuery* internal_default_instance() { + return reinterpret_cast( + &_BooleanQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(BooleanQuery& a, BooleanQuery& b) { + a.Swap(&b); + } + inline void Swap(BooleanQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BooleanQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + BooleanQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BooleanQuery& from); + void MergeFrom(const BooleanQuery& 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(BooleanQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.BooleanQuery"; + } + 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 { + kGeneralQueryFieldNumber = 2, + kOccurFieldNumber = 1, + }; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + int general_query_size() const; + void clear_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* + mutable_general_query(); + const ::milvus::grpc::GeneralQuery& general_query(int index) const; + ::milvus::grpc::GeneralQuery* add_general_query(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& + general_query() const; + + // .milvus.grpc.Occur occur = 1; + void clear_occur(); + ::milvus::grpc::Occur occur() const; + void set_occur(::milvus::grpc::Occur value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.BooleanQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery > general_query_; + int occur_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class GeneralQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GeneralQuery) */ { + public: + GeneralQuery(); + virtual ~GeneralQuery(); + + GeneralQuery(const GeneralQuery& from); + GeneralQuery(GeneralQuery&& from) noexcept + : GeneralQuery() { + *this = ::std::move(from); + } + + inline GeneralQuery& operator=(const GeneralQuery& from) { + CopyFrom(from); + return *this; + } + inline GeneralQuery& operator=(GeneralQuery&& 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 GeneralQuery& default_instance(); + + enum QueryCase { + kBooleanQuery = 1, + kTermQuery = 2, + kRangeQuery = 3, + kVectorQuery = 4, + QUERY_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GeneralQuery* internal_default_instance() { + return reinterpret_cast( + &_GeneralQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(GeneralQuery& a, GeneralQuery& b) { + a.Swap(&b); + } + inline void Swap(GeneralQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GeneralQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + GeneralQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const GeneralQuery& from); + void MergeFrom(const GeneralQuery& 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(GeneralQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.GeneralQuery"; + } + 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 { + kBooleanQueryFieldNumber = 1, + kTermQueryFieldNumber = 2, + kRangeQueryFieldNumber = 3, + kVectorQueryFieldNumber = 4, + }; + // .milvus.grpc.BooleanQuery boolean_query = 1; + bool has_boolean_query() const; + void clear_boolean_query(); + const ::milvus::grpc::BooleanQuery& boolean_query() const; + ::milvus::grpc::BooleanQuery* release_boolean_query(); + ::milvus::grpc::BooleanQuery* mutable_boolean_query(); + void set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query); + + // .milvus.grpc.TermQuery term_query = 2; + bool has_term_query() const; + void clear_term_query(); + const ::milvus::grpc::TermQuery& term_query() const; + ::milvus::grpc::TermQuery* release_term_query(); + ::milvus::grpc::TermQuery* mutable_term_query(); + void set_allocated_term_query(::milvus::grpc::TermQuery* term_query); + + // .milvus.grpc.RangeQuery range_query = 3; + bool has_range_query() const; + void clear_range_query(); + const ::milvus::grpc::RangeQuery& range_query() const; + ::milvus::grpc::RangeQuery* release_range_query(); + ::milvus::grpc::RangeQuery* mutable_range_query(); + void set_allocated_range_query(::milvus::grpc::RangeQuery* range_query); + + // .milvus.grpc.VectorQuery vector_query = 4; + bool has_vector_query() const; + void clear_vector_query(); + const ::milvus::grpc::VectorQuery& vector_query() const; + ::milvus::grpc::VectorQuery* release_vector_query(); + ::milvus::grpc::VectorQuery* mutable_vector_query(); + void set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query); + + void clear_query(); + QueryCase query_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.GeneralQuery) + private: + class _Internal; + void set_has_boolean_query(); + void set_has_term_query(); + void set_has_range_query(); + void set_has_vector_query(); + + inline bool has_query() const; + inline void clear_has_query(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union QueryUnion { + QueryUnion() {} + ::milvus::grpc::BooleanQuery* boolean_query_; + ::milvus::grpc::TermQuery* term_query_; + ::milvus::grpc::RangeQuery* range_query_; + ::milvus::grpc::VectorQuery* vector_query_; + } query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HSearchParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HSearchParam) */ { + public: + HSearchParam(); + virtual ~HSearchParam(); + + HSearchParam(const HSearchParam& from); + HSearchParam(HSearchParam&& from) noexcept + : HSearchParam() { + *this = ::std::move(from); + } + + inline HSearchParam& operator=(const HSearchParam& from) { + CopyFrom(from); + return *this; + } + inline HSearchParam& operator=(HSearchParam&& 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 HSearchParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HSearchParam* internal_default_instance() { + return reinterpret_cast( + &_HSearchParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(HSearchParam& a, HSearchParam& b) { + a.Swap(&b); + } + inline void Swap(HSearchParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HSearchParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HSearchParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HSearchParam& from); + void MergeFrom(const HSearchParam& 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(HSearchParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HSearchParam"; + } + 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 { + kPartitionTagArrayFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 1, + kGeneralQueryFieldNumber = 3, + }; + // repeated string partition_tag_array = 2; + int partition_tag_array_size() const; + void clear_partition_tag_array(); + const std::string& partition_tag_array(int index) const; + std::string* mutable_partition_tag_array(int index); + void set_partition_tag_array(int index, const std::string& value); + void set_partition_tag_array(int index, std::string&& value); + void set_partition_tag_array(int index, const char* value); + void set_partition_tag_array(int index, const char* value, size_t size); + std::string* add_partition_tag_array(); + void add_partition_tag_array(const std::string& value); + void add_partition_tag_array(std::string&& value); + void add_partition_tag_array(const char* value); + void add_partition_tag_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .milvus.grpc.GeneralQuery general_query = 3; + bool has_general_query() const; + void clear_general_query(); + const ::milvus::grpc::GeneralQuery& general_query() const; + ::milvus::grpc::GeneralQuery* release_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(); + void set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HSearchParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::GeneralQuery* general_query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HSearchInSegmentsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HSearchInSegmentsParam) */ { + public: + HSearchInSegmentsParam(); + virtual ~HSearchInSegmentsParam(); + + HSearchInSegmentsParam(const HSearchInSegmentsParam& from); + HSearchInSegmentsParam(HSearchInSegmentsParam&& from) noexcept + : HSearchInSegmentsParam() { + *this = ::std::move(from); + } + + inline HSearchInSegmentsParam& operator=(const HSearchInSegmentsParam& from) { + CopyFrom(from); + return *this; + } + inline HSearchInSegmentsParam& operator=(HSearchInSegmentsParam&& 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 HSearchInSegmentsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HSearchInSegmentsParam* internal_default_instance() { + return reinterpret_cast( + &_HSearchInSegmentsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(HSearchInSegmentsParam& a, HSearchInSegmentsParam& b) { + a.Swap(&b); + } + inline void Swap(HSearchInSegmentsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HSearchInSegmentsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HSearchInSegmentsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HSearchInSegmentsParam& from); + void MergeFrom(const HSearchInSegmentsParam& 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(HSearchInSegmentsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HSearchInSegmentsParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdArrayFieldNumber = 1, + kSearchParamFieldNumber = 2, + }; + // repeated string segment_id_array = 1; + int segment_id_array_size() const; + void clear_segment_id_array(); + const std::string& segment_id_array(int index) const; + std::string* mutable_segment_id_array(int index); + void set_segment_id_array(int index, const std::string& value); + void set_segment_id_array(int index, std::string&& value); + void set_segment_id_array(int index, const char* value); + void set_segment_id_array(int index, const char* value, size_t size); + std::string* add_segment_id_array(); + void add_segment_id_array(const std::string& value); + void add_segment_id_array(std::string&& value); + void add_segment_id_array(const char* value); + void add_segment_id_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& segment_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_segment_id_array(); + + // .milvus.grpc.HSearchParam search_param = 2; + bool has_search_param() const; + void clear_search_param(); + const ::milvus::grpc::HSearchParam& search_param() const; + ::milvus::grpc::HSearchParam* release_search_param(); + ::milvus::grpc::HSearchParam* mutable_search_param(); + void set_allocated_search_param(::milvus::grpc::HSearchParam* search_param); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HSearchInSegmentsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField segment_id_array_; + ::milvus::grpc::HSearchParam* search_param_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class AttrRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.AttrRecord) */ { + public: + AttrRecord(); + virtual ~AttrRecord(); + + AttrRecord(const AttrRecord& from); + AttrRecord(AttrRecord&& from) noexcept + : AttrRecord() { + *this = ::std::move(from); + } + + inline AttrRecord& operator=(const AttrRecord& from) { + CopyFrom(from); + return *this; + } + inline AttrRecord& operator=(AttrRecord&& 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 AttrRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const AttrRecord* internal_default_instance() { + return reinterpret_cast( + &_AttrRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(AttrRecord& a, AttrRecord& b) { + a.Swap(&b); + } + inline void Swap(AttrRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AttrRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + AttrRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AttrRecord& from); + void MergeFrom(const AttrRecord& 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(AttrRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.AttrRecord"; + } + 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 { + kValueFieldNumber = 1, + }; + // repeated string value = 1; + int value_size() const; + void clear_value(); + const std::string& value(int index) const; + std::string* mutable_value(int index); + void set_value(int index, const std::string& value); + void set_value(int index, std::string&& value); + void set_value(int index, const char* value); + void set_value(int index, const char* value, size_t size); + std::string* add_value(); + void add_value(const std::string& value); + void add_value(std::string&& value); + void add_value(const char* value); + void add_value(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_value(); + + // @@protoc_insertion_point(class_scope:milvus.grpc.AttrRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntity : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntity) */ { + public: + HEntity(); + virtual ~HEntity(); + + HEntity(const HEntity& from); + HEntity(HEntity&& from) noexcept + : HEntity() { + *this = ::std::move(from); + } + + inline HEntity& operator=(const HEntity& from) { + CopyFrom(from); + return *this; + } + inline HEntity& operator=(HEntity&& 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 HEntity& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntity* internal_default_instance() { + return reinterpret_cast( + &_HEntity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(HEntity& a, HEntity& b) { + a.Swap(&b); + } + inline void Swap(HEntity* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntity* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntity& from); + void MergeFrom(const HEntity& 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(HEntity* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntity"; + } + 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 { + kFieldNamesFieldNumber = 3, + kAttrRecordsFieldNumber = 4, + kResultValuesFieldNumber = 5, + kStatusFieldNumber = 1, + kEntityIdFieldNumber = 2, + }; + // repeated string field_names = 3; + int field_names_size() const; + void clear_field_names(); + const std::string& field_names(int index) const; + std::string* mutable_field_names(int index); + void set_field_names(int index, const std::string& value); + void set_field_names(int index, std::string&& value); + void set_field_names(int index, const char* value); + void set_field_names(int index, const char* value, size_t size); + std::string* add_field_names(); + void add_field_names(const std::string& value); + void add_field_names(std::string&& value); + void add_field_names(const char* value); + void add_field_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& field_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_field_names(); + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + int attr_records_size() const; + void clear_attr_records(); + ::milvus::grpc::AttrRecord* mutable_attr_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* + mutable_attr_records(); + const ::milvus::grpc::AttrRecord& attr_records(int index) const; + ::milvus::grpc::AttrRecord* add_attr_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& + attr_records() const; + + // repeated .milvus.grpc.FieldValue result_values = 5; + int result_values_size() const; + void clear_result_values(); + ::milvus::grpc::FieldValue* mutable_result_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >* + mutable_result_values(); + const ::milvus::grpc::FieldValue& result_values(int index) const; + ::milvus::grpc::FieldValue* add_result_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >& + result_values() const; + + // .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 entity_id = 2; + void clear_entity_id(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id() const; + void set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntity) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField field_names_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord > attr_records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue > result_values_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HQueryResult : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HQueryResult) */ { + public: + HQueryResult(); + virtual ~HQueryResult(); + + HQueryResult(const HQueryResult& from); + HQueryResult(HQueryResult&& from) noexcept + : HQueryResult() { + *this = ::std::move(from); + } + + inline HQueryResult& operator=(const HQueryResult& from) { + CopyFrom(from); + return *this; + } + inline HQueryResult& operator=(HQueryResult&& 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 HQueryResult& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HQueryResult* internal_default_instance() { + return reinterpret_cast( + &_HQueryResult_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(HQueryResult& a, HQueryResult& b) { + a.Swap(&b); + } + inline void Swap(HQueryResult* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HQueryResult* New() const final { + return CreateMaybeMessage(nullptr); + } + + HQueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HQueryResult& from); + void MergeFrom(const HQueryResult& 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(HQueryResult* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HQueryResult"; + } + 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 { + kEntitiesFieldNumber = 2, + kScoreFieldNumber = 4, + kDistanceFieldNumber = 5, + kStatusFieldNumber = 1, + kRowNumFieldNumber = 3, + }; + // repeated .milvus.grpc.HEntity entities = 2; + int entities_size() const; + void clear_entities(); + ::milvus::grpc::HEntity* mutable_entities(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >* + mutable_entities(); + const ::milvus::grpc::HEntity& entities(int index) const; + ::milvus::grpc::HEntity* add_entities(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& + entities() const; + + // repeated float score = 4; + int score_size() const; + void clear_score(); + float score(int index) const; + void set_score(int index, float value); + void add_score(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + score() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_score(); + + // repeated float distance = 5; + int distance_size() const; + void clear_distance(); + float distance(int index) const; + void set_distance(int index, float value); + void add_distance(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + distance() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_distance(); + + // .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 row_num = 3; + void clear_row_num(); + ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; + void set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HQueryResult) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity > entities_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > score_; + mutable std::atomic _score_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distance_; + mutable std::atomic _distance_cached_byte_size_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int64 row_num_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HInsertParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HInsertParam) */ { + public: + HInsertParam(); + virtual ~HInsertParam(); + + HInsertParam(const HInsertParam& from); + HInsertParam(HInsertParam&& from) noexcept + : HInsertParam() { + *this = ::std::move(from); + } + + inline HInsertParam& operator=(const HInsertParam& from) { + CopyFrom(from); + return *this; + } + inline HInsertParam& operator=(HInsertParam&& 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 HInsertParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HInsertParam* internal_default_instance() { + return reinterpret_cast( + &_HInsertParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(HInsertParam& a, HInsertParam& b) { + a.Swap(&b); + } + inline void Swap(HInsertParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HInsertParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HInsertParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HInsertParam& from); + void MergeFrom(const HInsertParam& 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(HInsertParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HInsertParam"; + } + 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 { + kEntityIdArrayFieldNumber = 4, + kExtraParamsFieldNumber = 5, + kCollectionNameFieldNumber = 1, + kPartitionTagFieldNumber = 2, + kEntitiesFieldNumber = 3, + }; + // repeated int64 entity_id_array = 4; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string partition_tag = 2; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // .milvus.grpc.HEntity entities = 3; + bool has_entities() const; + void clear_entities(); + const ::milvus::grpc::HEntity& entities() const; + ::milvus::grpc::HEntity* release_entities(); + ::milvus::grpc::HEntity* mutable_entities(); + void set_allocated_entities(::milvus::grpc::HEntity* entities); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HInsertParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::milvus::grpc::HEntity* entities_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntityIdentity : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntityIdentity) */ { + public: + HEntityIdentity(); + virtual ~HEntityIdentity(); + + HEntityIdentity(const HEntityIdentity& from); + HEntityIdentity(HEntityIdentity&& from) noexcept + : HEntityIdentity() { + *this = ::std::move(from); + } + + inline HEntityIdentity& operator=(const HEntityIdentity& from) { + CopyFrom(from); + return *this; + } + inline HEntityIdentity& operator=(HEntityIdentity&& 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 HEntityIdentity& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntityIdentity* internal_default_instance() { + return reinterpret_cast( + &_HEntityIdentity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(HEntityIdentity& a, HEntityIdentity& b) { + a.Swap(&b); + } + inline void Swap(HEntityIdentity* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntityIdentity* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntityIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntityIdentity& from); + void MergeFrom(const HEntityIdentity& 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(HEntityIdentity* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntityIdentity"; + } + 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 { + kCollectionNameFieldNumber = 1, + kIdFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // int64 id = 2; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::int64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntityIdentity) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::int64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntityIDs : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntityIDs) */ { + public: + HEntityIDs(); + virtual ~HEntityIDs(); + + HEntityIDs(const HEntityIDs& from); + HEntityIDs(HEntityIDs&& from) noexcept + : HEntityIDs() { + *this = ::std::move(from); + } + + inline HEntityIDs& operator=(const HEntityIDs& from) { + CopyFrom(from); + return *this; + } + inline HEntityIDs& operator=(HEntityIDs&& 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 HEntityIDs& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntityIDs* internal_default_instance() { + return reinterpret_cast( + &_HEntityIDs_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(HEntityIDs& a, HEntityIDs& b) { + a.Swap(&b); + } + inline void Swap(HEntityIDs* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntityIDs* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntityIDs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntityIDs& from); + void MergeFrom(const HEntityIDs& 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(HEntityIDs* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntityIDs"; + } + 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 { + kEntityIdArrayFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated int64 entity_id_array = 2; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // .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); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntityIDs) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HGetEntityIDsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HGetEntityIDsParam) */ { + public: + HGetEntityIDsParam(); + virtual ~HGetEntityIDsParam(); + + HGetEntityIDsParam(const HGetEntityIDsParam& from); + HGetEntityIDsParam(HGetEntityIDsParam&& from) noexcept + : HGetEntityIDsParam() { + *this = ::std::move(from); + } + + inline HGetEntityIDsParam& operator=(const HGetEntityIDsParam& from) { + CopyFrom(from); + return *this; + } + inline HGetEntityIDsParam& operator=(HGetEntityIDsParam&& 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 HGetEntityIDsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HGetEntityIDsParam* internal_default_instance() { + return reinterpret_cast( + &_HGetEntityIDsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 47; + + friend void swap(HGetEntityIDsParam& a, HGetEntityIDsParam& b) { + a.Swap(&b); + } + inline void Swap(HGetEntityIDsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HGetEntityIDsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HGetEntityIDsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HGetEntityIDsParam& from); + void MergeFrom(const HGetEntityIDsParam& 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(HGetEntityIDsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HGetEntityIDsParam"; + } + 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 { + kCollectionNameFieldNumber = 1, + kSegmentNameFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string segment_name = 2; + void clear_segment_name(); + const std::string& segment_name() const; + void set_segment_name(const std::string& value); + void set_segment_name(std::string&& value); + void set_segment_name(const char* value); + void set_segment_name(const char* value, size_t size); + std::string* mutable_segment_name(); + std::string* release_segment_name(); + void set_allocated_segment_name(std::string* segment_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HGetEntityIDsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr segment_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HDeleteByIDParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HDeleteByIDParam) */ { + public: + HDeleteByIDParam(); + virtual ~HDeleteByIDParam(); + + HDeleteByIDParam(const HDeleteByIDParam& from); + HDeleteByIDParam(HDeleteByIDParam&& from) noexcept + : HDeleteByIDParam() { + *this = ::std::move(from); + } + + inline HDeleteByIDParam& operator=(const HDeleteByIDParam& from) { + CopyFrom(from); + return *this; + } + inline HDeleteByIDParam& operator=(HDeleteByIDParam&& 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 HDeleteByIDParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HDeleteByIDParam* internal_default_instance() { + return reinterpret_cast( + &_HDeleteByIDParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 48; + + friend void swap(HDeleteByIDParam& a, HDeleteByIDParam& b) { + a.Swap(&b); + } + inline void Swap(HDeleteByIDParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HDeleteByIDParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HDeleteByIDParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HDeleteByIDParam& from); + void MergeFrom(const HDeleteByIDParam& 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(HDeleteByIDParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HDeleteByIDParam"; + } + 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 { + kIdArrayFieldNumber = 2, + kCollectionNameFieldNumber = 1, + }; + // repeated int64 id_array = 2; + int id_array_size() const; + void clear_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const; + void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id_array(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HDeleteByIDParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; + mutable std::atomic _id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HIndexParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HIndexParam) */ { + public: + HIndexParam(); + virtual ~HIndexParam(); + + HIndexParam(const HIndexParam& from); + HIndexParam(HIndexParam&& from) noexcept + : HIndexParam() { + *this = ::std::move(from); + } + + inline HIndexParam& operator=(const HIndexParam& from) { + CopyFrom(from); + return *this; + } + inline HIndexParam& operator=(HIndexParam&& 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 HIndexParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HIndexParam* internal_default_instance() { + return reinterpret_cast( + &_HIndexParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 49; + + friend void swap(HIndexParam& a, HIndexParam& b) { + a.Swap(&b); + } + inline void Swap(HIndexParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HIndexParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HIndexParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HIndexParam& from); + void MergeFrom(const HIndexParam& 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(HIndexParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HIndexParam"; + } + 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 { + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 2, + kStatusFieldNumber = 1, + kIndexTypeFieldNumber = 3, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .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); + + // int32 index_type = 3; + void clear_index_type(); + ::PROTOBUF_NAMESPACE_ID::int32 index_type() const; + void set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HIndexParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int32 index_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; // =================================================================== @@ -7044,6 +11157,2964 @@ inline void GetVectorIDsParam::set_allocated_segment_name(std::string* segment_n // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.segment_name) } +// ------------------------------------------------------------------- + +// VectorFieldParam + +// int64 dimension = 1; +inline void VectorFieldParam::clear_dimension() { + dimension_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorFieldParam::dimension() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldParam.dimension) + return dimension_; +} +inline void VectorFieldParam::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { + + dimension_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorFieldParam.dimension) +} + +// ------------------------------------------------------------------- + +// FieldType + +// .milvus.grpc.DataType data_type = 1; +inline bool FieldType::has_data_type() const { + return value_case() == kDataType; +} +inline void FieldType::set_has_data_type() { + _oneof_case_[0] = kDataType; +} +inline void FieldType::clear_data_type() { + if (has_data_type()) { + value_.data_type_ = 0; + clear_has_value(); + } +} +inline ::milvus::grpc::DataType FieldType::data_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.data_type) + if (has_data_type()) { + return static_cast< ::milvus::grpc::DataType >(value_.data_type_); + } + return static_cast< ::milvus::grpc::DataType >(0); +} +inline void FieldType::set_data_type(::milvus::grpc::DataType value) { + if (!has_data_type()) { + clear_value(); + set_has_data_type(); + } + value_.data_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldType.data_type) +} + +// .milvus.grpc.VectorFieldParam vector_param = 2; +inline bool FieldType::has_vector_param() const { + return value_case() == kVectorParam; +} +inline void FieldType::set_has_vector_param() { + _oneof_case_[0] = kVectorParam; +} +inline void FieldType::clear_vector_param() { + if (has_vector_param()) { + delete value_.vector_param_; + clear_has_value(); + } +} +inline ::milvus::grpc::VectorFieldParam* FieldType::release_vector_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldType.vector_param) + if (has_vector_param()) { + clear_has_value(); + ::milvus::grpc::VectorFieldParam* temp = value_.vector_param_; + value_.vector_param_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorFieldParam& FieldType::vector_param() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.vector_param) + return has_vector_param() + ? *value_.vector_param_ + : *reinterpret_cast< ::milvus::grpc::VectorFieldParam*>(&::milvus::grpc::_VectorFieldParam_default_instance_); +} +inline ::milvus::grpc::VectorFieldParam* FieldType::mutable_vector_param() { + if (!has_vector_param()) { + clear_value(); + set_has_vector_param(); + value_.vector_param_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldType.vector_param) + return value_.vector_param_; +} + +inline bool FieldType::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void FieldType::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline FieldType::ValueCase FieldType::value_case() const { + return FieldType::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FieldParam + +// uint64 id = 1; +inline void FieldParam::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FieldParam::id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.id) + return id_; +} +inline void FieldParam::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.id) +} + +// string name = 2; +inline void FieldParam::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldParam::name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.name) + return name_.GetNoArena(); +} +inline void FieldParam::set_name(const std::string& value) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(std::string&& value) { + + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value, size_t size) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldParam.name) +} +inline std::string* FieldParam::mutable_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.name) + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldParam::release_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.name) + + return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldParam::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.name) +} + +// .milvus.grpc.FieldType type = 3; +inline bool FieldParam::has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline void FieldParam::clear_type() { + if (GetArenaNoVirtual() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +inline const ::milvus::grpc::FieldType& FieldParam::type() const { + const ::milvus::grpc::FieldType* p = type_; + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.type) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_FieldType_default_instance_); +} +inline ::milvus::grpc::FieldType* FieldParam::release_type() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.type) + + ::milvus::grpc::FieldType* temp = type_; + type_ = nullptr; + return temp; +} +inline ::milvus::grpc::FieldType* FieldParam::mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::FieldType>(GetArenaNoVirtual()); + type_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.type) + return type_; +} +inline void FieldParam::set_allocated_type(::milvus::grpc::FieldType* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.type) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int FieldParam::extra_params_size() const { + return extra_params_.size(); +} +inline void FieldParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +FieldParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& FieldParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +FieldParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorFieldValue + +// repeated .milvus.grpc.RowRecord value = 1; +inline int VectorFieldValue::value_size() const { + return value_.size(); +} +inline void VectorFieldValue::clear_value() { + value_.Clear(); +} +inline ::milvus::grpc::RowRecord* VectorFieldValue::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldValue.value) + return value_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* +VectorFieldValue::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldValue.value) + return &value_; +} +inline const ::milvus::grpc::RowRecord& VectorFieldValue::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldValue.value) + return value_.Get(index); +} +inline ::milvus::grpc::RowRecord* VectorFieldValue::add_value() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldValue.value) + return value_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& +VectorFieldValue::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldValue.value) + return value_; +} + +// ------------------------------------------------------------------- + +// FieldValue + +// int32 int32_value = 1; +inline bool FieldValue::has_int32_value() const { + return value_case() == kInt32Value; +} +inline void FieldValue::set_has_int32_value() { + _oneof_case_[0] = kInt32Value; +} +inline void FieldValue::clear_int32_value() { + if (has_int32_value()) { + value_.int32_value_ = 0; + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 FieldValue::int32_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.int32_value) + if (has_int32_value()) { + return value_.int32_value_; + } + return 0; +} +inline void FieldValue::set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!has_int32_value()) { + clear_value(); + set_has_int32_value(); + } + value_.int32_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.int32_value) +} + +// int64 int64_value = 2; +inline bool FieldValue::has_int64_value() const { + return value_case() == kInt64Value; +} +inline void FieldValue::set_has_int64_value() { + _oneof_case_[0] = kInt64Value; +} +inline void FieldValue::clear_int64_value() { + if (has_int64_value()) { + value_.int64_value_ = PROTOBUF_LONGLONG(0); + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FieldValue::int64_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.int64_value) + if (has_int64_value()) { + return value_.int64_value_; + } + return PROTOBUF_LONGLONG(0); +} +inline void FieldValue::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!has_int64_value()) { + clear_value(); + set_has_int64_value(); + } + value_.int64_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.int64_value) +} + +// float float_value = 3; +inline bool FieldValue::has_float_value() const { + return value_case() == kFloatValue; +} +inline void FieldValue::set_has_float_value() { + _oneof_case_[0] = kFloatValue; +} +inline void FieldValue::clear_float_value() { + if (has_float_value()) { + value_.float_value_ = 0; + clear_has_value(); + } +} +inline float FieldValue::float_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.float_value) + if (has_float_value()) { + return value_.float_value_; + } + return 0; +} +inline void FieldValue::set_float_value(float value) { + if (!has_float_value()) { + clear_value(); + set_has_float_value(); + } + value_.float_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.float_value) +} + +// double double_value = 4; +inline bool FieldValue::has_double_value() const { + return value_case() == kDoubleValue; +} +inline void FieldValue::set_has_double_value() { + _oneof_case_[0] = kDoubleValue; +} +inline void FieldValue::clear_double_value() { + if (has_double_value()) { + value_.double_value_ = 0; + clear_has_value(); + } +} +inline double FieldValue::double_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.double_value) + if (has_double_value()) { + return value_.double_value_; + } + return 0; +} +inline void FieldValue::set_double_value(double value) { + if (!has_double_value()) { + clear_value(); + set_has_double_value(); + } + value_.double_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.double_value) +} + +// string string_value = 5; +inline bool FieldValue::has_string_value() const { + return value_case() == kStringValue; +} +inline void FieldValue::set_has_string_value() { + _oneof_case_[0] = kStringValue; +} +inline void FieldValue::clear_string_value() { + if (has_string_value()) { + value_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + clear_has_value(); + } +} +inline const std::string& FieldValue::string_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.string_value) + if (has_string_value()) { + return value_.string_value_.GetNoArena(); + } + return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void FieldValue::set_string_value(const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(const char* value, size_t size) { + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldValue.string_value) +} +inline std::string* FieldValue::mutable_string_value() { + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.string_value) + return value_.string_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldValue::release_string_value() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldValue.string_value) + if (has_string_value()) { + clear_has_value(); + return value_.string_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } else { + return nullptr; + } +} +inline void FieldValue::set_allocated_string_value(std::string* string_value) { + if (has_value()) { + clear_value(); + } + if (string_value != nullptr) { + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(string_value); + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.string_value) +} + +// bool bool_value = 6; +inline bool FieldValue::has_bool_value() const { + return value_case() == kBoolValue; +} +inline void FieldValue::set_has_bool_value() { + _oneof_case_[0] = kBoolValue; +} +inline void FieldValue::clear_bool_value() { + if (has_bool_value()) { + value_.bool_value_ = false; + clear_has_value(); + } +} +inline bool FieldValue::bool_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.bool_value) + if (has_bool_value()) { + return value_.bool_value_; + } + return false; +} +inline void FieldValue::set_bool_value(bool value) { + if (!has_bool_value()) { + clear_value(); + set_has_bool_value(); + } + value_.bool_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.bool_value) +} + +// .milvus.grpc.VectorFieldValue vector_value = 7; +inline bool FieldValue::has_vector_value() const { + return value_case() == kVectorValue; +} +inline void FieldValue::set_has_vector_value() { + _oneof_case_[0] = kVectorValue; +} +inline void FieldValue::clear_vector_value() { + if (has_vector_value()) { + delete value_.vector_value_; + clear_has_value(); + } +} +inline ::milvus::grpc::VectorFieldValue* FieldValue::release_vector_value() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldValue.vector_value) + if (has_vector_value()) { + clear_has_value(); + ::milvus::grpc::VectorFieldValue* temp = value_.vector_value_; + value_.vector_value_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorFieldValue& FieldValue::vector_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.vector_value) + return has_vector_value() + ? *value_.vector_value_ + : *reinterpret_cast< ::milvus::grpc::VectorFieldValue*>(&::milvus::grpc::_VectorFieldValue_default_instance_); +} +inline ::milvus::grpc::VectorFieldValue* FieldValue::mutable_vector_value() { + if (!has_vector_value()) { + clear_value(); + set_has_vector_value(); + value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.vector_value) + return value_.vector_value_; +} + +inline bool FieldValue::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void FieldValue::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline FieldValue::ValueCase FieldValue::value_case() const { + return FieldValue::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Mapping + +// .milvus.grpc.Status status = 1; +inline bool Mapping::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& Mapping::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* Mapping::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* Mapping::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.status) + return status_; +} +inline void Mapping::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.Mapping.status) +} + +// uint64 collection_id = 2; +inline void Mapping::clear_collection_id() { + collection_id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Mapping::collection_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_id) + return collection_id_; +} +inline void Mapping::set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + collection_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_id) +} + +// string collection_name = 3; +inline void Mapping::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Mapping::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_name) + return collection_name_.GetNoArena(); +} +inline void Mapping::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Mapping.collection_name) +} +inline std::string* Mapping::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Mapping::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Mapping::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Mapping.collection_name) +} + +// repeated .milvus.grpc.FieldParam fields = 4; +inline int Mapping::fields_size() const { + return fields_.size(); +} +inline void Mapping::clear_fields() { + fields_.Clear(); +} +inline ::milvus::grpc::FieldParam* Mapping::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >* +Mapping::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Mapping.fields) + return &fields_; +} +inline const ::milvus::grpc::FieldParam& Mapping::fields(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.fields) + return fields_.Get(index); +} +inline ::milvus::grpc::FieldParam* Mapping::add_fields() { + // @@protoc_insertion_point(field_add:milvus.grpc.Mapping.fields) + return fields_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >& +Mapping::fields() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Mapping.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// MappingList + +// .milvus.grpc.Status status = 1; +inline bool MappingList::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& MappingList::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* MappingList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.MappingList.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* MappingList::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.status) + return status_; +} +inline void MappingList::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.MappingList.status) +} + +// repeated .milvus.grpc.Mapping mapping_list = 2; +inline int MappingList::mapping_list_size() const { + return mapping_list_.size(); +} +inline void MappingList::clear_mapping_list() { + mapping_list_.Clear(); +} +inline ::milvus::grpc::Mapping* MappingList::mutable_mapping_list(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* +MappingList::mutable_mapping_list() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.MappingList.mapping_list) + return &mapping_list_; +} +inline const ::milvus::grpc::Mapping& MappingList::mapping_list(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Get(index); +} +inline ::milvus::grpc::Mapping* MappingList::add_mapping_list() { + // @@protoc_insertion_point(field_add:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& +MappingList::mapping_list() const { + // @@protoc_insertion_point(field_list:milvus.grpc.MappingList.mapping_list) + return mapping_list_; +} + +// ------------------------------------------------------------------- + +// TermQuery + +// string field_name = 1; +inline void TermQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& TermQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.field_name) + return field_name_.GetNoArena(); +} +inline void TermQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.field_name) +} +inline std::string* TermQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* TermQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void TermQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name) +} + +// repeated string values = 2; +inline int TermQuery::values_size() const { + return values_.size(); +} +inline void TermQuery::clear_values() { + values_.Clear(); +} +inline const std::string& TermQuery::values(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.values) + return values_.Get(index); +} +inline std::string* TermQuery::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.values) + return values_.Mutable(index); +} +inline void TermQuery::set_values(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) + values_.Mutable(index)->assign(value); +} +inline void TermQuery::set_values(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) + values_.Mutable(index)->assign(std::move(value)); +} +inline void TermQuery::set_values(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + values_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.values) +} +inline void TermQuery::set_values(int index, const char* value, size_t size) { + values_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.values) +} +inline std::string* TermQuery::add_values() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TermQuery.values) + return values_.Add(); +} +inline void TermQuery::add_values(const std::string& value) { + values_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(std::string&& value) { + values_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(const char* value) { + GOOGLE_DCHECK(value != nullptr); + values_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(const char* value, size_t size) { + values_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TermQuery.values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +TermQuery::values() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.values) + return values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +TermQuery::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.values) + return &values_; +} + +// float boost = 3; +inline void TermQuery::clear_boost() { + boost_ = 0; +} +inline float TermQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.boost) + return boost_; +} +inline void TermQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int TermQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void TermQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +TermQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& TermQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +TermQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// CompareExpr + +// .milvus.grpc.CompareOperator operator = 1; +inline void CompareExpr::clear_operator_() { + operator__ = 0; +} +inline ::milvus::grpc::CompareOperator CompareExpr::operator_() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operator) + return static_cast< ::milvus::grpc::CompareOperator >(operator__); +} +inline void CompareExpr::set_operator_(::milvus::grpc::CompareOperator value) { + + operator__ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operator) +} + +// string operand = 2; +inline void CompareExpr::clear_operand() { + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CompareExpr::operand() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operand) + return operand_.GetNoArena(); +} +inline void CompareExpr::set_operand(const std::string& value) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(std::string&& value) { + + operand_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value, size_t size) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CompareExpr.operand) +} +inline std::string* CompareExpr::mutable_operand() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CompareExpr.operand) + return operand_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CompareExpr::release_operand() { + // @@protoc_insertion_point(field_release:milvus.grpc.CompareExpr.operand) + + return operand_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CompareExpr::set_allocated_operand(std::string* operand) { + if (operand != nullptr) { + + } else { + + } + operand_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), operand); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CompareExpr.operand) +} + +// ------------------------------------------------------------------- + +// RangeQuery + +// string field_name = 1; +inline void RangeQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RangeQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.field_name) + return field_name_.GetNoArena(); +} +inline void RangeQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RangeQuery.field_name) +} +inline std::string* RangeQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RangeQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.RangeQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RangeQuery.field_name) +} + +// repeated .milvus.grpc.CompareExpr operand = 2; +inline int RangeQuery::operand_size() const { + return operand_.size(); +} +inline void RangeQuery::clear_operand() { + operand_.Clear(); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::mutable_operand(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.operand) + return operand_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* +RangeQuery::mutable_operand() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.operand) + return &operand_; +} +inline const ::milvus::grpc::CompareExpr& RangeQuery::operand(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.operand) + return operand_.Get(index); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::add_operand() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.operand) + return operand_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& +RangeQuery::operand() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.operand) + return operand_; +} + +// float boost = 3; +inline void RangeQuery::clear_boost() { + boost_ = 0; +} +inline float RangeQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.boost) + return boost_; +} +inline void RangeQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int RangeQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void RangeQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +RangeQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& RangeQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +RangeQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorQuery + +// string field_name = 1; +inline void VectorQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.field_name) + return field_name_.GetNoArena(); +} +inline void VectorQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorQuery.field_name) +} +inline std::string* VectorQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorQuery.field_name) +} + +// float query_boost = 2; +inline void VectorQuery::clear_query_boost() { + query_boost_ = 0; +} +inline float VectorQuery::query_boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.query_boost) + return query_boost_; +} +inline void VectorQuery::set_query_boost(float value) { + + query_boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.query_boost) +} + +// repeated .milvus.grpc.RowRecord records = 3; +inline int VectorQuery::records_size() const { + return records_.size(); +} +inline void VectorQuery::clear_records() { + records_.Clear(); +} +inline ::milvus::grpc::RowRecord* VectorQuery::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.records) + return records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* +VectorQuery::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.records) + return &records_; +} +inline const ::milvus::grpc::RowRecord& VectorQuery::records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.records) + return records_.Get(index); +} +inline ::milvus::grpc::RowRecord* VectorQuery::add_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.records) + return records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& +VectorQuery::records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.records) + return records_; +} + +// int64 topk = 4; +inline void VectorQuery::clear_topk() { + topk_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorQuery::topk() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.topk) + return topk_; +} +inline void VectorQuery::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) { + + topk_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.topk) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int VectorQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void VectorQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +VectorQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& VectorQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +VectorQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// BooleanQuery + +// .milvus.grpc.Occur occur = 1; +inline void BooleanQuery::clear_occur() { + occur_ = 0; +} +inline ::milvus::grpc::Occur BooleanQuery::occur() const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.occur) + return static_cast< ::milvus::grpc::Occur >(occur_); +} +inline void BooleanQuery::set_occur(::milvus::grpc::Occur value) { + + occur_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.BooleanQuery.occur) +} + +// repeated .milvus.grpc.GeneralQuery general_query = 2; +inline int BooleanQuery::general_query_size() const { + return general_query_.size(); +} +inline void BooleanQuery::clear_general_query() { + general_query_.Clear(); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::mutable_general_query(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.BooleanQuery.general_query) + return general_query_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* +BooleanQuery::mutable_general_query() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.BooleanQuery.general_query) + return &general_query_; +} +inline const ::milvus::grpc::GeneralQuery& BooleanQuery::general_query(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.general_query) + return general_query_.Get(index); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::add_general_query() { + // @@protoc_insertion_point(field_add:milvus.grpc.BooleanQuery.general_query) + return general_query_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& +BooleanQuery::general_query() const { + // @@protoc_insertion_point(field_list:milvus.grpc.BooleanQuery.general_query) + return general_query_; +} + +// ------------------------------------------------------------------- + +// GeneralQuery + +// .milvus.grpc.BooleanQuery boolean_query = 1; +inline bool GeneralQuery::has_boolean_query() const { + return query_case() == kBooleanQuery; +} +inline void GeneralQuery::set_has_boolean_query() { + _oneof_case_[0] = kBooleanQuery; +} +inline void GeneralQuery::clear_boolean_query() { + if (has_boolean_query()) { + delete query_.boolean_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::release_boolean_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.boolean_query) + if (has_boolean_query()) { + clear_has_query(); + ::milvus::grpc::BooleanQuery* temp = query_.boolean_query_; + query_.boolean_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::BooleanQuery& GeneralQuery::boolean_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.boolean_query) + return has_boolean_query() + ? *query_.boolean_query_ + : *reinterpret_cast< ::milvus::grpc::BooleanQuery*>(&::milvus::grpc::_BooleanQuery_default_instance_); +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::mutable_boolean_query() { + if (!has_boolean_query()) { + clear_query(); + set_has_boolean_query(); + query_.boolean_query_ = CreateMaybeMessage< ::milvus::grpc::BooleanQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.boolean_query) + return query_.boolean_query_; +} + +// .milvus.grpc.TermQuery term_query = 2; +inline bool GeneralQuery::has_term_query() const { + return query_case() == kTermQuery; +} +inline void GeneralQuery::set_has_term_query() { + _oneof_case_[0] = kTermQuery; +} +inline void GeneralQuery::clear_term_query() { + if (has_term_query()) { + delete query_.term_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::TermQuery* GeneralQuery::release_term_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.term_query) + if (has_term_query()) { + clear_has_query(); + ::milvus::grpc::TermQuery* temp = query_.term_query_; + query_.term_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::TermQuery& GeneralQuery::term_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.term_query) + return has_term_query() + ? *query_.term_query_ + : *reinterpret_cast< ::milvus::grpc::TermQuery*>(&::milvus::grpc::_TermQuery_default_instance_); +} +inline ::milvus::grpc::TermQuery* GeneralQuery::mutable_term_query() { + if (!has_term_query()) { + clear_query(); + set_has_term_query(); + query_.term_query_ = CreateMaybeMessage< ::milvus::grpc::TermQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.term_query) + return query_.term_query_; +} + +// .milvus.grpc.RangeQuery range_query = 3; +inline bool GeneralQuery::has_range_query() const { + return query_case() == kRangeQuery; +} +inline void GeneralQuery::set_has_range_query() { + _oneof_case_[0] = kRangeQuery; +} +inline void GeneralQuery::clear_range_query() { + if (has_range_query()) { + delete query_.range_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::release_range_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.range_query) + if (has_range_query()) { + clear_has_query(); + ::milvus::grpc::RangeQuery* temp = query_.range_query_; + query_.range_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::RangeQuery& GeneralQuery::range_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.range_query) + return has_range_query() + ? *query_.range_query_ + : *reinterpret_cast< ::milvus::grpc::RangeQuery*>(&::milvus::grpc::_RangeQuery_default_instance_); +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::mutable_range_query() { + if (!has_range_query()) { + clear_query(); + set_has_range_query(); + query_.range_query_ = CreateMaybeMessage< ::milvus::grpc::RangeQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.range_query) + return query_.range_query_; +} + +// .milvus.grpc.VectorQuery vector_query = 4; +inline bool GeneralQuery::has_vector_query() const { + return query_case() == kVectorQuery; +} +inline void GeneralQuery::set_has_vector_query() { + _oneof_case_[0] = kVectorQuery; +} +inline void GeneralQuery::clear_vector_query() { + if (has_vector_query()) { + delete query_.vector_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::release_vector_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.vector_query) + if (has_vector_query()) { + clear_has_query(); + ::milvus::grpc::VectorQuery* temp = query_.vector_query_; + query_.vector_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorQuery& GeneralQuery::vector_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.vector_query) + return has_vector_query() + ? *query_.vector_query_ + : *reinterpret_cast< ::milvus::grpc::VectorQuery*>(&::milvus::grpc::_VectorQuery_default_instance_); +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::mutable_vector_query() { + if (!has_vector_query()) { + clear_query(); + set_has_vector_query(); + query_.vector_query_ = CreateMaybeMessage< ::milvus::grpc::VectorQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.vector_query) + return query_.vector_query_; +} + +inline bool GeneralQuery::has_query() const { + return query_case() != QUERY_NOT_SET; +} +inline void GeneralQuery::clear_has_query() { + _oneof_case_[0] = QUERY_NOT_SET; +} +inline GeneralQuery::QueryCase GeneralQuery::query_case() const { + return GeneralQuery::QueryCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// HSearchParam + +// string collection_name = 1; +inline void HSearchParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HSearchParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HSearchParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchParam.collection_name) +} +inline std::string* HSearchParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HSearchParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HSearchParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchParam.collection_name) +} + +// repeated string partition_tag_array = 2; +inline int HSearchParam::partition_tag_array_size() const { + return partition_tag_array_.size(); +} +inline void HSearchParam::clear_partition_tag_array() { + partition_tag_array_.Clear(); +} +inline const std::string& HSearchParam::partition_tag_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Get(index); +} +inline std::string* HSearchParam::mutable_partition_tag_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Mutable(index); +} +inline void HSearchParam::set_partition_tag_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(value); +} +inline void HSearchParam::set_partition_tag_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(std::move(value)); +} +inline void HSearchParam::set_partition_tag_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::set_partition_tag_array(int index, const char* value, size_t size) { + partition_tag_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchParam.partition_tag_array) +} +inline std::string* HSearchParam::add_partition_tag_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Add(); +} +inline void HSearchParam::add_partition_tag_array(const std::string& value) { + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(std::string&& value) { + partition_tag_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(const char* value, size_t size) { + partition_tag_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HSearchParam.partition_tag_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HSearchParam::partition_tag_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HSearchParam::mutable_partition_tag_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchParam.partition_tag_array) + return &partition_tag_array_; +} + +// .milvus.grpc.GeneralQuery general_query = 3; +inline bool HSearchParam::has_general_query() const { + return this != internal_default_instance() && general_query_ != nullptr; +} +inline void HSearchParam::clear_general_query() { + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; +} +inline const ::milvus::grpc::GeneralQuery& HSearchParam::general_query() const { + const ::milvus::grpc::GeneralQuery* p = general_query_; + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.general_query) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_GeneralQuery_default_instance_); +} +inline ::milvus::grpc::GeneralQuery* HSearchParam::release_general_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchParam.general_query) + + ::milvus::grpc::GeneralQuery* temp = general_query_; + general_query_ = nullptr; + return temp; +} +inline ::milvus::grpc::GeneralQuery* HSearchParam::mutable_general_query() { + + if (general_query_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::GeneralQuery>(GetArenaNoVirtual()); + general_query_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.general_query) + return general_query_; +} +inline void HSearchParam::set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete general_query_; + } + if (general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + general_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, general_query, submessage_arena); + } + + } else { + + } + general_query_ = general_query; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchParam.general_query) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int HSearchParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HSearchParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HSearchParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HSearchParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HSearchParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HSearchParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HSearchParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// HSearchInSegmentsParam + +// repeated string segment_id_array = 1; +inline int HSearchInSegmentsParam::segment_id_array_size() const { + return segment_id_array_.size(); +} +inline void HSearchInSegmentsParam::clear_segment_id_array() { + segment_id_array_.Clear(); +} +inline const std::string& HSearchInSegmentsParam::segment_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Get(index); +} +inline std::string* HSearchInSegmentsParam::mutable_segment_id_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Mutable(index); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(value); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(std::move(value)); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const char* value, size_t size) { + segment_id_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline std::string* HSearchInSegmentsParam::add_segment_id_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Add(); +} +inline void HSearchInSegmentsParam::add_segment_id_array(const std::string& value) { + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(std::string&& value) { + segment_id_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(const char* value, size_t size) { + segment_id_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HSearchInSegmentsParam::segment_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HSearchInSegmentsParam::mutable_segment_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return &segment_id_array_; +} + +// .milvus.grpc.HSearchParam search_param = 2; +inline bool HSearchInSegmentsParam::has_search_param() const { + return this != internal_default_instance() && search_param_ != nullptr; +} +inline void HSearchInSegmentsParam::clear_search_param() { + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; +} +inline const ::milvus::grpc::HSearchParam& HSearchInSegmentsParam::search_param() const { + const ::milvus::grpc::HSearchParam* p = search_param_; + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchInSegmentsParam.search_param) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HSearchParam_default_instance_); +} +inline ::milvus::grpc::HSearchParam* HSearchInSegmentsParam::release_search_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchInSegmentsParam.search_param) + + ::milvus::grpc::HSearchParam* temp = search_param_; + search_param_ = nullptr; + return temp; +} +inline ::milvus::grpc::HSearchParam* HSearchInSegmentsParam::mutable_search_param() { + + if (search_param_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HSearchParam>(GetArenaNoVirtual()); + search_param_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchInSegmentsParam.search_param) + return search_param_; +} +inline void HSearchInSegmentsParam::set_allocated_search_param(::milvus::grpc::HSearchParam* search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete search_param_; + } + if (search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + search_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, search_param, submessage_arena); + } + + } else { + + } + search_param_ = search_param; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchInSegmentsParam.search_param) +} + +// ------------------------------------------------------------------- + +// AttrRecord + +// repeated string value = 1; +inline int AttrRecord::value_size() const { + return value_.size(); +} +inline void AttrRecord::clear_value() { + value_.Clear(); +} +inline const std::string& AttrRecord::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.value) + return value_.Get(index); +} +inline std::string* AttrRecord::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.AttrRecord.value) + return value_.Mutable(index); +} +inline void AttrRecord::set_value(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.value) + value_.Mutable(index)->assign(value); +} +inline void AttrRecord::set_value(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.value) + value_.Mutable(index)->assign(std::move(value)); +} +inline void AttrRecord::set_value(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + value_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::set_value(int index, const char* value, size_t size) { + value_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.AttrRecord.value) +} +inline std::string* AttrRecord::add_value() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.AttrRecord.value) + return value_.Add(); +} +inline void AttrRecord::add_value(const std::string& value) { + value_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(std::string&& value) { + value_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + value_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(const char* value, size_t size) { + value_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.AttrRecord.value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +AttrRecord::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.value) + return value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +AttrRecord::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.value) + return &value_; +} + +// ------------------------------------------------------------------- + +// HEntity + +// .milvus.grpc.Status status = 1; +inline bool HEntity::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HEntity::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HEntity::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntity.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HEntity::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.status) + return status_; +} +inline void HEntity::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.HEntity.status) +} + +// int64 entity_id = 2; +inline void HEntity::clear_entity_id() { + entity_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.entity_id) + return entity_id_; +} +inline void HEntity::set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + entity_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.entity_id) +} + +// repeated string field_names = 3; +inline int HEntity::field_names_size() const { + return field_names_.size(); +} +inline void HEntity::clear_field_names() { + field_names_.Clear(); +} +inline const std::string& HEntity::field_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.field_names) + return field_names_.Get(index); +} +inline std::string* HEntity::mutable_field_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.field_names) + return field_names_.Mutable(index); +} +inline void HEntity::set_field_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.field_names) + field_names_.Mutable(index)->assign(value); +} +inline void HEntity::set_field_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.field_names) + field_names_.Mutable(index)->assign(std::move(value)); +} +inline void HEntity::set_field_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntity.field_names) +} +inline void HEntity::set_field_names(int index, const char* value, size_t size) { + field_names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntity.field_names) +} +inline std::string* HEntity::add_field_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HEntity.field_names) + return field_names_.Add(); +} +inline void HEntity::add_field_names(const std::string& value) { + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(std::string&& value) { + field_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(const char* value, size_t size) { + field_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HEntity.field_names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HEntity::field_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.field_names) + return field_names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HEntity::mutable_field_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.field_names) + return &field_names_; +} + +// repeated .milvus.grpc.AttrRecord attr_records = 4; +inline int HEntity::attr_records_size() const { + return attr_records_.size(); +} +inline void HEntity::clear_attr_records() { + attr_records_.Clear(); +} +inline ::milvus::grpc::AttrRecord* HEntity::mutable_attr_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_records) + return attr_records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* +HEntity::mutable_attr_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.attr_records) + return &attr_records_; +} +inline const ::milvus::grpc::AttrRecord& HEntity::attr_records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_records) + return attr_records_.Get(index); +} +inline ::milvus::grpc::AttrRecord* HEntity::add_attr_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.attr_records) + return attr_records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& +HEntity::attr_records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.attr_records) + return attr_records_; +} + +// repeated .milvus.grpc.FieldValue result_values = 5; +inline int HEntity::result_values_size() const { + return result_values_.size(); +} +inline void HEntity::clear_result_values() { + result_values_.Clear(); +} +inline ::milvus::grpc::FieldValue* HEntity::mutable_result_values(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.result_values) + return result_values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >* +HEntity::mutable_result_values() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.result_values) + return &result_values_; +} +inline const ::milvus::grpc::FieldValue& HEntity::result_values(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.result_values) + return result_values_.Get(index); +} +inline ::milvus::grpc::FieldValue* HEntity::add_result_values() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.result_values) + return result_values_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >& +HEntity::result_values() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.result_values) + return result_values_; +} + +// ------------------------------------------------------------------- + +// HQueryResult + +// .milvus.grpc.Status status = 1; +inline bool HQueryResult::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HQueryResult::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HQueryResult::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HQueryResult.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HQueryResult::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.status) + return status_; +} +inline void HQueryResult::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.HQueryResult.status) +} + +// repeated .milvus.grpc.HEntity entities = 2; +inline int HQueryResult::entities_size() const { + return entities_.size(); +} +inline void HQueryResult::clear_entities() { + entities_.Clear(); +} +inline ::milvus::grpc::HEntity* HQueryResult::mutable_entities(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entities) + return entities_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >* +HQueryResult::mutable_entities() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.entities) + return &entities_; +} +inline const ::milvus::grpc::HEntity& HQueryResult::entities(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.entities) + return entities_.Get(index); +} +inline ::milvus::grpc::HEntity* HQueryResult::add_entities() { + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.entities) + return entities_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& +HQueryResult::entities() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.entities) + return entities_; +} + +// int64 row_num = 3; +inline void HQueryResult::clear_row_num() { + row_num_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HQueryResult::row_num() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.row_num) + return row_num_; +} +inline void HQueryResult::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) { + + row_num_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.row_num) +} + +// repeated float score = 4; +inline int HQueryResult::score_size() const { + return score_.size(); +} +inline void HQueryResult::clear_score() { + score_.Clear(); +} +inline float HQueryResult::score(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.score) + return score_.Get(index); +} +inline void HQueryResult::set_score(int index, float value) { + score_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.score) +} +inline void HQueryResult::add_score(float value) { + score_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.score) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +HQueryResult::score() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.score) + return score_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +HQueryResult::mutable_score() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.score) + return &score_; +} + +// repeated float distance = 5; +inline int HQueryResult::distance_size() const { + return distance_.size(); +} +inline void HQueryResult::clear_distance() { + distance_.Clear(); +} +inline float HQueryResult::distance(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.distance) + return distance_.Get(index); +} +inline void HQueryResult::set_distance(int index, float value) { + distance_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.distance) +} +inline void HQueryResult::add_distance(float value) { + distance_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.distance) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +HQueryResult::distance() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.distance) + return distance_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +HQueryResult::mutable_distance() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.distance) + return &distance_; +} + +// ------------------------------------------------------------------- + +// HInsertParam + +// string collection_name = 1; +inline void HInsertParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HInsertParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HInsertParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HInsertParam.collection_name) +} +inline std::string* HInsertParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HInsertParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HInsertParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.collection_name) +} + +// string partition_tag = 2; +inline void HInsertParam::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HInsertParam::partition_tag() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void HInsertParam::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HInsertParam.partition_tag) +} +inline std::string* HInsertParam::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HInsertParam::release_partition_tag() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HInsertParam::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.partition_tag) +} + +// .milvus.grpc.HEntity entities = 3; +inline bool HInsertParam::has_entities() const { + return this != internal_default_instance() && entities_ != nullptr; +} +inline void HInsertParam::clear_entities() { + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; +} +inline const ::milvus::grpc::HEntity& HInsertParam::entities() const { + const ::milvus::grpc::HEntity* p = entities_; + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entities) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HEntity_default_instance_); +} +inline ::milvus::grpc::HEntity* HInsertParam::release_entities() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.entities) + + ::milvus::grpc::HEntity* temp = entities_; + entities_ = nullptr; + return temp; +} +inline ::milvus::grpc::HEntity* HInsertParam::mutable_entities() { + + if (entities_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); + entities_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entities) + return entities_; +} +inline void HInsertParam::set_allocated_entities(::milvus::grpc::HEntity* entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete entities_; + } + if (entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entities, submessage_arena); + } + + } else { + + } + entities_ = entities; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entities) +} + +// repeated int64 entity_id_array = 4; +inline int HInsertParam::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void HInsertParam::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HInsertParam::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entity_id_array) + return entity_id_array_.Get(index); +} +inline void HInsertParam::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.entity_id_array) +} +inline void HInsertParam::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HInsertParam.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HInsertParam::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HInsertParam.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HInsertParam::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HInsertParam.entity_id_array) + return &entity_id_array_; +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int HInsertParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HInsertParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HInsertParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HInsertParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HInsertParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HInsertParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HInsertParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HInsertParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HInsertParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// HEntityIdentity + +// string collection_name = 1; +inline void HEntityIdentity::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HEntityIdentity::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.collection_name) + return collection_name_.GetNoArena(); +} +inline void HEntityIdentity::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntityIdentity.collection_name) +} +inline std::string* HEntityIdentity::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntityIdentity.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HEntityIdentity::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntityIdentity.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HEntityIdentity::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntityIdentity.collection_name) +} + +// int64 id = 2; +inline void HEntityIdentity::clear_id() { + id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.id) + return id_; +} +inline void HEntityIdentity::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.id) +} + +// ------------------------------------------------------------------- + +// HEntityIDs + +// .milvus.grpc.Status status = 1; +inline bool HEntityIDs::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HEntityIDs::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIDs.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HEntityIDs::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntityIDs.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HEntityIDs::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntityIDs.status) + return status_; +} +inline void HEntityIDs::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.HEntityIDs.status) +} + +// repeated int64 entity_id_array = 2; +inline int HEntityIDs::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void HEntityIDs::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIDs::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIDs.entity_id_array) + return entity_id_array_.Get(index); +} +inline void HEntityIDs::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIDs.entity_id_array) +} +inline void HEntityIDs::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntityIDs.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntityIDs::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntityIDs.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntityIDs::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntityIDs.entity_id_array) + return &entity_id_array_; +} + +// ------------------------------------------------------------------- + +// HGetEntityIDsParam + +// string collection_name = 1; +inline void HGetEntityIDsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HGetEntityIDsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HGetEntityIDsParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HGetEntityIDsParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline std::string* HGetEntityIDsParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HGetEntityIDsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HGetEntityIDsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HGetEntityIDsParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HGetEntityIDsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HGetEntityIDsParam.collection_name) +} + +// string segment_name = 2; +inline void HGetEntityIDsParam::clear_segment_name() { + segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HGetEntityIDsParam::segment_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HGetEntityIDsParam.segment_name) + return segment_name_.GetNoArena(); +} +inline void HGetEntityIDsParam::set_segment_name(const std::string& value) { + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(std::string&& value) { + + segment_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(const char* value, size_t size) { + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline std::string* HGetEntityIDsParam::mutable_segment_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HGetEntityIDsParam.segment_name) + return segment_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HGetEntityIDsParam::release_segment_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HGetEntityIDsParam.segment_name) + + return segment_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HGetEntityIDsParam::set_allocated_segment_name(std::string* segment_name) { + if (segment_name != nullptr) { + + } else { + + } + segment_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), segment_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HGetEntityIDsParam.segment_name) +} + +// ------------------------------------------------------------------- + +// HDeleteByIDParam + +// string collection_name = 1; +inline void HDeleteByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HDeleteByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HDeleteByIDParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HDeleteByIDParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline std::string* HDeleteByIDParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HDeleteByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HDeleteByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HDeleteByIDParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HDeleteByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HDeleteByIDParam.collection_name) +} + +// repeated int64 id_array = 2; +inline int HDeleteByIDParam::id_array_size() const { + return id_array_.size(); +} +inline void HDeleteByIDParam::clear_id_array() { + id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HDeleteByIDParam::id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HDeleteByIDParam.id_array) + return id_array_.Get(index); +} +inline void HDeleteByIDParam::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HDeleteByIDParam.id_array) +} +inline void HDeleteByIDParam::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HDeleteByIDParam.id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HDeleteByIDParam::id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HDeleteByIDParam.id_array) + return id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HDeleteByIDParam::mutable_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HDeleteByIDParam.id_array) + return &id_array_; +} + +// ------------------------------------------------------------------- + +// HIndexParam + +// .milvus.grpc.Status status = 1; +inline bool HIndexParam::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HIndexParam::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HIndexParam::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HIndexParam.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HIndexParam::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.status) + return status_; +} +inline void HIndexParam::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.HIndexParam.status) +} + +// string collection_name = 2; +inline void HIndexParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HIndexParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HIndexParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HIndexParam.collection_name) +} +inline std::string* HIndexParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HIndexParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HIndexParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HIndexParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HIndexParam.collection_name) +} + +// int32 index_type = 3; +inline void HIndexParam::clear_index_type() { + index_type_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HIndexParam::index_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.index_type) + return index_type_; +} +inline void HIndexParam::set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value) { + + index_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HIndexParam.index_type) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int HIndexParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HIndexParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HIndexParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HIndexParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HIndexParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HIndexParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HIndexParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HIndexParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HIndexParam.extra_params) + return extra_params_; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -7097,12 +14168,80 @@ inline void GetVectorIDsParam::set_allocated_segment_name(std::string* segment_n // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) } // namespace grpc } // namespace milvus +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::milvus::grpc::DataType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::DataType>() { + return ::milvus::grpc::DataType_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::CompareOperator> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::CompareOperator>() { + return ::milvus::grpc::CompareOperator_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::Occur> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::Occur>() { + return ::milvus::grpc::Occur_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + // @@protoc_insertion_point(global_scope) #include diff --git a/core/src/grpc/milvus.proto b/core/src/grpc/milvus.proto index 5e46842a87..bbf81d2b8d 100644 --- a/core/src/grpc/milvus.proto +++ b/core/src/grpc/milvus.proto @@ -232,6 +232,208 @@ message GetVectorIDsParam { string segment_name = 2; } + +/********************************************************************************************************************/ + +enum DataType { + NULL = 0; + INT8 = 1; + INT16 = 2; + INT32 = 3; + INT64 = 4; + + STRING = 20; + + BOOL = 30; + + FLOAT = 40; + DOUBLE = 41; + + VECTOR = 100; + UNKNOWN = 9999; +} + +/////////////////////////////////////////////////////////////////// + +message VectorFieldParam { + int64 dimension = 1; +} + +message FieldType { + oneof value { + DataType data_type = 1; + VectorFieldParam vector_param = 2; + } +} + +message FieldParam { + uint64 id = 1; + string name = 2; + FieldType type = 3; + repeated KeyValuePair extra_params = 4; +} + +message VectorFieldValue { + repeated RowRecord value = 1; +} + +message FieldValue { + oneof value { + int32 int32_value = 1; + int64 int64_value = 2; + float float_value = 3; + double double_value = 4; + string string_value = 5; + bool bool_value = 6; + VectorFieldValue vector_value = 7; + } +} + +/////////////////////////////////////////////////////////////////// + +message Mapping { + Status status = 1; + uint64 collection_id = 2; + string collection_name = 3; + repeated FieldParam fields = 4; +} + +message MappingList { + Status status = 1; + repeated Mapping mapping_list = 2; +} + +/////////////////////////////////////////////////////////////////// + +message TermQuery { + string field_name = 1; + repeated string values = 2; + float boost = 3; + repeated KeyValuePair extra_params = 4; +} + +enum CompareOperator { + LT = 0; + LTE = 1; + EQ = 2; + GT = 3; + GTE = 4; + NE = 5; +} + +message CompareExpr { + CompareOperator operator = 1; + string operand = 2; +} + +message RangeQuery { + string field_name = 1; + repeated CompareExpr operand = 2; + float boost = 3; + repeated KeyValuePair extra_params = 4; +} + +message VectorQuery { + string field_name = 1; + float query_boost = 2; + repeated RowRecord records = 3; + int64 topk = 4; + repeated KeyValuePair extra_params = 5; +} + +enum Occur { + INVALID = 0; + MUST = 1; + SHOULD = 2; + MUST_NOT = 3; +} + +message BooleanQuery { + Occur occur = 1; + repeated GeneralQuery general_query = 2; +} + +message GeneralQuery { + oneof query { + BooleanQuery boolean_query = 1; + TermQuery term_query = 2; + RangeQuery range_query = 3; + VectorQuery vector_query = 4; + } +} + +message HSearchParam { + string collection_name = 1; + repeated string partition_tag_array = 2; + GeneralQuery general_query = 3; + repeated KeyValuePair extra_params = 4; +} + +message HSearchInSegmentsParam { + repeated string segment_id_array = 1; + HSearchParam search_param = 2; +} + +/////////////////////////////////////////////////////////////////// + +message AttrRecord { + repeated string value = 1; +} + +message HEntity { + Status status = 1; + int64 entity_id = 2; + repeated string field_names = 3; + repeated AttrRecord attr_records = 4; + repeated FieldValue result_values = 5; +} + +message HQueryResult { + Status status = 1; + repeated HEntity entities = 2; + int64 row_num = 3; + repeated float score = 4; + repeated float distance = 5; +} + +message HInsertParam { + string collection_name = 1; + string partition_tag = 2; + HEntity entities = 3; + repeated int64 entity_id_array = 4; + repeated KeyValuePair extra_params = 5; +} + +message HEntityIdentity { + string collection_name = 1; + int64 id = 2; +} + +message HEntityIDs { + Status status = 1; + repeated int64 entity_id_array = 2; +} + +message HGetEntityIDsParam { + string collection_name = 1; + string segment_name = 2; +} + +message HDeleteByIDParam { + string collection_name = 1; + repeated int64 id_array = 2; +} + +/////////////////////////////////////////////////////////////////// + +message HIndexParam { + Status status = 1; + string collection_name = 2; + int32 index_type = 3; + repeated KeyValuePair extra_params = 4; +} + + service MilvusService { /** * @brief This method is used to create collection @@ -448,4 +650,47 @@ service MilvusService { * @return Status */ rpc Compact(CollectionName) returns (Status) {} -} + + /********************************New Interface********************************************/ + + rpc CreateHybridCollection(Mapping) returns (Status) {} + + rpc HasHybridCollection(CollectionName) returns (BoolReply) {} + + rpc DropHybridCollection(CollectionName) returns (Status) {} + + rpc DescribeHybridCollection(CollectionName) returns (Mapping) {} + + rpc CountHybridCollection(CollectionName) returns (CollectionRowCount) {} + + rpc ShowHybridCollections(Command) returns (MappingList) {} + + rpc ShowHybridCollectionInfo (CollectionName) returns (CollectionInfo) {} + + rpc PreloadHybridCollection(CollectionName) returns (Status) {} + + /////////////////////////////////////////////////////////////////// + +// rpc CreateIndex(IndexParam) returns (Status) {} +// +// rpc DescribeIndex(CollectionName) returns (IndexParam) {} +// +// rpc DropIndex(CollectionName) returns (Status) {} + + /////////////////////////////////////////////////////////////////// + + rpc InsertEntity(HInsertParam) returns (HEntityIDs) {} + + // TODO(yukun): will change to HQueryResult + rpc HybridSearch(HSearchParam) returns (TopKQueryResult) {} + + rpc HybridSearchInSegments(HSearchInSegmentsParam) returns (TopKQueryResult) {} + + rpc GetEntityByID(HEntityIdentity) returns (HEntity) {} + + rpc GetEntityIDs(HGetEntityIDsParam) returns (HEntityIDs) {} + + rpc DeleteEntitiesByID(HDeleteByIDParam) returns (Status) {} + + /////////////////////////////////////////////////////////////////// +} \ No newline at end of file diff --git a/core/src/query/BinaryQuery.cpp b/core/src/query/BinaryQuery.cpp new file mode 100644 index 0000000000..27b57f86d0 --- /dev/null +++ b/core/src/query/BinaryQuery.cpp @@ -0,0 +1,222 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include + +#include "query/BinaryQuery.h" + +namespace milvus { +namespace query { + +BinaryQueryPtr +ConstructBinTree(std::vector queries, QueryRelation relation, uint64_t idx) { + if (idx == queries.size()) { + return nullptr; + } else if (idx == queries.size() - 1) { + return queries[idx]->getBinaryQuery(); + } else { + BinaryQueryPtr bquery = std::make_shared(); + bquery->relation = relation; + bquery->left_query = std::make_shared(); + bquery->right_query = std::make_shared(); + bquery->left_query->bin = queries[idx]->getBinaryQuery(); + ++idx; + bquery->right_query->bin = ConstructBinTree(queries, relation, idx); + return bquery; + } +} + +Status +ConstructLeafBinTree(std::vector leaf_queries, BinaryQueryPtr binary_query, uint64_t idx) { + if (idx == leaf_queries.size()) { + return Status::OK(); + } + binary_query->left_query = std::make_shared(); + binary_query->right_query = std::make_shared(); + if (leaf_queries.size() == leaf_queries.size() - 1) { + binary_query->left_query->leaf = leaf_queries[idx]; + return Status::OK(); + } else if (idx == leaf_queries.size() - 2) { + binary_query->left_query->leaf = leaf_queries[idx]; + ++idx; + binary_query->right_query->leaf = leaf_queries[idx]; + return Status::OK(); + } else { + binary_query->left_query->bin->relation = binary_query->relation; + binary_query->right_query->leaf = leaf_queries[idx]; + ++idx; + return ConstructLeafBinTree(leaf_queries, binary_query->left_query->bin, idx); + } +} + +Status +GenBinaryQuery(BooleanQueryPtr query, BinaryQueryPtr& binary_query) { + if (query->getBooleanQuerys().size() == 0) { + if (binary_query->relation == QueryRelation::AND || binary_query->relation == QueryRelation::OR) { + // Put VectorQuery to the end of leafqueries + auto query_size = query->getLeafQueries().size(); + for (uint64_t i = 0; i < query_size; ++i) { + if (query->getLeafQueries()[i]->vector_query != nullptr) { + std::swap(query->getLeafQueries()[i], query->getLeafQueries()[0]); + break; + } + } + return ConstructLeafBinTree(query->getLeafQueries(), binary_query, 0); + } else { + switch (query->getOccur()) { + case Occur::MUST: { + binary_query->relation = QueryRelation::AND; + return GenBinaryQuery(query, binary_query); + } + case Occur::MUST_NOT: + case Occur::SHOULD: { + binary_query->relation = QueryRelation::OR; + return GenBinaryQuery(query, binary_query); + } + } + } + } + + if (query->getBooleanQuerys().size() == 1) { + auto bc = query->getBooleanQuerys()[0]; + binary_query->left_query = std::make_shared(); + switch (bc->getOccur()) { + case Occur::MUST: { + binary_query->relation = QueryRelation::AND; + Status s = GenBinaryQuery(bc, binary_query); + return s; + } + case Occur::MUST_NOT: + case Occur::SHOULD: { + binary_query->relation = QueryRelation::OR; + Status s = GenBinaryQuery(bc, binary_query); + return s; + } + } + } + + // Construct binary query for every single boolean query + std::vector must_queries; + std::vector must_not_queries; + std::vector should_queries; + Status status; + for (auto& _query : query->getBooleanQuerys()) { + status = GenBinaryQuery(_query, _query->getBinaryQuery()); + if (!status.ok()) { + return status; + } + if (_query->getOccur() == Occur::MUST) { + must_queries.emplace_back(_query); + } else if (_query->getOccur() == Occur::MUST_NOT) { + must_not_queries.emplace_back(_query); + } else { + should_queries.emplace_back(_query); + } + } + + // Construct binary query for combine boolean queries + BinaryQueryPtr must_bquery, should_bquery, must_not_bquery; + uint64_t bquery_num = 0; + if (must_queries.size() > 1) { + // Construct a must binary tree + must_bquery = ConstructBinTree(must_queries, QueryRelation::R1, 0); + ++bquery_num; + } else if (must_queries.size() == 1) { + must_bquery = must_queries[0]->getBinaryQuery(); + ++bquery_num; + } + + if (should_queries.size() > 1) { + // Construct a should binary tree + should_bquery = ConstructBinTree(should_queries, QueryRelation::R2, 0); + ++bquery_num; + } else if (should_queries.size() == 1) { + should_bquery = should_queries[0]->getBinaryQuery(); + ++bquery_num; + } + + if (must_not_queries.size() > 1) { + // Construct a must_not binary tree + must_not_bquery = ConstructBinTree(must_not_queries, QueryRelation::R1, 0); + ++bquery_num; + } else if (must_not_queries.size() == 1) { + must_not_bquery = must_not_queries[0]->getBinaryQuery(); + ++bquery_num; + } + + binary_query->left_query = std::make_shared(); + binary_query->right_query = std::make_shared(); + BinaryQueryPtr must_should_query = std::make_shared(); + must_should_query->left_query = std::make_shared(); + must_should_query->right_query = std::make_shared(); + if (bquery_num == 3) { + must_should_query->relation = QueryRelation::R3; + must_should_query->left_query->bin = must_bquery; + must_should_query->right_query->bin = should_bquery; + binary_query->relation = QueryRelation::R1; + binary_query->left_query->bin = must_should_query; + binary_query->right_query->bin = must_not_bquery; + } else if (bquery_num == 2) { + if (must_bquery == nullptr) { + binary_query->relation = QueryRelation::R3; + binary_query->left_query->bin = must_not_bquery; + binary_query->right_query->bin = should_bquery; + } else if (should_bquery == nullptr) { + binary_query->relation = QueryRelation::R4; + binary_query->left_query->bin = must_bquery; + binary_query->right_query->bin = must_not_bquery; + } else { + binary_query->relation = QueryRelation::R3; + binary_query->left_query->bin = must_bquery; + binary_query->right_query->bin = should_bquery; + } + } else { + if (must_bquery != nullptr) { + binary_query = must_bquery; + } else if (should_bquery != nullptr) { + binary_query = should_bquery; + } else { + binary_query = must_not_bquery; + } + } + + return Status::OK(); +} + +uint64_t +BinaryQueryHeight(BinaryQueryPtr& binary_query) { + if (binary_query == nullptr) { + return 1; + } + uint64_t left_height = 0, right_height = 0; + if (binary_query->left_query != nullptr) { + left_height = BinaryQueryHeight(binary_query->left_query->bin); + } + if (binary_query->right_query != nullptr) { + right_height = BinaryQueryHeight(binary_query->right_query->bin); + } + return left_height > right_height ? left_height + 1 : right_height + 1; +} + +bool +ValidateBinaryQuery(BinaryQueryPtr& binary_query) { + // Only for one layer BooleanQuery + uint64_t height = BinaryQueryHeight(binary_query); + return height > 1 && height < 4; +} + +} // namespace query +} // namespace milvus diff --git a/core/src/query/BinaryQuery.h b/core/src/query/BinaryQuery.h new file mode 100644 index 0000000000..5c296338ce --- /dev/null +++ b/core/src/query/BinaryQuery.h @@ -0,0 +1,38 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include + +#include "BooleanQuery.h" + +namespace milvus { +namespace query { + +BinaryQueryPtr +ConstructBinTree(std::vector clauses, QueryRelation relation, uint64_t idx); + +Status +ConstructLeafBinTree(std::vector leaf_clauses, BinaryQueryPtr binary_query, uint64_t idx); + +Status +GenBinaryQuery(BooleanQueryPtr clause, BinaryQueryPtr& binary_query); + +uint64_t +BinaryQueryHeight(BinaryQueryPtr& binary_query); + +bool +ValidateBinaryQuery(BinaryQueryPtr& binary_query); + +} // namespace query +} // namespace milvus diff --git a/core/src/query/BooleanQuery.h b/core/src/query/BooleanQuery.h new file mode 100644 index 0000000000..e5304aad11 --- /dev/null +++ b/core/src/query/BooleanQuery.h @@ -0,0 +1,87 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include + +#include "GeneralQuery.h" +#include "utils/Status.h" + +namespace milvus { +namespace query { + +enum class Occur { + INVALID = 0, + MUST, + MUST_NOT, + SHOULD, +}; + +class BooleanQuery { + public: + BooleanQuery() { + } + + explicit BooleanQuery(Occur occur) : occur_(occur) { + } + + Occur + getOccur() { + return occur_; + } + + void + SetOccur(Occur occur) { + occur_ = occur; + } + + void + AddBooleanQuery(std::shared_ptr boolean_clause) { + boolean_clauses_.emplace_back(boolean_clause); + } + + void + AddLeafQuery(LeafQueryPtr leaf_query) { + leaf_queries_.emplace_back(leaf_query); + } + + void + SetLeafQuery(std::vector leaf_queries) { + leaf_queries_ = leaf_queries; + } + + std::vector> + getBooleanQuerys() { + return boolean_clauses_; + } + + BinaryQueryPtr& + getBinaryQuery() { + return binary_query_; + } + + std::vector& + getLeafQueries() { + return leaf_queries_; + } + + private: + Occur occur_ = Occur::INVALID; + std::vector> boolean_clauses_; + std::vector leaf_queries_; + BinaryQueryPtr binary_query_ = std::make_shared(); +}; +using BooleanQueryPtr = std::shared_ptr; + +} // namespace query +} // namespace milvus diff --git a/core/src/query/GeneralQuery.h b/core/src/query/GeneralQuery.h new file mode 100644 index 0000000000..604ed1c8b3 --- /dev/null +++ b/core/src/query/GeneralQuery.h @@ -0,0 +1,107 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include +#include "utils/Json.h" + +namespace milvus { +namespace query { + +enum class CompareOperator { + LT = 0, + LTE, + EQ, + GT, + GTE, + NE, +}; + +enum class QueryRelation { + INVALID = 0, + R1, + R2, + R3, + R4, + AND, + OR, +}; + +struct QueryColumn { + std::string name; + std::string column_value; +}; + +struct TermQuery { + std::string field_name; + std::vector field_value; + float boost; +}; +using TermQueryPtr = std::shared_ptr; + +struct CompareExpr { + CompareOperator compare_operator; + std::string operand; +}; + +struct RangeQuery { + std::string field_name; + std::vector compare_expr; + float boost; +}; +using RangeQueryPtr = std::shared_ptr; + +struct VectorRecord { + std::vector float_data; + std::vector binary_data; +}; + +struct VectorQuery { + std::string field_name; + milvus::json extra_params; + int64_t topk; + float boost; + VectorRecord query_vector; +}; +using VectorQueryPtr = std::shared_ptr; + +struct LeafQuery; +using LeafQueryPtr = std::shared_ptr; + +struct BinaryQuery; +using BinaryQueryPtr = std::shared_ptr; + +struct GeneralQuery { + LeafQueryPtr leaf; + BinaryQueryPtr bin = std::make_shared(); +}; +using GeneralQueryPtr = std::shared_ptr; + +struct LeafQuery { + TermQueryPtr term_query; + RangeQueryPtr range_query; + VectorQueryPtr vector_query; + float query_boost; +}; + +struct BinaryQuery { + GeneralQueryPtr left_query; + GeneralQueryPtr right_query; + QueryRelation relation; + float query_boost; +}; + +} // namespace query +} // namespace milvus diff --git a/core/src/scheduler/job/SearchJob.cpp b/core/src/scheduler/job/SearchJob.cpp index 977ea3a31f..6f1e446a95 100644 --- a/core/src/scheduler/job/SearchJob.cpp +++ b/core/src/scheduler/job/SearchJob.cpp @@ -21,6 +21,12 @@ SearchJob::SearchJob(const std::shared_ptr& context, uint64_t t : Job(JobType::SEARCH), context_(context), topk_(topk), extra_params_(extra_params), vectors_(vectors) { } +SearchJob::SearchJob(const std::shared_ptr& context, milvus::query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, + const engine::VectorsData& vectors) + : Job(JobType::SEARCH), context_(context), general_query_(general_query), attr_type_(attr_type), vectors_(vectors) { +} + bool SearchJob::AddIndexFile(const SegmentSchemaPtr& index_file) { std::unique_lock lock(mutex_); diff --git a/core/src/scheduler/job/SearchJob.h b/core/src/scheduler/job/SearchJob.h index baf24fe4bb..429acd1840 100644 --- a/core/src/scheduler/job/SearchJob.h +++ b/core/src/scheduler/job/SearchJob.h @@ -26,6 +26,8 @@ #include "db/Types.h" #include "db/meta/MetaTypes.h" +#include "query/GeneralQuery.h" + #include "server/context/Context.h" namespace milvus { @@ -43,6 +45,10 @@ class SearchJob : public Job { SearchJob(const std::shared_ptr& context, uint64_t topk, const milvus::json& extra_params, const engine::VectorsData& vectors); + SearchJob(const std::shared_ptr& context, query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, + const engine::VectorsData& vectorsData); + public: bool AddIndexFile(const SegmentSchemaPtr& index_file); @@ -99,6 +105,21 @@ class SearchJob : public Job { return mutex_; } + query::GeneralQueryPtr + general_query() { + return general_query_; + } + + std::unordered_map& + attr_type() { + return attr_type_; + } + + uint64_t& + vector_count() { + return vector_count_; + } + private: const std::shared_ptr context_; @@ -113,6 +134,10 @@ class SearchJob : public Job { ResultDistances result_distances_; Status status_; + query::GeneralQueryPtr general_query_; + std::unordered_map attr_type_; + uint64_t vector_count_; + std::mutex mutex_; std::condition_variable cv_; }; diff --git a/core/src/scheduler/task/SearchTask.cpp b/core/src/scheduler/task/SearchTask.cpp index fdb7f9f765..f07a132306 100644 --- a/core/src/scheduler/task/SearchTask.cpp +++ b/core/src/scheduler/task/SearchTask.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include "db/Utils.h" @@ -123,6 +124,21 @@ XSearchTask::XSearchTask(const std::shared_ptr& context, Segmen if (!file_->index_params_.empty()) { json_params = milvus::json::parse(file_->index_params_); } + // if (auto job = job_.lock()) { + // auto search_job = std::static_pointer_cast(job); + // query::GeneralQueryPtr general_query = search_job->general_query(); + // if (general_query != nullptr) { + // std::unordered_map types; + // auto attr_type = search_job->attr_type(); + // auto type_it = attr_type.begin(); + // for (; type_it != attr_type.end(); type_it++) { + // types.insert(std::make_pair(type_it->first, (engine::DataType)(type_it->second))); + // } + // index_engine_ = + // EngineFactory::Build(file_->dimension_, file_->location_, engine_type, + // (MetricType)file_->metric_type_, types, json_params); + // } + // } index_engine_ = EngineFactory::Build(file_->dimension_, file_->location_, engine_type, (MetricType)file_->metric_type_, json_params); } @@ -222,8 +238,11 @@ XSearchTask::Execute() { } // step 1: allocate memory + query::GeneralQueryPtr general_query = search_job->general_query(); + uint64_t nq = search_job->nq(); uint64_t topk = search_job->topk(); + const milvus::json& extra_params = search_job->extra_params(); const engine::VectorsData& vectors = search_job->vectors(); @@ -241,6 +260,46 @@ XSearchTask::Execute() { hybrid = true; } Status s; + if (general_query != nullptr) { + std::unordered_map types; + auto attr_type = search_job->attr_type(); + auto type_it = attr_type.begin(); + for (; type_it != attr_type.end(); type_it++) { + types.insert(std::make_pair(type_it->first, (engine::DataType)(type_it->second))); + } + faiss::ConcurrentBitsetPtr bitset; + s = index_engine_->ExecBinaryQuery(general_query, bitset, types, nq, topk, output_distance, output_ids); + + if (!s.ok()) { + search_job->GetStatus() = s; + search_job->SearchDone(index_id_); + return; + } + + auto spec_k = file_->row_count_ < topk ? file_->row_count_ : topk; + if (spec_k == 0) { + LOG_ENGINE_WARNING_ << "Searching in an empty file. file location = " << file_->location_; + } + + { + std::unique_lock lock(search_job->mutex()); + + if (search_job->GetResultIds().size() > spec_k) { + if (search_job->GetResultIds().front() == -1) { + // initialized results set + search_job->GetResultIds().resize(spec_k * nq); + search_job->GetResultDistances().resize(spec_k * nq); + } + } + + search_job->vector_count() = nq; + XSearchTask::MergeTopkToResultSet(output_ids, output_distance, spec_k, nq, topk, ascending_reduce, + search_job->GetResultIds(), search_job->GetResultDistances()); + } + search_job->SearchDone(index_id_); + index_engine_ = nullptr; + return; + } if (!vectors.float_data_.empty()) { s = index_engine_->Search(nq, vectors.float_data_.data(), topk, extra_params, output_distance.data(), output_ids.data(), hybrid); diff --git a/core/src/search/Task.cpp b/core/src/search/Task.cpp new file mode 100644 index 0000000000..58adeeb358 --- /dev/null +++ b/core/src/search/Task.cpp @@ -0,0 +1,223 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. +#if 0 +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "db/Utils.h" +#include "db/engine/EngineFactory.h" +#include "search/Task.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" + +namespace milvus { +namespace search { + +Task::Task(const std::shared_ptr& context, SegmentSchemaPtr& file, + milvus::query::GeneralQueryPtr general_query, std::unordered_map& attr_type, + context::HybridSearchContextPtr hybrid_search_context) + : context_(context), + file_(file), + general_query_(general_query), + attr_type_(attr_type), + hybrid_search_context_(hybrid_search_context) { + if (file_) { + // distance -- value 0 means two vectors equal, ascending reduce, L2/HAMMING/JACCARD/TONIMOTO ... + // similarity -- infinity value means two vectors equal, descending reduce, IP + if (file_->metric_type_ == static_cast(engine::MetricType::IP) && + file_->engine_type_ != static_cast(engine::EngineType::FAISS_PQ)) { + ascending_reduce = false; + } + + engine::EngineType engine_type; + if (file->file_type_ == engine::meta::SegmentSchema::FILE_TYPE::RAW || + file->file_type_ == engine::meta::SegmentSchema::FILE_TYPE::TO_INDEX || + file->file_type_ == engine::meta::SegmentSchema::FILE_TYPE::BACKUP) { + engine_type = engine::utils::IsBinaryMetricType(file->metric_type_) ? engine::EngineType::FAISS_BIN_IDMAP + : engine::EngineType::FAISS_IDMAP; + } else { + engine_type = (engine::EngineType)file->engine_type_; + } + + milvus::json json_params; + if (!file_->index_params_.empty()) { + json_params = milvus::json::parse(file_->index_params_); + } + + index_engine_ = engine::EngineFactory::Build(file_->dimension_, file_->location_, engine_type, + (engine::MetricType)file_->metric_type_, json_params); + } +} + +void +Task::Load() { + auto load_ctx = context_->Follower("XSearchTask::Load " + std::to_string(file_->id_)); + + Status stat = Status::OK(); + std::string error_msg; + std::string type_str; + + try { + stat = index_engine_->Load(); + type_str = "IDSK2CPU"; + } catch (std::exception& ex) { + // typical error: out of disk space or permition denied + error_msg = "Failed to load index file: " + std::string(ex.what()); + stat = Status(SERVER_UNEXPECTED_ERROR, error_msg); + } + + if (!stat.ok()) { + return; + } +} + +void +Task::Execute() { + auto execute_ctx = context_->Follower("XSearchTask::Execute " + std::to_string(index_id_)); + + if (index_engine_ == nullptr) { + return; + } + + TimeRecorder rc("DoSearch file id:" + std::to_string(index_id_)); + + std::vector output_ids; + std::vector output_distance; + + // step 1: allocate memory + + try { + // step 2: search + Status s; + if (general_query_ != nullptr) { + faiss::ConcurrentBitsetPtr bitset; + uint64_t nq, topk; + s = index_engine_->ExecBinaryQuery(general_query_, bitset, attr_type_, nq, topk, output_distance, + output_ids); + + if (!s.ok()) { + return; + } + + auto spec_k = file_->row_count_ < topk ? file_->row_count_ : topk; + if (spec_k == 0) { + ENGINE_LOG_WARNING << "Searching in an empty file. file location = " << file_->location_; + } + + { + if (result_ids_.size() > spec_k) { + if (result_ids_.front() == -1) { + result_ids_.resize(spec_k * nq); + result_distances_.resize(spec_k * nq); + } + } + Task::MergeTopkToResultSet(output_ids, output_distance, spec_k, nq, topk, ascending_reduce, result_ids_, + result_distances_); + } + index_engine_ = nullptr; + execute_ctx->GetTraceContext()->GetSpan()->Finish(); + return; + } + + if (!s.ok()) { + return; + } + } catch (std::exception& ex) { + ENGINE_LOG_ERROR << "SearchTask encounter exception: " << ex.what(); + // search_job->IndexSearchDone(index_id_);//mark as done avoid dead lock, even search failed + } + + rc.ElapseFromBegin("totally cost"); + + // release index in resource + index_engine_ = nullptr; + + execute_ctx->GetTraceContext()->GetSpan()->Finish(); +} + +void +Task::MergeTopkToResultSet(const milvus::search::ResultIds& src_ids, + const milvus::search::ResultDistances& src_distances, size_t src_k, size_t nq, size_t topk, + bool ascending, milvus::search::ResultIds& tar_ids, + milvus::search::ResultDistances& tar_distances) { + if (src_ids.empty()) { + return; + } + + size_t tar_k = tar_ids.size() / nq; + size_t buf_k = std::min(topk, src_k + tar_k); + + ResultIds buf_ids(nq * buf_k, -1); + ResultDistances buf_distances(nq * buf_k, 0.0); + + for (uint64_t i = 0; i < nq; i++) { + size_t buf_k_j = 0, src_k_j = 0, tar_k_j = 0; + size_t buf_idx, src_idx, tar_idx; + + size_t buf_k_multi_i = buf_k * i; + size_t src_k_multi_i = topk * i; + size_t tar_k_multi_i = tar_k * i; + + while (buf_k_j < buf_k && src_k_j < src_k && tar_k_j < tar_k) { + src_idx = src_k_multi_i + src_k_j; + tar_idx = tar_k_multi_i + tar_k_j; + buf_idx = buf_k_multi_i + buf_k_j; + + if ((tar_ids[tar_idx] == -1) || // initialized value + (ascending && src_distances[src_idx] < tar_distances[tar_idx]) || + (!ascending && src_distances[src_idx] > tar_distances[tar_idx])) { + buf_ids[buf_idx] = src_ids[src_idx]; + buf_distances[buf_idx] = src_distances[src_idx]; + src_k_j++; + } else { + buf_ids[buf_idx] = tar_ids[tar_idx]; + buf_distances[buf_idx] = tar_distances[tar_idx]; + tar_k_j++; + } + buf_k_j++; + } + + if (buf_k_j < buf_k) { + if (src_k_j < src_k) { + while (buf_k_j < buf_k && src_k_j < src_k) { + buf_idx = buf_k_multi_i + buf_k_j; + src_idx = src_k_multi_i + src_k_j; + buf_ids[buf_idx] = src_ids[src_idx]; + buf_distances[buf_idx] = src_distances[src_idx]; + src_k_j++; + buf_k_j++; + } + } else { + while (buf_k_j < buf_k && tar_k_j < tar_k) { + buf_idx = buf_k_multi_i + buf_k_j; + tar_idx = tar_k_multi_i + tar_k_j; + buf_ids[buf_idx] = tar_ids[tar_idx]; + buf_distances[buf_idx] = tar_distances[tar_idx]; + tar_k_j++; + buf_k_j++; + } + } + } + } + tar_ids.swap(buf_ids); + tar_distances.swap(buf_distances); +} + +} // namespace search +} // namespace milvus + +#endif diff --git a/core/src/search/Task.h b/core/src/search/Task.h new file mode 100644 index 0000000000..8bec31ac1a --- /dev/null +++ b/core/src/search/Task.h @@ -0,0 +1,93 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. +#if 0 + +#pragma once + +#include +#include +#include +#include +#include + +#include "context/HybridSearchContext.h" +#include "db/Types.h" +#include "db/engine/ExecutionEngine.h" +#include "db/meta/MetaTypes.h" +#include "server/context/Context.h" +#include "utils/Status.h" + +namespace milvus { + +namespace context { +struct HybridSearchContext; +using HybridSearchContextPtr = std::shared_ptr; +} // namespace context + +namespace search { + +using SegmentSchemaPtr = engine::meta::SegmentSchemaPtr; + +using Id2IndexMap = std::unordered_map; + +using ResultIds = engine::ResultIds; +using ResultDistances = engine::ResultDistances; + +class Task { + public: + explicit Task(const std::shared_ptr& context, SegmentSchemaPtr& file, + query::GeneralQueryPtr general_query, std::unordered_map& attr_type, + context::HybridSearchContextPtr hybrid_search_context); + + void + Load(); + + void + Execute(); + + public: + static void + MergeTopkToResultSet(const ResultIds& src_ids, const ResultDistances& src_distances, size_t src_k, size_t nq, + size_t topk, bool ascending, ResultIds& tar_ids, ResultDistances& tar_distances); + + const std::string& + GetLocation() const; + + size_t + GetIndexId() const; + + public: + const std::shared_ptr context_; + + SegmentSchemaPtr file_; + + size_t index_id_ = 0; + int index_type_ = 0; + engine::ExecutionEnginePtr index_engine_ = nullptr; + + // distance -- value 0 means two vectors equal, ascending reduce, L2/HAMMING/JACCARD/TONIMOTO ... + // similarity -- infinity value means two vectors equal, descending reduce, IP + bool ascending_reduce = true; + + query::GeneralQueryPtr general_query_; + std::unordered_map attr_type_; + context::HybridSearchContextPtr hybrid_search_context_; + + ResultIds result_ids_; + ResultDistances result_distances_; +}; + +using TaskPtr = std::shared_ptr; + +} // namespace search +} // namespace milvus + +#endif diff --git a/core/src/search/TaskInst.cpp b/core/src/search/TaskInst.cpp new file mode 100644 index 0000000000..00e28bc05f --- /dev/null +++ b/core/src/search/TaskInst.cpp @@ -0,0 +1,116 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. +#if 0 + +#pragma once + +#include +#include +#include +#include + +#include "search/TaskInst.h" + +namespace milvus { +namespace search { + +void +TaskInst::Start() { + running_ = true; + load_thread_ = std::make_shared(&TaskInst::StartLoadTask, this); + exec_thread_ = std::make_shared(&TaskInst::StartExecuteTask, this); +} + +void +TaskInst::Stop() { + running_ = false; + StopExecuteTask(); + StopLoadTask(); +} + +std::queue& +TaskInst::load_queue() { + return load_queue_; +} + +std::queue& +TaskInst::exec_queue() { + return exec_queue_; +} + +std::condition_variable& +TaskInst::load_cv() { + return load_cv_; +} + +std::condition_variable& +TaskInst::exec_cv() { + return exec_cv_; +} + +void +TaskInst::StartLoadTask() { + while (running_) { + std::unique_lock lock(load_mutex_); + load_cv_.wait(lock, [this] { return !load_queue_.empty(); }); + while (!load_queue_.empty()) { + auto task = load_queue_.front(); + task->Load(); + load_queue_.pop(); + exec_queue_.push(task); + exec_cv_.notify_one(); + } + } +} + +void +TaskInst::StartExecuteTask() { + while (running_) { + std::unique_lock lock(exec_mutex_); + exec_cv_.wait(lock, [this] { return !exec_queue_.empty(); }); + while (!exec_queue_.empty()) { + auto task = exec_queue_.front(); + task->Execute(); + exec_queue_.pop(); + } + } +} + +void +TaskInst::StopLoadTask() { + { + std::lock_guard lock(load_mutex_); + load_queue_.push(nullptr); + load_cv_.notify_one(); + if (load_thread_->joinable()) { + load_thread_->join(); + } + load_thread_ = nullptr; + } +} + +void +TaskInst::StopExecuteTask() { + { + std::lock_guard lock(exec_mutex_); + exec_queue_.push(nullptr); + exec_cv_.notify_one(); + if (exec_thread_->joinable()) { + exec_thread_->join(); + } + exec_thread_ = nullptr; + } +} + +} // namespace search +} // namespace milvus + +#endif diff --git a/core/src/search/TaskInst.h b/core/src/search/TaskInst.h new file mode 100644 index 0000000000..2331436ce7 --- /dev/null +++ b/core/src/search/TaskInst.h @@ -0,0 +1,82 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. +#if 0 + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "Task.h" + +namespace milvus { +namespace search { + +class TaskInst { + public: + static TaskInst& + GetInstance() { + static TaskInst instance; + return instance; + } + + void + Start(); + void + Stop(); + + std::queue& + load_queue(); + std::queue& + exec_queue(); + + std::condition_variable& + load_cv(); + std::condition_variable& + exec_cv(); + + private: + TaskInst() = default; + ~TaskInst() = default; + + void + StartLoadTask(); + void + StartExecuteTask(); + void + StopLoadTask(); + void + StopExecuteTask(); + + private: + bool running_; + + std::shared_ptr load_thread_; + std::shared_ptr exec_thread_; + + std::queue load_queue_; + std::queue exec_queue_; + + std::condition_variable load_cv_; + std::condition_variable exec_cv_; + std::mutex exec_mutex_; + std::mutex load_mutex_; +}; + +} // namespace search +} // namespace milvus + +#endif diff --git a/core/src/segment/Attr.cpp b/core/src/segment/Attr.cpp new file mode 100644 index 0000000000..fd5657daa3 --- /dev/null +++ b/core/src/segment/Attr.cpp @@ -0,0 +1,168 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include "Vectors.h" +#include "segment/Attr.h" +#include "utils/Log.h" + +namespace milvus { +namespace segment { + +Attr::Attr(const std::vector& data, size_t nbytes, const std::vector uids, const std::string& name) + : data_(std::move(data)), nbytes_(nbytes), uids_(std::move(uids)), name_(name) { +} + +void +Attr::AddAttr(const std::vector& data, size_t nbytes) { + data_.reserve(data_.size() + data.size()); + data_.insert(data_.end(), std::make_move_iterator(data.begin()), std::make_move_iterator(data.end())); + nbytes_ += nbytes; +} + +void +Attr::AddUids(const std::vector& uids) { + uids_.reserve(uids_.size() + uids.size()); + uids_.insert(uids_.end(), std::make_move_iterator(uids.begin()), std::make_move_iterator(uids.end())); +} + +void +Attr::SetName(const std::string& name) { + name_ = name; +} + +const std::vector& +Attr::GetData() const { + return data_; +} + +const std::string& +Attr::GetName() const { + return name_; +} + +const std::string& +Attr::GetCollectionId() { + return collection_id_; +} + +const size_t& +Attr::GetNbytes() const { + return nbytes_; +} + +const std::vector& +Attr::GetUids() const { + return uids_; +} + +size_t +Attr::GetCount() const { + return uids_.size(); +} + +size_t +Attr::GetCodeLength() const { + return uids_.size() == 0 ? 0 : nbytes_ / uids_.size(); +} + +void +Attr::Erase(int32_t offset) { + auto code_length = GetCodeLength(); + if (code_length != 0) { + auto step = offset * code_length; + data_.erase(data_.begin() + step, data_.begin() + step + code_length); + uids_.erase(uids_.begin() + offset, uids_.begin() + offset + 1); + } +} + +void +Attr::Erase(std::vector& offsets) { + if (offsets.empty()) { + return; + } + + // Sort and remove duplicates + auto start = std::chrono::high_resolution_clock::now(); + + std::sort(offsets.begin(), offsets.end()); + + auto end = std::chrono::high_resolution_clock::now(); + std::chrono::duration diff = end - start; + LOG_ENGINE_DEBUG_ << "Sorting " << offsets.size() << " offsets to delete took " << diff.count() << " s"; + + start = std::chrono::high_resolution_clock::now(); + + offsets.erase(std::unique(offsets.begin(), offsets.end()), offsets.end()); + + end = std::chrono::high_resolution_clock::now(); + diff = end - start; + LOG_ENGINE_DEBUG_ << "Deduplicating " << offsets.size() << " offsets to delete took " << diff.count() << " s"; + + LOG_ENGINE_DEBUG_ << "Attributes begin erasing..."; + + size_t new_size = uids_.size() - offsets.size(); + std::vector new_uids(new_size); + auto code_length = GetCodeLength(); + std::vector new_data(new_size * code_length); + + auto count = 0; + auto skip = offsets.cbegin(); + auto loop_size = uids_.size(); + + for (size_t i = 0; i < loop_size;) { + while (skip != offsets.cend() && i == *skip) { + ++i; + ++skip; + } + + if (i == loop_size) { + break; + } + + new_uids[count] = uids_[i]; + + for (size_t j = 0; j < code_length; ++j) { + new_data[count * code_length + j] = data_[i * code_length + j]; + } + + ++count; + ++i; + } + + data_.clear(); + uids_.clear(); + data_.swap(new_data); + uids_.swap(new_uids); + + end = std::chrono::high_resolution_clock::now(); + diff = end - start; + LOG_ENGINE_DEBUG_ << "Erasing " << offsets.size() << " vectors out of " << loop_size << " vectors took " + << diff.count() << " s"; +} + +} // namespace segment +} // namespace milvus diff --git a/core/src/segment/Attr.h b/core/src/segment/Attr.h index 8956a7a37a..506e50f33b 100644 --- a/core/src/segment/Attr.h +++ b/core/src/segment/Attr.h @@ -18,13 +18,53 @@ #pragma once #include +#include +#include namespace milvus { namespace segment { class Attr { public: - Attr(void* data, size_t nbytes); + Attr(const std::vector& data, size_t nbytes, const std::vector uids, const std::string& name); + + Attr(); + + void + AddAttr(const std::vector& data, size_t nbytes); + + void + AddUids(const std::vector& uids); + + void + SetName(const std::string& name); + + const std::vector& + GetData() const; + + const std::string& + GetName() const; + + const std::string& + GetCollectionId(); + + const size_t& + GetNbytes() const; + + const std::vector& + GetUids() const; + + size_t + GetCount() const; + + size_t + GetCodeLength() const; + + void + Erase(int32_t offset); + + void + Erase(std::vector& offsets); // No copy and move Attr(const Attr&) = delete; @@ -36,8 +76,11 @@ class Attr { operator=(Attr&&) = delete; private: - void* data_; + std::vector data_; size_t nbytes_; + std::vector uids_; + std::string name_; + std::string collection_id_; }; using AttrPtr = std::shared_ptr; diff --git a/core/src/segment/Attrs.h b/core/src/segment/Attrs.h index 07e9ce0ed5..26d9507c2e 100644 --- a/core/src/segment/Attrs.h +++ b/core/src/segment/Attrs.h @@ -17,6 +17,7 @@ #pragma once +#include #include #include @@ -26,8 +27,12 @@ namespace milvus { namespace segment { struct Attrs { + // Attrs() = default; + std::unordered_map attrs; }; +using AttrsPtr = std::shared_ptr; + } // namespace segment } // namespace milvus diff --git a/core/src/segment/SegmentReader.cpp b/core/src/segment/SegmentReader.cpp index fe0bb62e7f..d717bf863b 100644 --- a/core/src/segment/SegmentReader.cpp +++ b/core/src/segment/SegmentReader.cpp @@ -50,6 +50,7 @@ SegmentReader::Load() { try { fs_ptr_->operation_ptr_->CreateDirectory(); default_codec.GetVectorsFormat()->read(fs_ptr_, segment_ptr_->vectors_ptr_); + default_codec.GetAttrsFormat()->read(fs_ptr_, segment_ptr_->attrs_ptr_); // default_codec.GetVectorIndexFormat()->read(fs_ptr_, segment_ptr_->vector_index_ptr_); default_codec.GetDeletedDocsFormat()->read(fs_ptr_, segment_ptr_->deleted_docs_ptr_); } catch (std::exception& e) { diff --git a/core/src/segment/SegmentWriter.cpp b/core/src/segment/SegmentWriter.cpp index e774f67347..889b33f48a 100644 --- a/core/src/segment/SegmentWriter.cpp +++ b/core/src/segment/SegmentWriter.cpp @@ -19,6 +19,7 @@ #include #include +#include #include "SegmentReader.h" #include "Vectors.h" @@ -50,6 +51,26 @@ SegmentWriter::AddVectors(const std::string& name, const std::vector& d return Status::OK(); } +Status +SegmentWriter::AddAttrs(const std::string& name, const std::unordered_map& attr_nbytes, + const std::unordered_map>& attr_data, + const std::vector& uids) { + auto attr_data_it = attr_data.begin(); + auto attrs = segment_ptr_->attrs_ptr_->attrs; + for (; attr_data_it != attr_data.end(); ++attr_data_it) { + if (attrs.find(attr_data_it->first) != attrs.end()) { + segment_ptr_->attrs_ptr_->attrs.at(attr_data_it->first) + ->AddAttr(attr_data_it->second, attr_nbytes.at(attr_data_it->first)); + segment_ptr_->attrs_ptr_->attrs.at(attr_data_it->first)->AddUids(uids); + } else { + AttrPtr attr = std::make_shared(attr_data_it->second, attr_nbytes.at(attr_data_it->first), uids, + attr_data_it->first); + segment_ptr_->attrs_ptr_->attrs.insert(std::make_pair(attr_data_it->first, attr)); + } + } + return Status::OK(); +} + Status SegmentWriter::SetVectorIndex(const milvus::knowhere::VecIndexPtr& index) { segment_ptr_->vector_index_ptr_->SetVectorIndex(index); @@ -74,6 +95,11 @@ SegmentWriter::Serialize() { return status; } + status = WriteAttrs(); + if (!status.ok()) { + return status; + } + recorder.RecordSection("Writing vectors and uids done"); // Write an empty deleted doc @@ -98,6 +124,20 @@ SegmentWriter::WriteVectors() { return Status::OK(); } +Status +SegmentWriter::WriteAttrs() { + codec::DefaultCodec default_codec; + try { + fs_ptr_->operation_ptr_->CreateDirectory(); + default_codec.GetAttrsFormat()->write(fs_ptr_, segment_ptr_->attrs_ptr_); + } catch (std::exception& e) { + std::string err_msg = "Failed to write vectors: " + std::string(e.what()); + LOG_ENGINE_ERROR_ << err_msg; + return Status(SERVER_WRITE_ERROR, err_msg); + } + return Status::OK(); +} + Status SegmentWriter::WriteVectorIndex(const std::string& location) { codec::DefaultCodec default_codec; @@ -238,6 +278,22 @@ SegmentWriter::Merge(const std::string& dir_to_merge, const std::string& name) { auto rows = segment_to_merge->vectors_ptr_->GetCount(); recorder.RecordSection("Adding " + std::to_string(rows) + " vectors and uids"); + std::unordered_map attr_nbytes; + std::unordered_map> attr_data; + auto attr_it = segment_to_merge->attrs_ptr_->attrs.begin(); + for (; attr_it != segment_to_merge->attrs_ptr_->attrs.end(); attr_it++) { + attr_nbytes.insert(std::make_pair(attr_it->first, attr_it->second->GetNbytes())); + attr_data.insert(std::make_pair(attr_it->first, attr_it->second->GetData())); + + if (segment_to_merge->deleted_docs_ptr_ != nullptr) { + auto offsets_to_delete = segment_to_merge->deleted_docs_ptr_->GetDeletedDocs(); + + // Erase from field data + attr_it->second->Erase(offsets_to_delete); + } + } + AddAttrs(name, attr_nbytes, attr_data, segment_to_merge->vectors_ptr_->GetUids()); + LOG_ENGINE_DEBUG_ << "Merging completed from " << dir_to_merge << " to " << fs_ptr_->operation_ptr_->GetDirectory(); return Status::OK(); diff --git a/core/src/segment/SegmentWriter.h b/core/src/segment/SegmentWriter.h index cf35fab9ca..5c45e782c1 100644 --- a/core/src/segment/SegmentWriter.h +++ b/core/src/segment/SegmentWriter.h @@ -19,6 +19,7 @@ #include #include +#include #include #include "segment/Types.h" @@ -35,6 +36,10 @@ class SegmentWriter { Status AddVectors(const std::string& name, const std::vector& data, const std::vector& uids); + Status + AddAttrs(const std::string& name, const std::unordered_map& attr_nbytes, + const std::unordered_map>& attr_data, const std::vector& uids); + Status SetVectorIndex(const knowhere::VecIndexPtr& index); @@ -69,6 +74,9 @@ class SegmentWriter { Status WriteVectors(); + Status + WriteAttrs(); + Status WriteBloomFilter(); diff --git a/core/src/segment/Types.h b/core/src/segment/Types.h index 10b3bd3dd7..dc0982fced 100644 --- a/core/src/segment/Types.h +++ b/core/src/segment/Types.h @@ -19,6 +19,7 @@ #include +#include "segment/Attrs.h" #include "segment/DeletedDocs.h" #include "segment/IdBloomFilter.h" #include "segment/VectorIndex.h" @@ -31,6 +32,7 @@ typedef int64_t doc_id_t; struct Segment { VectorsPtr vectors_ptr_ = std::make_shared(); + AttrsPtr attrs_ptr_ = std::make_shared(); VectorIndexPtr vector_index_ptr_ = std::make_shared(); DeletedDocsPtr deleted_docs_ptr_ = nullptr; IdBloomFilterPtr id_bloom_filter_ptr_ = nullptr; diff --git a/core/src/server/Server.cpp b/core/src/server/Server.cpp index aac78f84e2..3a6c99ff45 100644 --- a/core/src/server/Server.cpp +++ b/core/src/server/Server.cpp @@ -30,6 +30,8 @@ #include "utils/SignalUtil.h" #include "utils/TimeRecorder.h" +#include "search/TaskInst.h" + namespace milvus { namespace server { @@ -283,6 +285,8 @@ Server::StartService() { // goto FAIL; // } + // search::TaskInst::GetInstance().Start(); + return Status::OK(); FAIL: std::cerr << "Milvus initializes fail: " << stat.message() << std::endl; @@ -291,6 +295,7 @@ FAIL: void Server::StopService() { + // search::TaskInst::GetInstance().Stop(); // storage::S3ClientWrapper::GetInstance().StopService(); web::WebServer::GetInstance().Stop(); grpc::GrpcServer::GetInstance().Stop(); diff --git a/core/src/server/delivery/RequestHandler.cpp b/core/src/server/delivery/RequestHandler.cpp index 2fa8bec8dc..8db0197a1b 100644 --- a/core/src/server/delivery/RequestHandler.cpp +++ b/core/src/server/delivery/RequestHandler.cpp @@ -39,6 +39,10 @@ #include "server/delivery/request/ShowCollectionsRequest.h" #include "server/delivery/request/ShowPartitionsRequest.h" +#include "server/delivery/hybrid_request/CreateHybridCollectionRequest.h" +#include "server/delivery/hybrid_request/HybridSearchRequest.h" +#include "server/delivery/hybrid_request/InsertEntityRequest.h" + namespace milvus { namespace server { @@ -248,5 +252,48 @@ RequestHandler::Compact(const std::shared_ptr& context, const std::stri return request_ptr->status(); } +/*******************************************New Interface*********************************************/ + +Status +RequestHandler::CreateHybridCollection(const std::shared_ptr& context, const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_extra_params) { + BaseRequestPtr request_ptr = CreateHybridCollectionRequest::Create(context, collection_name, field_types, + vector_dimensions, field_extra_params); + + RequestScheduler::ExecRequest(request_ptr); + return request_ptr->status(); +} + +Status +RequestHandler::HasHybridCollection(const std::shared_ptr& context, std::string& collection_name, + bool& has_collection) { +} + +Status +RequestHandler::InsertEntity(const std::shared_ptr& context, const std::string& collection_name, + const std::string& partition_tag, + std::unordered_map>& field_values, + std::unordered_map& vector_datas) { + BaseRequestPtr request_ptr = + InsertEntityRequest::Create(context, collection_name, partition_tag, field_values, vector_datas); + + RequestScheduler::ExecRequest(request_ptr); + return request_ptr->status(); +} + +Status +RequestHandler::HybridSearch(const std::shared_ptr& context, + context::HybridSearchContextPtr hybrid_search_context, const std::string& collection_name, + std::vector& partition_list, milvus::query::GeneralQueryPtr& general_query, + TopKQueryResult& result) { + BaseRequestPtr request_ptr = HybridSearchRequest::Create(context, hybrid_search_context, collection_name, + partition_list, general_query, result); + RequestScheduler::ExecRequest(request_ptr); + + return request_ptr->status(); +} + } // namespace server } // namespace milvus diff --git a/core/src/server/delivery/RequestHandler.h b/core/src/server/delivery/RequestHandler.h index 8ff990d91b..62ef6b4898 100644 --- a/core/src/server/delivery/RequestHandler.h +++ b/core/src/server/delivery/RequestHandler.h @@ -13,9 +13,12 @@ #include #include +#include #include #include +#include "context/HybridSearchContext.h" +#include "query/BooleanQuery.h" #include "server/delivery/request/BaseRequest.h" #include "utils/Status.h" @@ -109,6 +112,31 @@ class RequestHandler { Status Compact(const std::shared_ptr& context, const std::string& collection_name); + + /*******************************************New Interface*********************************************/ + + Status + CreateHybridCollection(const std::shared_ptr& context, const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_extra_params); + + Status + HasHybridCollection(const std::shared_ptr& context, std::string& collection_name, bool& has_collection); + + Status + DropHybridCollection(const std::shared_ptr& context, std::string& collection_name); + + Status + InsertEntity(const std::shared_ptr& context, const std::string& collection_name, + const std::string& partition_tag, + std::unordered_map>& field_values, + std::unordered_map& vector_datas); + + Status + HybridSearch(const std::shared_ptr& context, context::HybridSearchContextPtr hybrid_search_context, + const std::string& collection_name, std::vector& partition_list, + query::GeneralQueryPtr& boolean_query, TopKQueryResult& result); }; } // namespace server diff --git a/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.cpp b/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.cpp new file mode 100644 index 0000000000..be4a271d8d --- /dev/null +++ b/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.cpp @@ -0,0 +1,102 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#include "server/delivery/hybrid_request/CreateHybridCollectionRequest.h" +#include "db/Utils.h" +#include "server/DBWrapper.h" +#include "server/delivery/request/BaseRequest.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +#include +#include +#include +#include +#include + +namespace milvus { +namespace server { + +CreateHybridCollectionRequest::CreateHybridCollectionRequest( + const std::shared_ptr& context, const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_params) + : BaseRequest(context, BaseRequest::kCreateHybridCollection), + collection_name_(collection_name), + field_types_(field_types), + vector_dimensions_(vector_dimensions), + field_params_(field_params) { +} + +BaseRequestPtr +CreateHybridCollectionRequest::Create(const std::shared_ptr& context, + const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_params) { + return std::shared_ptr( + new CreateHybridCollectionRequest(context, collection_name, field_types, vector_dimensions, field_params)); +} + +Status +CreateHybridCollectionRequest::OnExecute() { + std::string hdr = "CreateCollectionRequest(collection=" + collection_name_ + ")"; + TimeRecorderAuto rc(hdr); + + try { + // step 1: check arguments + auto status = ValidationUtil::ValidateCollectionName(collection_name_); + if (!status.ok()) { + return status; + } + + rc.RecordSection("check validation"); + + // step 2: construct collection schema and vector schema + engine::meta::CollectionSchema table_info; + engine::meta::hybrid::FieldsSchema fields_schema; + + auto size = field_types_.size(); + table_info.collection_id_ = collection_name_; + fields_schema.fields_schema_.resize(size + 1); + for (uint64_t i = 0; i < size; ++i) { + fields_schema.fields_schema_[i].collection_id_ = collection_name_; + fields_schema.fields_schema_[i].field_name_ = field_types_[i].first; + fields_schema.fields_schema_[i].field_type_ = (int32_t)field_types_[i].second; + fields_schema.fields_schema_[i].field_params_ = field_params_[i].second; + } + fields_schema.fields_schema_[size].collection_id_ = collection_name_; + fields_schema.fields_schema_[size].field_name_ = vector_dimensions_[0].first; + fields_schema.fields_schema_[size].field_type_ = (int32_t)engine::meta::hybrid::DataType::VECTOR; + + table_info.dimension_ = vector_dimensions_[0].second; + // TODO(yukun): check dimension, metric_type, and assign engine_type + + // step 3: create collection + status = DBWrapper::DB()->CreateHybridCollection(table_info, fields_schema); + if (!status.ok()) { + // collection could exist + if (status.code() == DB_ALREADY_EXIST) { + return Status(SERVER_INVALID_COLLECTION_NAME, status.message()); + } + return status; + } + } catch (std::exception& ex) { + return Status(SERVER_UNEXPECTED_ERROR, ex.what()); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.h b/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.h new file mode 100644 index 0000000000..f31caced38 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/CreateHybridCollectionRequest.h @@ -0,0 +1,50 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include + +#include "server/delivery/request/BaseRequest.h" + +namespace milvus { +namespace server { + +class CreateHybridCollectionRequest : public BaseRequest { + public: + static BaseRequestPtr + Create(const std::shared_ptr& context, const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_params); + + protected: + CreateHybridCollectionRequest(const std::shared_ptr& context, + const std::string& collection_name, + std::vector>& field_types, + std::vector>& vector_dimensions, + std::vector>& field_arams); + + Status + OnExecute() override; + + private: + const std::string collection_name_; + std::vector>& field_types_; + std::vector> vector_dimensions_; + std::vector>& field_params_; +}; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp b/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp new file mode 100644 index 0000000000..a392e9e6e6 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp @@ -0,0 +1,134 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#include "server/delivery/hybrid_request/HybridSearchRequest.h" +#include "db/Utils.h" +#include "server/DBWrapper.h" +#include "utils/CommonUtil.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +#include +#include +#include +#include +#include +#include +#ifdef MILVUS_ENABLE_PROFILING +#include +#endif + +namespace milvus { +namespace server { + +HybridSearchRequest::HybridSearchRequest(const std::shared_ptr& context, + context::HybridSearchContextPtr& hybrid_search_context, + const std::string& collection_name, std::vector& partition_list, + milvus::query::GeneralQueryPtr& general_query, TopKQueryResult& result) + : BaseRequest(context, BaseRequest::kHybridSearch), + hybrid_search_contxt_(hybrid_search_context), + collection_name_(collection_name), + partition_list_(partition_list), + general_query_(general_query), + result_(result) { +} + +BaseRequestPtr +HybridSearchRequest::Create(const std::shared_ptr& context, + context::HybridSearchContextPtr& hybrid_search_context, const std::string& collection_name, + std::vector& partition_list, milvus::query::GeneralQueryPtr& general_query, + TopKQueryResult& result) { + return std::shared_ptr(new HybridSearchRequest(context, hybrid_search_context, collection_name, + partition_list, general_query, result)); +} + +Status +HybridSearchRequest::OnExecute() { + try { + fiu_do_on("SearchRequest.OnExecute.throw_std_exception", throw std::exception()); + std::string hdr = "SearchRequest(table=" + collection_name_; + + TimeRecorder rc(hdr); + + // step 1: check table name + auto status = ValidationUtil::ValidateCollectionName(collection_name_); + if (!status.ok()) { + return status; + } + + // step 2: check table existence + // only process root table, ignore partition table + engine::meta::CollectionSchema collection_schema; + engine::meta::hybrid::FieldsSchema fields_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeHybridCollection(collection_schema, fields_schema); + fiu_do_on("SearchRequest.OnExecute.describe_table_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + if (!status.ok()) { + if (status.code() == DB_NOT_FOUND) { + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); + } else { + return status; + } + } else { + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); + } + } + + std::unordered_map attr_type; + for (uint64_t i = 0; i < fields_schema.fields_schema_.size(); ++i) { + attr_type.insert( + std::make_pair(fields_schema.fields_schema_[i].field_name_, + (engine::meta::hybrid::DataType)fields_schema.fields_schema_[i].field_type_)); + } + + engine::ResultIds result_ids; + engine::ResultDistances result_distances; + uint64_t nq; + + status = DBWrapper::DB()->HybridQuery(context_, collection_name_, partition_list_, hybrid_search_contxt_, + general_query_, attr_type, nq, result_ids, result_distances); + +#ifdef MILVUS_ENABLE_PROFILING + ProfilerStop(); +#endif + + fiu_do_on("SearchRequest.OnExecute.query_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + if (!status.ok()) { + return status; + } + fiu_do_on("SearchRequest.OnExecute.empty_result_ids", result_ids.clear()); + if (result_ids.empty()) { + return Status::OK(); // empty table + } + + auto post_query_ctx = context_->Child("Constructing result"); + + // step 7: construct result array + result_.row_num_ = nq; + result_.distance_list_ = result_distances; + result_.id_list_ = result_ids; + + post_query_ctx->GetTraceContext()->GetSpan()->Finish(); + + // step 8: print time cost percent + rc.RecordSection("construct result and send"); + rc.ElapseFromBegin("totally cost"); + } catch (std::exception& ex) { + return Status(SERVER_UNEXPECTED_ERROR, ex.what()); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/HybridSearchRequest.h b/core/src/server/delivery/hybrid_request/HybridSearchRequest.h new file mode 100644 index 0000000000..a0f91a50a5 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/HybridSearchRequest.h @@ -0,0 +1,50 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include "server/delivery/request/BaseRequest.h" + +#include +#include +#include +#include + +namespace milvus { +namespace server { + +class HybridSearchRequest : public BaseRequest { + public: + static BaseRequestPtr + Create(const std::shared_ptr& context, + context::HybridSearchContextPtr& hybrid_search_context, const std::string& collection_name, + std::vector& partition_list, milvus::query::GeneralQueryPtr& general_query, + TopKQueryResult& result); + + protected: + HybridSearchRequest(const std::shared_ptr& context, + context::HybridSearchContextPtr& hybrid_search_context, const std::string& collection_name, + std::vector& partition_list, milvus::query::GeneralQueryPtr& general_query, + TopKQueryResult& result); + + Status + OnExecute() override; + + private: + context::HybridSearchContextPtr hybrid_search_contxt_; + const std::string collection_name_; + std::vector& partition_list_; + milvus::query::GeneralQueryPtr& general_query_; + TopKQueryResult& result_; +}; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/InsertEntityRequest.cpp b/core/src/server/delivery/hybrid_request/InsertEntityRequest.cpp new file mode 100644 index 0000000000..46f99bf179 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/InsertEntityRequest.cpp @@ -0,0 +1,205 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#include "server/delivery/hybrid_request/InsertEntityRequest.h" +#include "db/Utils.h" +#include "server/DBWrapper.h" +#include "utils/CommonUtil.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +#include +#include +#include +#include +#include +#include +#ifdef MILVUS_ENABLE_PROFILING +#include +#endif + +namespace milvus { +namespace server { + +InsertEntityRequest::InsertEntityRequest(const std::shared_ptr& context, + const std::string& collection_name, const std::string& partition_tag, + std::unordered_map>& field_values, + std::unordered_map& vector_datas) + : BaseRequest(context, BaseRequest::kInsertEntity), + collection_name_(collection_name), + partition_tag_(partition_tag), + field_values_(field_values), + vector_datas_(vector_datas) { +} + +BaseRequestPtr +InsertEntityRequest::Create(const std::shared_ptr& context, const std::string& collection_name, + const std::string& partition_tag, + std::unordered_map>& field_values, + std::unordered_map& vector_datas) { + return std::shared_ptr( + new InsertEntityRequest(context, collection_name, partition_tag, field_values, vector_datas)); +} + +Status +InsertEntityRequest::OnExecute() { + try { + fiu_do_on("InsertEntityRequest.OnExecute.throw_std_exception", throw std::exception()); + std::string hdr = "InsertEntityRequest(table=" + collection_name_ + ", n=" + field_values_.begin()->first + + ", partition_tag=" + partition_tag_ + ")"; + TimeRecorder rc(hdr); + + // step 1: check arguments + auto status = ValidationUtil::ValidateCollectionName(collection_name_); + if (!status.ok()) { + return status; + } + + auto vector_datas_it = vector_datas_.begin(); + if (vector_datas_it->second.float_data_.empty() && vector_datas_it->second.binary_data_.empty()) { + return Status(SERVER_INVALID_ROWRECORD_ARRAY, + "The vector array is emp ty. Make sure you have entered vector records."); + } + + // step 2: check table existence + // only process root table, ignore partition table + engine::meta::CollectionSchema collection_schema; + engine::meta::hybrid::FieldsSchema fields_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeHybridCollection(collection_schema, fields_schema); + if (!status.ok()) { + if (status.code() == DB_NOT_FOUND) { + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); + } else { + return status; + } + } else { + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); + } + } + + std::unordered_map field_types; + auto size = fields_schema.fields_schema_.size(); + for (uint64_t i = 0; i < size; ++i) { + if (fields_schema.fields_schema_[i].field_type_ == (int32_t)engine::meta::hybrid::DataType::VECTOR) { + continue; + } + field_types.insert( + std::make_pair(fields_schema.fields_schema_[i].field_name_, + (engine::meta::hybrid::DataType)fields_schema.fields_schema_[i].field_type_)); + } + + // step 3: check table flag + // all user provide id, or all internal id + bool user_provide_ids = !vector_datas_it->second.id_array_.empty(); + fiu_do_on("InsertEntityRequest.OnExecute.illegal_vector_id", user_provide_ids = false; + collection_schema.flag_ = engine::meta::FLAG_MASK_HAS_USERID); + // user already provided id before, all insert action require user id + if ((collection_schema.flag_ & engine::meta::FLAG_MASK_HAS_USERID) != 0 && !user_provide_ids) { + return Status(SERVER_ILLEGAL_VECTOR_ID, + "Collection vector IDs are user-defined. Please provide IDs for all vectors of this table."); + } + + fiu_do_on("InsertRequest.OnExecute.illegal_vector_id2", user_provide_ids = true; + collection_schema.flag_ = engine::meta::FLAG_MASK_NO_USERID); + // user didn't provided id before, no need to provide user id + if ((collection_schema.flag_ & engine::meta::FLAG_MASK_NO_USERID) != 0 && user_provide_ids) { + return Status( + SERVER_ILLEGAL_VECTOR_ID, + "Table vector IDs are auto-generated. All vectors of this table must use auto-generated IDs."); + } + + rc.RecordSection("check validation"); + +#ifdef MILVUS_ENABLE_PROFILING + std::string fname = "/tmp/insert_" + CommonUtil::GetCurrentTimeStr() + ".profiling"; + ProfilerStart(fname.c_str()); +#endif + // step 4: some metric type doesn't support float vectors + + // TODO(yukun): check dimension and metric_type + // for (uint64_t i = 0; i (vector_datas_it->second.vector_count_); + + engine::Entity entity; + entity.entity_count_ = vector_datas_it->second.vector_count_; + + entity.attr_data_ = field_values_; + entity.vector_data_.insert(std::make_pair(vector_datas_it->first, vector_datas_it->second)); + + rc.RecordSection("prepare vectors data"); + status = DBWrapper::DB()->InsertEntities(collection_name_, partition_tag_, entity, field_types); + fiu_do_on("InsertRequest.OnExecute.insert_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + if (!status.ok()) { + return status; + } + vector_datas_it->second.id_array_ = entity.id_array_; + + // auto ids_size = vectors_data_.id_array_.size(); + // fiu_do_on("InsertRequest.OnExecute.invalid_ids_size", ids_size = vec_count - 1); + // if (ids_size != vec_count) { + // std::string msg = + // "Add " + std::to_string(vec_count) + " vectors but only return " + std::to_string(ids_size) + + // " id"; + // return Status(SERVER_ILLEGAL_VECTOR_ID, msg); + // } + + // step 6: update table flag + user_provide_ids ? collection_schema.flag_ |= engine::meta::FLAG_MASK_HAS_USERID + : collection_schema.flag_ |= engine::meta::FLAG_MASK_NO_USERID; + status = DBWrapper::DB()->UpdateCollectionFlag(collection_name_, collection_schema.flag_); + +#ifdef MILVUS_ENABLE_PROFILING + ProfilerStop(); +#endif + + rc.RecordSection("add vectors to engine"); + rc.ElapseFromBegin("total cost"); + } catch (std::exception& ex) { + return Status(SERVER_UNEXPECTED_ERROR, ex.what()); + } + + return Status::OK(); +} + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/InsertEntityRequest.h b/core/src/server/delivery/hybrid_request/InsertEntityRequest.h new file mode 100644 index 0000000000..c2517b7714 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/InsertEntityRequest.h @@ -0,0 +1,48 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include "server/delivery/request/BaseRequest.h" + +#include +#include +#include +#include + +namespace milvus { +namespace server { + +class InsertEntityRequest : public BaseRequest { + public: + static BaseRequestPtr + Create(const std::shared_ptr& context, const std::string& collection_name, + const std::string& partition_tag, std::unordered_map>& field_values, + std::unordered_map& vector_datas); + + protected: + InsertEntityRequest(const std::shared_ptr& context, const std::string& collection_name, + const std::string& partition_tag, + std::unordered_map>& field_values, + std::unordered_map& vector_datas); + + Status + OnExecute() override; + + private: + const std::string collection_name_; + const std::string partition_tag_; + std::unordered_map> field_values_; + std::unordered_map& vector_datas_; +}; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/request/BaseRequest.cpp b/core/src/server/delivery/request/BaseRequest.cpp index 16d99dad91..66e7f3c68c 100644 --- a/core/src/server/delivery/request/BaseRequest.cpp +++ b/core/src/server/delivery/request/BaseRequest.cpp @@ -37,6 +37,7 @@ RequestGroup(BaseRequest::RequestType type) { {BaseRequest::kDeleteByID, DDL_DML_REQUEST_GROUP}, {BaseRequest::kGetVectorByID, INFO_REQUEST_GROUP}, {BaseRequest::kGetVectorIDs, INFO_REQUEST_GROUP}, + {BaseRequest::kInsertEntity, DDL_DML_REQUEST_GROUP}, // collection operations {BaseRequest::kShowCollections, INFO_REQUEST_GROUP}, @@ -47,6 +48,7 @@ RequestGroup(BaseRequest::RequestType type) { {BaseRequest::kShowCollectionInfo, INFO_REQUEST_GROUP}, {BaseRequest::kDropCollection, DDL_DML_REQUEST_GROUP}, {BaseRequest::kPreloadCollection, DQL_REQUEST_GROUP}, + {BaseRequest::kCreateHybridCollection, DDL_DML_REQUEST_GROUP}, // partition operations {BaseRequest::kCreatePartition, DDL_DML_REQUEST_GROUP}, @@ -62,6 +64,7 @@ RequestGroup(BaseRequest::RequestType type) { {BaseRequest::kSearchByID, DQL_REQUEST_GROUP}, {BaseRequest::kSearch, DQL_REQUEST_GROUP}, {BaseRequest::kSearchCombine, DQL_REQUEST_GROUP}, + {BaseRequest::kHybridSearch, DQL_REQUEST_GROUP}, }; auto iter = s_map_type_group.find(type); diff --git a/core/src/server/delivery/request/BaseRequest.h b/core/src/server/delivery/request/BaseRequest.h index 98d1ca86b3..86a8cb5a71 100644 --- a/core/src/server/delivery/request/BaseRequest.h +++ b/core/src/server/delivery/request/BaseRequest.h @@ -16,6 +16,7 @@ #include "grpc/gen-milvus/milvus.grpc.pb.h" #include "grpc/gen-status/status.grpc.pb.h" #include "grpc/gen-status/status.pb.h" +#include "query/GeneralQuery.h" #include "server/context/Context.h" #include "utils/Json.h" #include "utils/Status.h" @@ -68,6 +69,13 @@ struct TopKQueryResult { } }; +struct HybridQueryResult { + int64_t row_num_; + engine::ResultIds id_list_; + engine::ResultDistances distance_list_; + engine::Entity entities_; +}; + struct IndexParam { std::string collection_name_; int64_t index_type_; @@ -126,6 +134,7 @@ class BaseRequest { kDeleteByID, kGetVectorByID, kGetVectorIDs, + kInsertEntity, // collection operations kShowCollections = 300, @@ -136,6 +145,9 @@ class BaseRequest { kShowCollectionInfo, kDropCollection, kPreloadCollection, + kCreateHybridCollection, + kHasHybridCollection, + kDescribeHybridCollection, // partition operations kCreatePartition = 400, @@ -151,6 +163,7 @@ class BaseRequest { kSearchByID = 600, kSearch, kSearchCombine, + kHybridSearch, }; protected: diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.cpp b/core/src/server/grpc_impl/GrpcRequestHandler.cpp index a9a3265761..4f128bcfbb 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/core/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -15,8 +15,11 @@ #include #include #include +#include #include +#include "context/HybridSearchContext.h" +#include "query/BinaryQuery.h" #include "tracing/TextMapCarrier.h" #include "tracing/TracerUtil.h" #include "utils/Log.h" @@ -759,6 +762,195 @@ GrpcRequestHandler::Compact(::grpc::ServerContext* context, const ::milvus::grpc return ::grpc::Status::OK; } +/*******************************************New Interface*********************************************/ + +::grpc::Status +GrpcRequestHandler::CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, + ::milvus::grpc::Status* response) { + CHECK_NULLPTR_RETURN(request); + + std::vector> field_types; + std::vector> vector_dimensions; + std::vector> field_params; + for (uint64_t i = 0; i < request->fields_size(); ++i) { + if (request->fields(i).type().has_vector_param()) { + auto vector_dimension = + std::make_pair(request->fields(i).name(), request->fields(i).type().vector_param().dimension()); + vector_dimensions.emplace_back(vector_dimension); + } else { + auto type = std::make_pair(request->fields(i).name(), + (engine::meta::hybrid::DataType)request->fields(i).type().data_type()); + field_types.emplace_back(type); + } + // Currently only one extra_param + if (request->fields(i).extra_params_size() != 0) { + auto extra_params = std::make_pair(request->fields(i).name(), request->fields(i).extra_params(0).value()); + field_params.emplace_back(extra_params); + } else { + auto extra_params = std::make_pair(request->fields(i).name(), ""); + field_params.emplace_back(extra_params); + } + } + + Status status = request_handler_.CreateHybridCollection(GetContext(context), request->collection_name(), + field_types, vector_dimensions, field_params); + + SET_RESPONSE(response, status, context); + + return ::grpc::Status::OK; +} + +::grpc::Status +GrpcRequestHandler::InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, + ::milvus::grpc::HEntityIDs* response) { + CHECK_NULLPTR_RETURN(request); + + std::unordered_map> attr_values; + std::unordered_map vector_datas; + + auto attr_size = request->entities().attr_records_size(); + for (uint64_t i = 0; i < attr_size; ++i) { + std::vector values; + auto record_size = request->entities().attr_records(i).value_size(); + values.resize(record_size); + for (uint64_t j = 0; j < record_size; ++j) { + values[j] = request->entities().attr_records(i).value(j); + } + attr_values.insert(std::make_pair(request->entities().field_names(i), values)); + } + + auto vector_size = request->entities().result_values_size(); + for (uint64_t i = 0; i < vector_size; ++i) { + engine::VectorsData vectors; + CopyRowRecords(request->entities().result_values(i).vector_value().value(), request->entity_id_array(), + vectors); + vector_datas.insert(std::make_pair(request->entities().field_names(attr_size + i), vectors)); + } + + std::string collection_name = request->collection_name(); + std::string partition_tag = request->partition_tag(); + Status status = + request_handler_.InsertEntity(GetContext(context), collection_name, partition_tag, attr_values, vector_datas); + + response->mutable_entity_id_array()->Resize(static_cast(vector_datas.begin()->second.id_array_.size()), 0); + memcpy(response->mutable_entity_id_array()->mutable_data(), vector_datas.begin()->second.id_array_.data(), + vector_datas.begin()->second.id_array_.size() * sizeof(int64_t)); + + SET_RESPONSE(response->mutable_status(), status, context); + return ::grpc::Status::OK; +} + +void +DeSerialization(const ::milvus::grpc::GeneralQuery& general_query, query::BooleanQueryPtr boolean_clause) { + if (general_query.has_boolean_query()) { + // boolean_clause->SetOccur((query::Occur)general_query.boolean_query().occur()); + + for (uint64_t i = 0; i < general_query.boolean_query().general_query_size(); ++i) { + if (general_query.boolean_query().general_query(i).has_boolean_query()) { + query::BooleanQueryPtr query = + std::make_shared((query::Occur)(general_query.boolean_query().occur())); + DeSerialization(general_query.boolean_query().general_query(i), query); + boolean_clause->AddBooleanQuery(query); + } else { + auto leaf_query = std::make_shared(); + auto query = general_query.boolean_query().general_query(i); + if (query.has_term_query()) { + query::TermQueryPtr term_query = std::make_shared(); + term_query->field_name = query.term_query().field_name(); + term_query->boost = query.term_query().boost(); + term_query->field_value.resize(query.term_query().values_size()); + for (uint64_t j = 0; j < query.term_query().values_size(); ++j) { + term_query->field_value[j] = query.term_query().values(j); + } + leaf_query->term_query = term_query; + boolean_clause->AddLeafQuery(leaf_query); + } + if (query.has_range_query()) { + query::RangeQueryPtr range_query = std::make_shared(); + range_query->field_name = query.range_query().field_name(); + range_query->boost = query.range_query().boost(); + range_query->compare_expr.resize(query.range_query().operand_size()); + for (uint64_t j = 0; j < query.range_query().operand_size(); ++j) { + range_query->compare_expr[j].compare_operator = + query::CompareOperator(query.range_query().operand(j).operator_()); + range_query->compare_expr[j].operand = query.range_query().operand(j).operand(); + } + leaf_query->range_query = range_query; + boolean_clause->AddLeafQuery(leaf_query); + } + if (query.has_vector_query()) { + query::VectorQueryPtr vector_query = std::make_shared(); + + engine::VectorsData vectors; + CopyRowRecords(query.vector_query().records(), + google::protobuf::RepeatedField(), vectors); + + vector_query->query_vector.float_data = vectors.float_data_; + vector_query->query_vector.binary_data = vectors.binary_data_; + + vector_query->boost = query.vector_query().query_boost(); + vector_query->field_name = query.vector_query().field_name(); + vector_query->topk = query.vector_query().topk(); + + milvus::json json_params; + for (int j = 0; j < query.vector_query().extra_params_size(); j++) { + const ::milvus::grpc::KeyValuePair& extra = query.vector_query().extra_params(j); + if (extra.key() == EXTRA_PARAM_KEY) { + json_params = json::parse(extra.value()); + } + } + vector_query->extra_params = json_params; + leaf_query->vector_query = vector_query; + boolean_clause->AddLeafQuery(leaf_query); + } + } + } + } +} + +::grpc::Status +GrpcRequestHandler::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, + ::milvus::grpc::TopKQueryResult* response) { + CHECK_NULLPTR_RETURN(request); + + context::HybridSearchContextPtr hybrid_search_context = std::make_shared(); + + query::BooleanQueryPtr boolean_query = std::make_shared(); + DeSerialization(request->general_query(), boolean_query); + + query::GeneralQueryPtr general_query = std::make_shared(); + general_query->bin = std::make_shared(); + query::GenBinaryQuery(boolean_query, general_query->bin); + + Status status; + + if (!query::ValidateBinaryQuery(general_query->bin)) { + status = Status{SERVER_INVALID_BINARY_QUERY, "Generate wrong binary query tree"}; + SET_RESPONSE(response->mutable_status(), status, context); + return ::grpc::Status::OK; + } + + hybrid_search_context->general_query_ = general_query; + + std::vector partition_list; + partition_list.resize(request->partition_tag_array_size()); + for (uint64_t i = 0; i < request->partition_tag_array_size(); ++i) { + partition_list[i] = request->partition_tag_array(i); + } + + TopKQueryResult result; + + status = request_handler_.HybridSearch(GetContext(context), hybrid_search_context, request->collection_name(), + partition_list, general_query, result); + + // step 6: construct and return result + ConstructResults(result, response); + + SET_RESPONSE(response->mutable_status(), status, context); + + return ::grpc::Status::OK; +} + } // namespace grpc } // namespace server } // namespace milvus diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.h b/core/src/server/grpc_impl/GrpcRequestHandler.h index 385338272f..735ec86231 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.h +++ b/core/src/server/grpc_impl/GrpcRequestHandler.h @@ -304,6 +304,76 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + /*******************************************New Interface*********************************************/ + + ::grpc::Status + CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, + ::milvus::grpc::Status* response) override; + + // ::grpc::Status + // HasCollection(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::BoolReply* response) override; + // + // ::grpc::Status + // DropCollection(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::Status* response) override; + // + // ::grpc::Status + // DescribeCollection(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::Mapping* response) override; + // + // ::grpc::Status + // CountCollection(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::CollectionRowCount* response) override; + // + // ::grpc::Status + // ShowCollections(::grpc::ServerContext* context, + // const ::milvus::grpc::Command* request, + // ::milvus::grpc::MappingList* response) override; + // + // ::grpc::Status + // ShowCollectionInfo(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::CollectionInfo* response) override; + // + // ::grpc::Status + // PreloadCollection(::grpc::ServerContext* context, + // const ::milvus::grpc::CollectionName* request, + // ::milvus::grpc::Status* response) override; + // + ::grpc::Status + InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, + ::milvus::grpc::HEntityIDs* response) override; + + ::grpc::Status + HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, + ::milvus::grpc::TopKQueryResult* response) override; + // + // ::grpc::Status + // HybridSearchInSegments(::grpc::ServerContext* context, + // const ::milvus:: + // grpc::HSearchInSegmentsParam* request, + // ::milvus::grpc::HQueryResult* response) override; + // + // ::grpc::Status + // GetEntityByID(::grpc::ServerContext* context, + // const ::milvus::grpc::HEntityIdentity* request, + // ::milvus::grpc::HEntity* response) override; + // + // ::grpc::Status + // GetEntityIDs(::grpc::ServerContext* context, + // const ::milvus::grpc::HGetEntityIDsParam* request, + // ::milvus::grpc::HEntityIDs* response) override; + // + // ::grpc::Status + // DeleteEntitiesByID(::grpc::ServerContext* context, + // const ::milvus::grpc::HDeleteByIDParam* request, + // ::milvus::grpc::Status* response) override; + GrpcRequestHandler& RegisterRequestHandler(const RequestHandler& handler) { request_handler_ = handler; diff --git a/core/src/utils/Error.h b/core/src/utils/Error.h index 31c401dca1..c96cb4944c 100644 --- a/core/src/utils/Error.h +++ b/core/src/utils/Error.h @@ -83,6 +83,7 @@ constexpr ErrorCode SERVER_INVALID_INDEX_METRIC_TYPE = ToServerErrorCode(115); constexpr ErrorCode SERVER_INVALID_INDEX_FILE_SIZE = ToServerErrorCode(116); constexpr ErrorCode SERVER_OUT_OF_MEMORY = ToServerErrorCode(117); constexpr ErrorCode SERVER_INVALID_PARTITION_TAG = ToServerErrorCode(118); +constexpr ErrorCode SERVER_INVALID_BINARY_QUERY = ToServerErrorCode(119); // db error code constexpr ErrorCode DB_META_TRANSACTION_FAILED = ToDbErrorCode(1); diff --git a/core/unittest/CMakeLists.txt b/core/unittest/CMakeLists.txt index 5d48de56a7..e317a6d04e 100644 --- a/core/unittest/CMakeLists.txt +++ b/core/unittest/CMakeLists.txt @@ -29,6 +29,8 @@ aux_source_directory(${MILVUS_ENGINE_SRC}/db/engine db_engine_files) aux_source_directory(${MILVUS_ENGINE_SRC}/db/insert db_insert_files) aux_source_directory(${MILVUS_ENGINE_SRC}/db/meta db_meta_files) aux_source_directory(${MILVUS_ENGINE_SRC}/db/wal db_wal_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/search search_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/query query_files) set(grpc_service_files ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc @@ -89,10 +91,12 @@ set(web_server_files aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery server_delivery_impl_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/request server_delivery_request_files) +aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/hybrid_request server_delivery_hybrid_request_files) aux_source_directory(${MILVUS_ENGINE_SRC}/server/delivery/strategy server_delivery_strategy_files) set(server_delivery_files ${server_delivery_impl_files} ${server_delivery_request_files} + ${server_delivery_hybrid_request_files} ${server_delivery_strategy_files}) aux_source_directory(${MILVUS_ENGINE_SRC}/utils utils_files) @@ -147,6 +151,8 @@ set(common_files ${codecs_files} ${codecs_default_files} ${segment_files} + ${search_files} + ${query_files} ) set(unittest_libs diff --git a/core/unittest/db/CMakeLists.txt b/core/unittest/db/CMakeLists.txt index 8ea4530fa2..dd88fdd2a8 100644 --- a/core/unittest/db/CMakeLists.txt +++ b/core/unittest/db/CMakeLists.txt @@ -13,6 +13,7 @@ set(test_files ${CMAKE_CURRENT_SOURCE_DIR}/test_db.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_hybrid_db.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_db_mysql.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_wal.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_engine.cpp diff --git a/core/unittest/db/test_hybrid_db.cpp b/core/unittest/db/test_hybrid_db.cpp new file mode 100644 index 0000000000..6b10d17cf4 --- /dev/null +++ b/core/unittest/db/test_hybrid_db.cpp @@ -0,0 +1,283 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#include +#include +#include + +#include +#include +#include + +#include "cache/CpuCacheMgr.h" +#include "config/Config.h" +#include "db/Constants.h" +#include "db/DB.h" +#include "db/DBFactory.h" +#include "db/DBImpl.h" +#include "db/IDGenerator.h" +#include "db/meta/MetaConsts.h" +#include "db/utils.h" +#include "utils/CommonUtil.h" + +namespace { +static const char* TABLE_NAME = "test_hybrid"; +static constexpr int64_t TABLE_DIM = 128; +static constexpr int64_t SECONDS_EACH_HOUR = 3600; +static constexpr int64_t FIELD_NUM = 4; +static constexpr int64_t NQ = 10; +static constexpr int64_t TOPK = 100; + +void +BuildTableSchema(milvus::engine::meta::CollectionSchema& collection_schema, + milvus::engine::meta::hybrid::FieldsSchema& fields_schema, + std::unordered_map& attr_type) { + collection_schema.dimension_ = TABLE_DIM; + collection_schema.collection_id_ = TABLE_NAME; + + std::vector fields; + fields.resize(FIELD_NUM); + for (uint64_t i = 0; i < FIELD_NUM; ++i) { + fields[i].collection_id_ = TABLE_NAME; + fields[i].field_name_ = "field_" + std::to_string(i + 1); + } + fields[0].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT32; + fields[1].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT64; + fields[2].field_type_ = (int)milvus::engine::meta::hybrid::DataType::FLOAT; + fields[3].field_type_ = (int)milvus::engine::meta::hybrid::DataType::VECTOR; + fields_schema.fields_schema_ = fields; + + attr_type.insert(std::make_pair("field_0", milvus::engine::meta::hybrid::DataType::INT32)); + attr_type.insert(std::make_pair("field_1", milvus::engine::meta::hybrid::DataType::INT64)); + attr_type.insert(std::make_pair("field_2", milvus::engine::meta::hybrid::DataType::FLOAT)); +} + +void +BuildVectors(uint64_t n, uint64_t batch_index, milvus::engine::VectorsData& vectors) { + vectors.vector_count_ = n; + vectors.float_data_.clear(); + vectors.float_data_.resize(n * TABLE_DIM); + float* data = vectors.float_data_.data(); + for (uint64_t i = 0; i < n; i++) { + for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + data[TABLE_DIM * i] += i / 2000.; + + vectors.id_array_.push_back(n * batch_index + i); + } +} + +void +BuildEntity(uint64_t n, uint64_t batch_index, milvus::engine::Entity& entity) { + milvus::engine::VectorsData vectors; + vectors.vector_count_ = n; + vectors.float_data_.clear(); + vectors.float_data_.resize(n * TABLE_DIM); + float* data = vectors.float_data_.data(); + for (uint64_t i = 0; i < n; i++) { + for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + data[TABLE_DIM * i] += i / 2000.; + + vectors.id_array_.push_back(n * batch_index + i); + } + entity.vector_data_.insert(std::make_pair("field_3", vectors)); + std::vector value_0, value_1, value_2; + value_0.resize(n); + value_1.resize(n); + value_2.resize(n); + for (uint64_t i = 0; i < n; ++i) { + value_0[i] = std::to_string(i); + value_1[i] = std::to_string(i + n); + value_2[i] = std::to_string((i + 100) / (n + 1)); + } + entity.entity_count_ = n; + entity.attr_data_.insert(std::make_pair("field_0", value_0)); + entity.attr_data_.insert(std::make_pair("field_1", value_1)); + entity.attr_data_.insert(std::make_pair("field_2", value_2)); +} + +void +ConstructGeneralQuery(milvus::query::GeneralQueryPtr& general_query) { + general_query->bin->relation = milvus::query::QueryRelation::AND; + general_query->bin->left_query = std::make_shared(); + general_query->bin->right_query = std::make_shared(); + auto left = general_query->bin->left_query; + auto right = general_query->bin->right_query; + left->bin->relation = milvus::query::QueryRelation::AND; + + auto term_query = std::make_shared(); + term_query->field_name = "field_0"; + term_query->field_value = {"10", "20", "30", "40", "50"}; + term_query->boost = 1; + + auto range_query = std::make_shared(); + range_query->field_name = "field_1"; + std::vector compare_expr; + compare_expr.resize(2); + compare_expr[0].compare_operator = milvus::query::CompareOperator::GTE; + compare_expr[0].operand = "1000"; + compare_expr[1].compare_operator = milvus::query::CompareOperator::LTE; + compare_expr[1].operand = "5000"; + range_query->compare_expr = compare_expr; + range_query->boost = 2; + + auto vector_query = std::make_shared(); + vector_query->field_name = "field_3"; + vector_query->topk = 100; + vector_query->boost = 3; + milvus::json json_params = {{"nprobe", 10}}; + vector_query->extra_params = json_params; + milvus::query::VectorRecord record; + record.float_data.resize(NQ * TABLE_DIM); + float* data = record.float_data.data(); + for (uint64_t i = 0; i < NQ; i++) { + for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + data[TABLE_DIM * i] += i / 2000.; + } + vector_query->query_vector = record; + + left->bin->left_query = std::make_shared(); + left->bin->right_query = std::make_shared(); + left->bin->left_query->leaf = std::make_shared(); + left->bin->right_query->leaf = std::make_shared(); + left->bin->left_query->leaf->term_query = term_query; + left->bin->right_query->leaf->range_query = range_query; + + right->leaf = std::make_shared(); + right->leaf->vector_query = vector_query; +} +} // namespace + +TEST_F(DBTest, HYBRID_DB_TEST) { + milvus::engine::meta::CollectionSchema collection_info; + milvus::engine::meta::hybrid::FieldsSchema fields_info; + std::unordered_map attr_type; + BuildTableSchema(collection_info, fields_info, attr_type); + + auto stat = db_->CreateHybridCollection(collection_info, fields_info); + ASSERT_TRUE(stat.ok()); + milvus::engine::meta::CollectionSchema collection_info_get; + milvus::engine::meta::hybrid::FieldsSchema fields_info_get; + collection_info_get.collection_id_ = TABLE_NAME; + stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); + ASSERT_TRUE(stat.ok()); + ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + + uint64_t qb = 1000; + milvus::engine::Entity entity; + BuildEntity(qb, 0, entity); + + stat = db_->InsertEntities(TABLE_NAME, "", entity, attr_type); + ASSERT_TRUE(stat.ok()); + + stat = db_->Flush(); + ASSERT_TRUE(stat.ok()); + +// milvus::engine::CollectionIndex index; +// index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; +// index.extra_params_ = {{"nlist", 16384}}; +// +// stat = db_->CreateIndex(TABLE_NAME, index); +// ASSERT_TRUE(stat.ok()); +} + +TEST_F(DBTest, HYBRID_SEARCH_TEST) { +//#ifndef MILVUS_GPU_VERSION + milvus::engine::meta::CollectionSchema collection_info; + milvus::engine::meta::hybrid::FieldsSchema fields_info; + std::unordered_map attr_type; + BuildTableSchema(collection_info, fields_info, attr_type); + + auto stat = db_->CreateHybridCollection(collection_info, fields_info); + ASSERT_TRUE(stat.ok()); + milvus::engine::meta::CollectionSchema collection_info_get; + milvus::engine::meta::hybrid::FieldsSchema fields_info_get; + collection_info_get.collection_id_ = TABLE_NAME; + stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); + ASSERT_TRUE(stat.ok()); + ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + + uint64_t qb = 1000; + milvus::engine::Entity entity; + BuildEntity(qb, 0, entity); + + stat = db_->InsertEntities(TABLE_NAME, "", entity, attr_type); + ASSERT_TRUE(stat.ok()); + + stat = db_->Flush(); + ASSERT_TRUE(stat.ok()); + + // Construct general query + milvus::query::GeneralQueryPtr general_query = std::make_shared(); + ConstructGeneralQuery(general_query); + + std::vector tags; + milvus::context::HybridSearchContextPtr hybrid_context = std::make_shared(); + milvus::engine::ResultIds result_ids; + milvus::engine::ResultDistances result_distances; + uint64_t nq; + stat = db_->HybridQuery(dummy_context_, TABLE_NAME, tags, hybrid_context, general_query, attr_type, nq, result_ids, + result_distances); + ASSERT_TRUE(stat.ok()); +//#endif +} + +TEST_F(DBTest, COMPACT_TEST) { + milvus::engine::meta::CollectionSchema collection_info; + milvus::engine::meta::hybrid::FieldsSchema fields_info; + std::unordered_map attr_type; + BuildTableSchema(collection_info, fields_info, attr_type); + + auto stat = db_->CreateHybridCollection(collection_info, fields_info); + ASSERT_TRUE(stat.ok()); + milvus::engine::meta::CollectionSchema collection_info_get; + milvus::engine::meta::hybrid::FieldsSchema fields_info_get; + collection_info_get.collection_id_ = TABLE_NAME; + stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); + ASSERT_TRUE(stat.ok()); + ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + + uint64_t vector_count = 1000; + milvus::engine::Entity entity; + BuildEntity(vector_count, 0, entity); + + stat = db_->InsertEntities(TABLE_NAME, "", entity, attr_type); + ASSERT_TRUE(stat.ok()); + + stat = db_->Flush(); + ASSERT_TRUE(stat.ok()); + + std::vector ids_to_delete; + ids_to_delete.emplace_back(entity.id_array_.front()); + ids_to_delete.emplace_back(entity.id_array_.back()); + stat = db_->DeleteVectors(collection_info.collection_id_, ids_to_delete); + ASSERT_TRUE(stat.ok()); + + stat = db_->Flush(); + ASSERT_TRUE(stat.ok()); + + stat = db_->Compact(collection_info.collection_id_); + ASSERT_TRUE(stat.ok()); + + const int topk = 1, nprobe = 1; + milvus::json json_params = {{"nprobe", nprobe}}; + + std::vector tags; + milvus::engine::ResultIds result_ids; + milvus::engine::ResultDistances result_distances; + + for (auto& id : ids_to_delete) { + stat = db_->QueryByID(dummy_context_, collection_info.collection_id_, tags, topk, json_params, id, result_ids, + result_distances); + ASSERT_TRUE(stat.ok()); + ASSERT_EQ(result_ids[0], -1); + ASSERT_EQ(result_distances[0], std::numeric_limits::max()); + } +} diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp index 726dc403ce..ec240208ac 100644 --- a/core/unittest/server/test_rpc.cpp +++ b/core/unittest/server/test_rpc.cpp @@ -17,10 +17,10 @@ #include "config/Config.h" #include "server/Server.h" -#include "server/grpc_impl/GrpcRequestHandler.h" +#include "server/delivery/RequestHandler.h" #include "server/delivery/RequestScheduler.h" #include "server/delivery/request/BaseRequest.h" -#include "server/delivery/RequestHandler.h" +#include "server/grpc_impl/GrpcRequestHandler.h" #include "src/version.h" #include "grpc/gen-milvus/milvus.grpc.pb.h" @@ -28,11 +28,11 @@ #include "scheduler/ResourceFactory.h" #include "scheduler/SchedInst.h" #include "server/DBWrapper.h" -#include "utils/CommonUtil.h" #include "server/grpc_impl/GrpcServer.h" +#include "utils/CommonUtil.h" -#include #include +#include namespace { @@ -58,8 +58,7 @@ CopyBinRowRecord(::milvus::grpc::RowRecord* target, const std::vector& } void -SearchFunc(std::shared_ptr handler, - ::grpc::ServerContext* context, +SearchFunc(std::shared_ptr handler, ::grpc::ServerContext* context, std::shared_ptr<::milvus::grpc::SearchParam> request, std::shared_ptr<::milvus::grpc::TopKQueryResult> result) { handler->Search(context, request.get(), result.get()); @@ -439,7 +438,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_TEST) { collection_schema.set_collection_name(collection_name); collection_schema.set_dimension(COLLECTION_DIM); collection_schema.set_index_file_size(INDEX_FILE_SIZE); - collection_schema.set_metric_type(1); // L2 metric + collection_schema.set_metric_type(1); // L2 metric ::milvus::grpc::Status status; handler->CreateCollection(&context, &collection_schema, &status); ASSERT_EQ(status.error_code(), 0); @@ -494,8 +493,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_TEST) { for (int i = 0; i < QUERY_COUNT; i++) { ResultPtr result_ptr = std::make_shared<::milvus::grpc::TopKQueryResult>(); result_array.push_back(result_ptr); - ThreadPtr - thread = std::make_shared(SearchFunc, handler, &context, request_array[i], result_ptr); + ThreadPtr thread = std::make_shared(SearchFunc, handler, &context, request_array[i], result_ptr); thread_list.emplace_back(thread); std::this_thread::sleep_for(std::chrono::milliseconds(5)); } @@ -541,7 +539,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_BINARY_TEST) { collection_schema.set_collection_name(collection_name); collection_schema.set_dimension(COLLECTION_DIM); collection_schema.set_index_file_size(INDEX_FILE_SIZE); - collection_schema.set_metric_type(5); // tanimoto metric + collection_schema.set_metric_type(5); // tanimoto metric ::milvus::grpc::Status status; handler->CreateCollection(&context, &collection_schema, &status); ASSERT_EQ(status.error_code(), 0); @@ -596,8 +594,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_BINARY_TEST) { for (int i = 0; i < QUERY_COUNT; i++) { ResultPtr result_ptr = std::make_shared<::milvus::grpc::TopKQueryResult>(); result_array.push_back(result_ptr); - ThreadPtr - thread = std::make_shared(SearchFunc, handler, &context, request_array[i], result_ptr); + ThreadPtr thread = std::make_shared(SearchFunc, handler, &context, request_array[i], result_ptr); thread_list.emplace_back(thread); std::this_thread::sleep_for(std::chrono::milliseconds(5)); } @@ -955,6 +952,112 @@ TEST_F(RpcHandlerTest, CMD_TEST) { handler->Cmd(&context, &command, &reply); } +TEST_F(RpcHandlerTest, HYBRID_TEST) { + ::grpc::ServerContext context; + milvus::grpc::Mapping mapping; + milvus::grpc::Status response; + + uint64_t row_num = 1000; + uint64_t dimension = 128; + + // Create Hybrid Collection + mapping.set_collection_name("test_hybrid"); + auto field_0 = mapping.add_fields(); + field_0->set_name("field_0"); + field_0->mutable_type()->set_data_type(::milvus::grpc::DataType::INT64); + + auto field_1 = mapping.add_fields(); + field_1->mutable_type()->mutable_vector_param()->set_dimension(128); + field_1->set_name("field_1"); + + handler->CreateHybridCollection(&context, &mapping, &response); + + // Insert Entities + milvus::grpc::HInsertParam insert_param; + milvus::grpc::HEntityIDs entity_ids; + insert_param.set_collection_name("test_hybrid"); + + std::vector numerica_value; + numerica_value.resize(row_num); + for (uint64_t i = 0; i < row_num; i++) { + numerica_value[i] = std::to_string(i); + } + auto entity = insert_param.mutable_entities(); + auto field_name_0 = entity->add_field_names(); + *field_name_0 = "field_0"; + auto field_name_1 = entity->add_field_names(); + *field_name_1 = "field_1"; + + auto records_0 = entity->add_attr_records(); + for (auto value : numerica_value) { + auto record = records_0->add_value(); + *record = value; + } + + std::vector> vector_field; + vector_field.resize(row_num); + for (uint64_t i = 0; i < row_num; ++i) { + vector_field[i].resize(dimension); + for (uint64_t j = 0; j < dimension; ++j) { + vector_field[i][j] = (float)((i + 10) / (j + 20)); + } + } + auto vector_record = entity->add_result_values(); + for (uint64_t i = 0; i < row_num; ++i) { + auto record = vector_record->mutable_vector_value()->add_value(); + auto vector_data = record->mutable_float_data(); + vector_data->Resize(static_cast(vector_field[i].size()), 0.0); + memcpy(vector_data->mutable_data(), vector_field[i].data(), vector_field[i].size() * sizeof(float)); + } + handler->InsertEntity(&context, &insert_param, &entity_ids); + ASSERT_EQ(entity_ids.entity_id_array_size(), row_num); + + // TODO(yukun): Hybrid Search + uint64_t nq = 10; + uint64_t topk = 10; + milvus::grpc::HSearchParam search_param; + auto general_query = search_param.mutable_general_query(); + auto boolean_query_1 = general_query->mutable_boolean_query(); + boolean_query_1->set_occur(milvus::grpc::Occur::MUST); + auto general_query_1 = boolean_query_1->add_general_query(); + auto boolean_query_2 = general_query_1->mutable_boolean_query(); + auto term_query = boolean_query_2->add_general_query()->mutable_term_query(); + term_query->set_field_name("field_0"); + for (uint64_t i = 0; i < nq; ++i) { + auto value = std::to_string(i + nq); + auto term = term_query->add_values(); + *term = value; + } + auto vector_query = boolean_query_2->add_general_query()->mutable_vector_query(); + vector_query->set_field_name("field_1"); + vector_query->set_topk(topk); + vector_query->set_query_boost(2); + std::vector> query_vector; + query_vector.resize(nq); + for (uint64_t i = 0; i < nq; ++i) { + query_vector[i].resize(dimension); + for (uint64_t j = 0; j < dimension; ++j) { + query_vector[i][j] = (float)((j + 1) / (i + dimension)); + } + } + for (auto record : query_vector) { + auto row_record = vector_query->add_records(); + CopyRowRecord(row_record, record); + } + auto extra_param = vector_query->add_extra_params(); + extra_param->set_key("params"); + milvus::json param = {{"nprobe", 16}}; + extra_param->set_value(param.dump()); + + search_param.set_collection_name("test_hybrid"); + auto search_extra_param = search_param.add_extra_params(); + search_extra_param->set_key("params"); + search_extra_param->set_value(""); + + milvus::grpc::TopKQueryResult topk_query_result; + handler->HybridSearch(&context, &search_param, &topk_query_result); +} + ////////////////////////////////////////////////////////////////////// namespace { class DummyRequest : public milvus::server::BaseRequest { @@ -1000,8 +1103,7 @@ class AsyncDummyRequest : public milvus::server::BaseRequest { public: AsyncDummyRequest() - : BaseRequest(std::make_shared("dummy_request_id2"), - milvus::server::BaseRequest::kCmd, + : BaseRequest(std::make_shared("dummy_request_id2"), milvus::server::BaseRequest::kCmd, true) { } }; @@ -1012,8 +1114,8 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { ASSERT_TRUE(status.ok()); milvus::server::RequestScheduler::GetInstance().Start(); -// milvus::server::RequestScheduler::GetInstance().Stop(); -// milvus::server::RequestScheduler::GetInstance().Start(); + // milvus::server::RequestScheduler::GetInstance().Stop(); + // milvus::server::RequestScheduler::GetInstance().Start(); milvus::server::BaseRequestPtr base_task_ptr = DummyRequest::Create(); milvus::server::RequestScheduler::ExecRequest(base_task_ptr); @@ -1025,11 +1127,11 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { milvus::server::RequestScheduler::GetInstance().ExecuteRequest(request_ptr); fiu_disable("RequestScheduler.ExecuteRequest.push_queue_fail"); -// std::string dummy2 = "dql2"; -// milvus::server::BaseRequestPtr base_task_ptr2 = DummyRequest::Create(dummy2); -// fiu_enable("RequestScheduler.PutToQueue.null_queue", 1, NULL, 0); -// milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr2); -// fiu_disable("RequestScheduler.PutToQueue.null_queue"); + // std::string dummy2 = "dql2"; + // milvus::server::BaseRequestPtr base_task_ptr2 = DummyRequest::Create(dummy2); + // fiu_enable("RequestScheduler.PutToQueue.null_queue", 1, NULL, 0); + // milvus::server::RequestScheduler::GetInstance().ExecuteRequest(base_task_ptr2); + // fiu_disable("RequestScheduler.PutToQueue.null_queue"); milvus::server::BaseRequestPtr base_task_ptr3 = DummyRequest::Create(); fiu_enable("RequestScheduler.TakeToExecute.throw_std_exception", 1, NULL, 0); @@ -1063,7 +1165,7 @@ TEST_F(RpcSchedulerTest, BASE_TASK_TEST) { } TEST(RpcTest, RPC_SERVER_TEST) { - using GrpcServer = milvus::server::grpc::GrpcServer; + using GrpcServer = milvus::server::grpc::GrpcServer; GrpcServer& server = GrpcServer::GetInstance(); fiu_init(0); diff --git a/sdk/examples/simple/main.cpp b/sdk/examples/simple/main.cpp index 88c362f724..57e4320cbc 100644 --- a/sdk/examples/simple/main.cpp +++ b/sdk/examples/simple/main.cpp @@ -56,7 +56,8 @@ main(int argc, char* argv[]) { } ClientTest test(address, port); - test.Test(); +// test.Test(); + test.TestHybrid(); printf("Client stop...\n"); return 0; diff --git a/sdk/examples/simple/src/ClientTest.cpp b/sdk/examples/simple/src/ClientTest.cpp index c7474298f5..222dcc6a9e 100644 --- a/sdk/examples/simple/src/ClientTest.cpp +++ b/sdk/examples/simple/src/ClientTest.cpp @@ -10,6 +10,7 @@ // or implied. See the License for the specific language governing permissions and limitations under the License. #include "include/MilvusApi.h" +#include "include/BooleanQuery.h" #include "examples/utils/TimeRecorder.h" #include "examples/utils/Utils.h" #include "examples/simple/src/ClientTest.h" @@ -34,6 +35,7 @@ constexpr int64_t SEARCH_TARGET = BATCH_ENTITY_COUNT / 2; // change this value, constexpr int64_t ADD_ENTITY_LOOP = 5; constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::IVFSQ8; constexpr int32_t NLIST = 16384; +constexpr uint64_t FIELD_NUM = 3; } // namespace @@ -226,6 +228,86 @@ ClientTest::DropCollection(const std::string& collection_name) { std::cout << "DropCollection function call status: " << stat.message() << std::endl; } +void +ClientTest::CreateHybridCollection(const std::string& collection_name) { + milvus::FieldPtr field_ptr1 = std::make_shared(); + milvus::FieldPtr field_ptr2 = std::make_shared(); + milvus::VectorFieldPtr vec_field_ptr = std::make_shared(); + field_ptr1->field_type = milvus::DataType::INT64; + field_ptr1->field_name = "field_1"; + field_ptr2->field_type = milvus::DataType::FLOAT; + field_ptr2->field_name = "field_2"; + vec_field_ptr->field_type = milvus::DataType::VECTOR; + vec_field_ptr->field_name = "field_3"; + vec_field_ptr->dimension = 128; + + std::vector numerica_fields; + std::vector vector_fields; + numerica_fields.emplace_back(field_ptr1); + numerica_fields.emplace_back(field_ptr2); + vector_fields.emplace_back(vec_field_ptr); + + milvus::HMapping mapping = {collection_name, numerica_fields, vector_fields}; + milvus::Status stat = conn_->CreateHybridCollection(mapping); + std::cout << "CreateHybridCollection function call status: " << stat.message() << std::endl; +} + +void +ClientTest::InsertHybridEntities(std::string& collection_name, int64_t row_num) { + std::unordered_map> numerica_value; + std::vector value1, value2; + value1.resize(row_num); + value2.resize(row_num); + for (uint64_t i = 0; i < row_num; ++i) { + value1[i] = std::to_string(i); + value2[i] = std::to_string(i + row_num); + } + numerica_value.insert(std::make_pair("field_1", value1)); + numerica_value.insert(std::make_pair("field_2", value2)); + + std::unordered_map> vector_value; + std::vector entity_array; + std::vector record_ids; + { // generate vectors + milvus_sdk::Utils::BuildEntities(0, + row_num, + entity_array, + record_ids, + 128); + } + + vector_value.insert(std::make_pair("field_3", entity_array)); + milvus::HEntity entity = {numerica_value, vector_value}; + std::vector id_array; + milvus::Status status = conn_->InsertEntity(collection_name, "", entity, id_array); + std::cout << "InsertHybridEntities function call status: " << status.message() << std::endl; +} + +void +ClientTest::HybridSearch(std::string& collection_name) { + std::vector partition_tags; + milvus::TopKQueryResult topk_query_result; + + auto leaf_queries = milvus_sdk::Utils::GenLeafQuery(); + + //must + auto must_clause = std::make_shared(milvus::Occur::MUST); + must_clause->AddLeafQuery(leaf_queries[0]); + must_clause->AddLeafQuery(leaf_queries[1]); + must_clause->AddLeafQuery(leaf_queries[2]); + + auto query_clause = std::make_shared(); + query_clause->AddBooleanQuery(must_clause); + + std::string extra_params; + milvus::Status + status = conn_->HybridSearch(collection_name, partition_tags, query_clause, extra_params, topk_query_result); + for (uint64_t i = 0; i < topk_query_result.size(); ++i) { + std::cout << topk_query_result[i].ids[0] << " --------- " << topk_query_result[i].distances[0] << std::endl; + } + std::cout << "HybridSearch function call status: " << status.message() << std::endl; +} + void ClientTest::Test() { std::string collection_name = COLLECTION_NAME; @@ -262,3 +344,13 @@ ClientTest::Test() { DropIndex(collection_name); DropCollection(collection_name); } + +void +ClientTest::TestHybrid() { + std::string collection_name = "HYBRID_TEST"; + CreateHybridCollection(collection_name); + InsertHybridEntities(collection_name, 1000); + Flush(collection_name); +// SearchEntities(collection_name, ) + HybridSearch(collection_name); +} diff --git a/sdk/examples/simple/src/ClientTest.h b/sdk/examples/simple/src/ClientTest.h index b2a2621019..e9e2b2d514 100644 --- a/sdk/examples/simple/src/ClientTest.h +++ b/sdk/examples/simple/src/ClientTest.h @@ -26,6 +26,9 @@ class ClientTest { void Test(); + void + TestHybrid(); + private: void ShowServerVersion(); @@ -78,6 +81,17 @@ class ClientTest { void DropCollection(const std::string&); + /*******************************New Interface**********************************/ + + void + CreateHybridCollection(const std::string& collection_name); + + void + InsertHybridEntities(std::string&, int64_t); + + void + HybridSearch(std::string&); + private: std::shared_ptr conn_; std::vector> search_entity_array_; diff --git a/sdk/examples/utils/Utils.cpp b/sdk/examples/utils/Utils.cpp index ad698609fa..71b2c49379 100644 --- a/sdk/examples/utils/Utils.cpp +++ b/sdk/examples/utils/Utils.cpp @@ -140,7 +140,7 @@ Utils::BuildEntities(int64_t from, int64_t to, std::vector& enti milvus::Entity entity; entity.float_data.resize(dimension); for (int64_t i = 0; i < dimension; i++) { - entity.float_data[i] = (float)(k % (i + 1)); + entity.float_data[i] = (float)((k + 100) % (i + 1)); } entity_array.emplace_back(entity); @@ -249,4 +249,62 @@ Utils::PrintCollectionInfo(const milvus::CollectionInfo& info) { BLOCK_SPLITER } +void ConstructVector(uint64_t nq, uint64_t dimension, std::vector& query_vector) { + query_vector.resize(nq); + for (uint64_t i = 0; i < nq; ++i) { + query_vector[i].float_data.resize(dimension); + for (uint64_t j = 0; j < dimension; ++j) { + query_vector[i].float_data[j] = (float)((i + 100) / (j + 1)); + } + } +} + +std::vector +Utils::GenLeafQuery() { + //Construct TermQuery + std::vector field_value; + field_value.resize(1000); + for (uint64_t i = 0; i < 1000; ++i) { + field_value[i] = std::to_string(i); + } + milvus::TermQueryPtr tq = std::make_shared(); + tq->field_name = "field_1"; + tq->field_value = field_value; + + //Construct RangeQuery + milvus::CompareExpr ce1 = {milvus::CompareOperator::LTE, "10000"}, ce2 = {milvus::CompareOperator::GTE, "1"}; + std::vector ces{ce1, ce2}; + milvus::RangeQueryPtr rq = std::make_shared(); + rq->field_name = "field_2"; + rq->compare_expr = ces; + + //Construct VectorQuery + uint64_t NQ = 10; + uint64_t DIMENSION = 128; + uint64_t NPROBE = 32; + milvus::VectorQueryPtr vq = std::make_shared(); + ConstructVector(NQ, DIMENSION, vq->query_vector); + vq->field_name = "field_3"; + vq->topk = 10; + JSON json_params = {{"nprobe", NPROBE}}; + vq->extra_params = json_params.dump(); + + + std::vector lq; + milvus::LeafQueryPtr lq1 = std::make_shared(); + milvus::LeafQueryPtr lq2 = std::make_shared(); + milvus::LeafQueryPtr lq3 = std::make_shared(); + lq.emplace_back(lq1); + lq.emplace_back(lq2); + lq.emplace_back(lq3); + lq1->term_query_ptr = tq; + lq2->range_query_ptr = rq; + lq3->vector_query_ptr = vq; + + lq1->query_boost = 1.0; + lq2->query_boost = 2.0; + lq3->query_boost = 3.0; + return lq; +} + } // namespace milvus_sdk diff --git a/sdk/examples/utils/Utils.h b/sdk/examples/utils/Utils.h index f83ee069b7..4c4692bf76 100644 --- a/sdk/examples/utils/Utils.h +++ b/sdk/examples/utils/Utils.h @@ -12,6 +12,7 @@ #pragma once #include "MilvusApi.h" +#include "BooleanQuery.h" #include "thirdparty/nlohmann/json.hpp" #include @@ -72,6 +73,9 @@ class Utils { static void PrintCollectionInfo(const milvus::CollectionInfo& collection_info); + + static std::vector + GenLeafQuery(); }; } // namespace milvus_sdk diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc index 2276765803..72fd9653d7 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc @@ -44,6 +44,20 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/PreloadCollection", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", + "/milvus.grpc.MilvusService/CreateHybridCollection", + "/milvus.grpc.MilvusService/HasHybridCollection", + "/milvus.grpc.MilvusService/DropHybridCollection", + "/milvus.grpc.MilvusService/DescribeHybridCollection", + "/milvus.grpc.MilvusService/CountHybridCollection", + "/milvus.grpc.MilvusService/ShowHybridCollections", + "/milvus.grpc.MilvusService/ShowHybridCollectionInfo", + "/milvus.grpc.MilvusService/PreloadHybridCollection", + "/milvus.grpc.MilvusService/InsertEntity", + "/milvus.grpc.MilvusService/HybridSearch", + "/milvus.grpc.MilvusService/HybridSearchInSegments", + "/milvus.grpc.MilvusService/GetEntityByID", + "/milvus.grpc.MilvusService/GetEntityIDs", + "/milvus.grpc.MilvusService/DeleteEntitiesByID", }; std::unique_ptr< MilvusService::Stub> MilvusService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) { @@ -77,6 +91,20 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_PreloadCollection_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Flush_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Compact_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CreateHybridCollection_(MilvusService_method_names[24], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasHybridCollection_(MilvusService_method_names[25], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropHybridCollection_(MilvusService_method_names[26], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeHybridCollection_(MilvusService_method_names[27], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountHybridCollection_(MilvusService_method_names[28], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollections_(MilvusService_method_names[29], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowHybridCollectionInfo_(MilvusService_method_names[30], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadHybridCollection_(MilvusService_method_names[31], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_InsertEntity_(MilvusService_method_names[32], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearch_(MilvusService_method_names[33], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HybridSearchInSegments_(MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityByID_(MilvusService_method_names[35], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_GetEntityIDs_(MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DeleteEntitiesByID_(MilvusService_method_names[37], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} ::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { @@ -751,6 +779,398 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, false); } +::grpc::Status MilvusService::Stub::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* MilvusService::Stub::AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Mapping>::Create(channel_.get(), cq, rpcmethod_DescribeHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* MilvusService::Stub::PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Mapping>::Create(channel_.get(), cq, rpcmethod_DescribeHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowHybridCollections_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollections_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* MilvusService::Stub::AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::MappingList>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollections_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* MilvusService::Stub::PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::MappingList>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollections_, context, request, false); +} + +::grpc::Status MilvusService::Stub::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowHybridCollectionInfo_, context, request, response); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowHybridCollectionInfo_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollectionInfo_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowHybridCollectionInfo_, context, request, false); +} + +::grpc::Status MilvusService::Stub::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadHybridCollection_, context, request, response); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadHybridCollection_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadHybridCollection_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadHybridCollection_, context, request, false); +} + +::grpc::Status MilvusService::Stub::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_InsertEntity_, context, request, response); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_InsertEntity_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_InsertEntity_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_InsertEntity_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HybridSearch_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearch_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearch_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearch_, context, request, false); +} + +::grpc::Status MilvusService::Stub::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HybridSearchInSegments_, context, request, response); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HybridSearchInSegments_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearchInSegments_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_HybridSearchInSegments_, context, request, false); +} + +::grpc::Status MilvusService::Stub::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetEntityByID_, context, request, response); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, false); +} + +::grpc::Status MilvusService::Stub::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_GetEntityIDs_, context, request, response); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityIDs_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_GetEntityIDs_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* MilvusService::Stub::PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntityIDs>::Create(channel_.get(), cq, rpcmethod_GetEntityIDs_, context, request, false); +} + +::grpc::Status MilvusService::Stub::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DeleteEntitiesByID_, context, request, response); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, std::move(f)); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, reactor); +} + +void MilvusService::Stub::experimental_async::DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteEntitiesByID_, context, request, response, reactor); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteEntitiesByID_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteEntitiesByID_, context, request, false); +} + MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[0], @@ -872,6 +1292,76 @@ MilvusService::Service::Service() { ::grpc::internal::RpcMethod::NORMAL_RPC, new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[24], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Mapping, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::CreateHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[25], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + std::mem_fn(&MilvusService::Service::HasHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[26], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DropHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[27], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( + std::mem_fn(&MilvusService::Service::DescribeHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[28], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + std::mem_fn(&MilvusService::Service::CountHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[29], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::MappingList>( + std::mem_fn(&MilvusService::Service::ShowHybridCollections), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[30], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + std::mem_fn(&MilvusService::Service::ShowHybridCollectionInfo), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[31], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::PreloadHybridCollection), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[32], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( + std::mem_fn(&MilvusService::Service::InsertEntity), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[33], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + std::mem_fn(&MilvusService::Service::HybridSearch), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[34], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( + std::mem_fn(&MilvusService::Service::HybridSearchInSegments), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[35], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + std::mem_fn(&MilvusService::Service::GetEntityByID), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[36], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( + std::mem_fn(&MilvusService::Service::GetEntityIDs), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MilvusService_method_names[37], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DeleteEntitiesByID), this))); } MilvusService::Service::~Service() { @@ -1045,6 +1535,104 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } +::grpc::Status MilvusService::Service::CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HasHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DropHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DescribeHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::CountHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::ShowHybridCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::ShowHybridCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::PreloadHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::HybridSearchInSegments(::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::GetEntityIDs(::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MilvusService::Service::DeleteEntitiesByID(::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response) { + (void) context; + (void) request; + (void) response; + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + } // namespace milvus } // namespace grpc diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h index c9f00d5e92..fd2b54b5a1 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h @@ -359,6 +359,117 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } + // *******************************New Interface******************************************* + // + virtual ::grpc::Status CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>> AsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>>(AsyncDescribeHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>> PrepareAsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>>(PrepareAsyncDescribeHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> AsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(AsyncCountHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountHybridCollectionRaw(context, request, cq)); + } + virtual ::grpc::Status ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>> AsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>>(AsyncShowHybridCollectionsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>> PrepareAsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>>(PrepareAsyncShowHybridCollectionsRaw(context, request, cq)); + } + virtual ::grpc::Status ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> AsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(AsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + virtual ::grpc::Status PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadHybridCollectionRaw(context, request, cq)); + } + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual ::grpc::Status InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> AsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(AsyncInsertEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> PrepareAsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(PrepareAsyncInsertEntityRaw(context, request, cq)); + } + // TODO(yukun): will change to HQueryResult + virtual ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchRaw(context, request, cq)); + } + virtual ::grpc::Status HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + virtual ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>>(AsyncGetEntityByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>>(PrepareAsyncGetEntityByIDRaw(context, request, cq)); + } + virtual ::grpc::Status GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> AsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(AsyncGetEntityIDsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>> PrepareAsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>>(PrepareAsyncGetEntityIDsRaw(context, request, cq)); + } + virtual ::grpc::Status DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDeleteEntitiesByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDeleteEntitiesByIDRaw(context, request, cq)); + } class experimental_async_interface { public: virtual ~experimental_async_interface() {} @@ -602,6 +713,75 @@ class MilvusService final { virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // *******************************New Interface******************************************* + // + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // TODO(yukun): will change to HQueryResult + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; }; virtual class experimental_async_interface* experimental_async() { return nullptr; } private: @@ -653,6 +833,34 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>* AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Mapping>* PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>* AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::MappingList>* PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntityIDs>* PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: @@ -825,6 +1033,104 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } + ::grpc::Status CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Mapping* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>> AsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>>(AsyncDescribeHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>> PrepareAsyncDescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>>(PrepareAsyncDescribeHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> AsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(AsyncCountHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::MappingList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>> AsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>>(AsyncShowHybridCollectionsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>> PrepareAsyncShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>>(PrepareAsyncShowHybridCollectionsRaw(context, request, cq)); + } + ::grpc::Status ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> AsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(AsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowHybridCollectionInfoRaw(context, request, cq)); + } + ::grpc::Status PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadHybridCollectionRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadHybridCollectionRaw(context, request, cq)); + } + ::grpc::Status InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::milvus::grpc::HEntityIDs* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> AsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(AsyncInsertEntityRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> PrepareAsyncInsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(PrepareAsyncInsertEntityRaw(context, request, cq)); + } + ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::TopKQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchRaw(context, request, cq)); + } + ::grpc::Status HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::milvus::grpc::TopKQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> AsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(AsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>> PrepareAsyncHybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>>(PrepareAsyncHybridSearchInSegmentsRaw(context, request, cq)); + } + ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::milvus::grpc::HEntity* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>>(AsyncGetEntityByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>>(PrepareAsyncGetEntityByIDRaw(context, request, cq)); + } + ::grpc::Status GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::milvus::grpc::HEntityIDs* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> AsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(AsyncGetEntityIDsRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>> PrepareAsyncGetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>>(PrepareAsyncGetEntityIDsRaw(context, request, cq)); + } + ::grpc::Status DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDeleteEntitiesByIDRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDeleteEntitiesByIDRaw(context, request, cq)); + } class experimental_async final : public StubInterface::experimental_async_interface { public: @@ -924,6 +1230,62 @@ class MilvusService final { void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, std::function) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, std::function) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, std::function) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Mapping* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, std::function) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, std::function) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::MappingList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowHybridCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadHybridCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void InsertEntity(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void InsertEntity(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearchInSegments(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, std::function) override; + void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, std::function) override; + void GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, std::function) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void GetEntityIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HEntityIDs* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, std::function) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DeleteEntitiesByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; private: friend class Stub; explicit experimental_async(Stub* stub): stub_(stub) { } @@ -983,6 +1345,34 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::Mapping& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* AsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Mapping>* PrepareAsyncDescribeHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* AsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* AsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::MappingList>* PrepareAsyncShowHybridCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* AsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowHybridCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadHybridCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* AsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* PrepareAsyncInsertEntityRaw(::grpc::ClientContext* context, const ::milvus::grpc::HInsertParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* AsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* PrepareAsyncHybridSearchInSegmentsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchInSegmentsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HEntityIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* AsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntityIDs>* PrepareAsyncGetEntityIDsRaw(::grpc::ClientContext* context, const ::milvus::grpc::HGetEntityIDsParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteEntitiesByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::HDeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; const ::grpc::internal::RpcMethod rpcmethod_CreateCollection_; const ::grpc::internal::RpcMethod rpcmethod_HasCollection_; const ::grpc::internal::RpcMethod rpcmethod_DescribeCollection_; @@ -1007,6 +1397,20 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; + const ::grpc::internal::RpcMethod rpcmethod_CreateHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_HasHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DropHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DescribeHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_CountHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ShowHybridCollections_; + const ::grpc::internal::RpcMethod rpcmethod_ShowHybridCollectionInfo_; + const ::grpc::internal::RpcMethod rpcmethod_PreloadHybridCollection_; + const ::grpc::internal::RpcMethod rpcmethod_InsertEntity_; + const ::grpc::internal::RpcMethod rpcmethod_HybridSearch_; + const ::grpc::internal::RpcMethod rpcmethod_HybridSearchInSegments_; + const ::grpc::internal::RpcMethod rpcmethod_GetEntityByID_; + const ::grpc::internal::RpcMethod rpcmethod_GetEntityIDs_; + const ::grpc::internal::RpcMethod rpcmethod_DeleteEntitiesByID_; }; static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); @@ -1182,6 +1586,33 @@ class MilvusService final { // // @return Status virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + // *******************************New Interface******************************************* + // + virtual ::grpc::Status CreateHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::Mapping* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status HasHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response); + virtual ::grpc::Status DropHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Mapping* response); + virtual ::grpc::Status CountHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response); + virtual ::grpc::Status ShowHybridCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::MappingList* response); + virtual ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response); + virtual ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); + // ///////////////////////////////////////////////////////////////// + // + // rpc CreateIndex(IndexParam) returns (Status) {} + // + // rpc DescribeIndex(CollectionName) returns (IndexParam) {} + // + // rpc DropIndex(CollectionName) returns (Status) {} + // + // ///////////////////////////////////////////////////////////////// + // + virtual ::grpc::Status InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response); + // TODO(yukun): will change to HQueryResult + virtual ::grpc::Status HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response); + virtual ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* context, const ::milvus::grpc::HSearchInSegmentsParam* request, ::milvus::grpc::TopKQueryResult* response); + virtual ::grpc::Status GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response); + virtual ::grpc::Status GetEntityIDs(::grpc::ServerContext* context, const ::milvus::grpc::HGetEntityIDsParam* request, ::milvus::grpc::HEntityIDs* response); + virtual ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* context, const ::milvus::grpc::HDeleteByIDParam* request, ::milvus::grpc::Status* response); }; template class WithAsyncMethod_CreateCollection : public BaseClass { @@ -1663,7 +2094,287 @@ class MilvusService final { ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + template + class WithAsyncMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodAsync(24); + } + ~WithAsyncMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCreateHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::Mapping* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodAsync(25); + } + ~WithAsyncMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHasHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodAsync(26); + } + ~WithAsyncMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDropHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodAsync(27); + } + ~WithAsyncMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Mapping>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodAsync(28); + } + ~WithAsyncMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCountHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodAsync(29); + } + ~WithAsyncMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::MappingList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodAsync(30); + } + ~WithAsyncMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodAsync(31); + } + ~WithAsyncMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_InsertEntity() { + ::grpc::Service::MarkMethodAsync(32); + } + ~WithAsyncMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestInsertEntity(::grpc::ServerContext* context, ::milvus::grpc::HInsertParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HybridSearch() { + ::grpc::Service::MarkMethodAsync(33); + } + ~WithAsyncMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodAsync(34); + } + ~WithAsyncMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::milvus::grpc::HSearchInSegmentsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResult>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetEntityByID() { + ::grpc::Service::MarkMethodAsync(35); + } + ~WithAsyncMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::HEntityIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodAsync(36); + } + ~WithAsyncMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityIDs(::grpc::ServerContext* context, ::milvus::grpc::HGetEntityIDsParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntityIDs>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithAsyncMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodAsync(37); + } + ~WithAsyncMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::milvus::grpc::HDeleteByIDParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: @@ -2408,7 +3119,441 @@ class MilvusService final { } virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + template + class ExperimentalWithCallbackMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_CreateHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(24, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::Mapping* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->CreateHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_CreateHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Mapping, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(24)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HasHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(25, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::BoolReply* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HasHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HasHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( + ::grpc::Service::experimental().GetHandler(25)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DropHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(26, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DropHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DropHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(26)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DescribeHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(27, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Mapping* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DescribeHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DescribeHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>*>( + ::grpc::Service::experimental().GetHandler(27)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_CountHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(28, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->CountHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_CountHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( + ::grpc::Service::experimental().GetHandler(28)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ShowHybridCollections() { + ::grpc::Service::experimental().MarkMethodCallback(29, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::Command* request, + ::milvus::grpc::MappingList* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ShowHybridCollections(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ShowHybridCollections( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::MappingList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>*>( + ::grpc::Service::experimental().GetHandler(29)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() { + ::grpc::Service::experimental().MarkMethodCallback(30, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->ShowHybridCollectionInfo(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_ShowHybridCollectionInfo( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( + ::grpc::Service::experimental().GetHandler(30)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_PreloadHybridCollection() { + ::grpc::Service::experimental().MarkMethodCallback(31, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->PreloadHybridCollection(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_PreloadHybridCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(31)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_InsertEntity() { + ::grpc::Service::experimental().MarkMethodCallback(32, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HInsertParam* request, + ::milvus::grpc::HEntityIDs* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->InsertEntity(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_InsertEntity( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>*>( + ::grpc::Service::experimental().GetHandler(32)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HybridSearch() { + ::grpc::Service::experimental().MarkMethodCallback(33, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HSearchParam* request, + ::milvus::grpc::TopKQueryResult* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HybridSearch(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HybridSearch( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>*>( + ::grpc::Service::experimental().GetHandler(33)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_HybridSearchInSegments() { + ::grpc::Service::experimental().MarkMethodCallback(34, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HSearchInSegmentsParam* request, + ::milvus::grpc::TopKQueryResult* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->HybridSearchInSegments(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_HybridSearchInSegments( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>*>( + ::grpc::Service::experimental().GetHandler(34)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_GetEntityByID() { + ::grpc::Service::experimental().MarkMethodCallback(35, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HEntityIdentity* request, + ::milvus::grpc::HEntity* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->GetEntityByID(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_GetEntityByID( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>*>( + ::grpc::Service::experimental().GetHandler(35)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_GetEntityIDs() { + ::grpc::Service::experimental().MarkMethodCallback(36, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HGetEntityIDsParam* request, + ::milvus::grpc::HEntityIDs* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->GetEntityIDs(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_GetEntityIDs( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>*>( + ::grpc::Service::experimental().GetHandler(36)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithCallbackMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithCallbackMethod_DeleteEntitiesByID() { + ::grpc::Service::experimental().MarkMethodCallback(37, + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>( + [this](::grpc::ServerContext* context, + const ::milvus::grpc::HDeleteByIDParam* request, + ::milvus::grpc::Status* response, + ::grpc::experimental::ServerCallbackRpcController* controller) { + return this->DeleteEntitiesByID(context, request, response, controller); + })); + } + void SetMessageAllocatorFor_DeleteEntitiesByID( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>*>( + ::grpc::Service::experimental().GetHandler(37)) + ->SetMessageAllocator(allocator); + } + ~ExperimentalWithCallbackMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template class WithGenericMethod_CreateCollection : public BaseClass { private: @@ -2818,6 +3963,244 @@ class MilvusService final { } }; template + class WithGenericMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodGeneric(24); + } + ~WithGenericMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodGeneric(25); + } + ~WithGenericMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodGeneric(26); + } + ~WithGenericMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodGeneric(27); + } + ~WithGenericMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodGeneric(28); + } + ~WithGenericMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodGeneric(29); + } + ~WithGenericMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodGeneric(30); + } + ~WithGenericMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodGeneric(31); + } + ~WithGenericMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_InsertEntity() { + ::grpc::Service::MarkMethodGeneric(32); + } + ~WithGenericMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HybridSearch() { + ::grpc::Service::MarkMethodGeneric(33); + } + ~WithGenericMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodGeneric(34); + } + ~WithGenericMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetEntityByID() { + ::grpc::Service::MarkMethodGeneric(35); + } + ~WithGenericMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodGeneric(36); + } + ~WithGenericMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithGenericMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodGeneric(37); + } + ~WithGenericMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template class WithRawMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -3298,6 +4681,286 @@ class MilvusService final { } }; template + class WithRawMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodRaw(24); + } + ~WithRawMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(24, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodRaw(25); + } + ~WithRawMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHasHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(25, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodRaw(26); + } + ~WithRawMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDropHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(26, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodRaw(27); + } + ~WithRawMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(27, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodRaw(28); + } + ~WithRawMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestCountHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(28, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodRaw(29); + } + ~WithRawMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(29, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodRaw(30); + } + ~WithRawMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(30, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodRaw(31); + } + ~WithRawMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(31, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_InsertEntity() { + ::grpc::Service::MarkMethodRaw(32); + } + ~WithRawMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestInsertEntity(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(32, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HybridSearch() { + ::grpc::Service::MarkMethodRaw(33); + } + ~WithRawMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearch(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(33, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodRaw(34); + } + ~WithRawMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(34, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetEntityByID() { + ::grpc::Service::MarkMethodRaw(35); + } + ~WithRawMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(35, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodRaw(36); + } + ~WithRawMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetEntityIDs(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithRawMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithRawMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodRaw(37); + } + ~WithRawMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(37, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template class ExperimentalWithRawCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -3898,6 +5561,356 @@ class MilvusService final { virtual void Compact(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template + class ExperimentalWithRawCallbackMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_CreateHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(24, + 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->CreateHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HasHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(25, + 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->HasHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HasHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DropHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(26, + 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->DropHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DropHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DescribeHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(27, + 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->DescribeHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_CountHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(28, + 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->CountHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void CountHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ShowHybridCollections() { + ::grpc::Service::experimental().MarkMethodRawCallback(29, + 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->ShowHybridCollections(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() { + ::grpc::Service::experimental().MarkMethodRawCallback(30, + 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->ShowHybridCollectionInfo(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_PreloadHybridCollection() { + ::grpc::Service::experimental().MarkMethodRawCallback(31, + 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->PreloadHybridCollection(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_InsertEntity() { + ::grpc::Service::experimental().MarkMethodRawCallback(32, + 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->InsertEntity(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void InsertEntity(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HybridSearch() { + ::grpc::Service::experimental().MarkMethodRawCallback(33, + 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->HybridSearch(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_HybridSearchInSegments() { + ::grpc::Service::experimental().MarkMethodRawCallback(34, + 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->HybridSearchInSegments(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_GetEntityByID() { + ::grpc::Service::experimental().MarkMethodRawCallback(35, + 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->GetEntityByID(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_GetEntityIDs() { + ::grpc::Service::experimental().MarkMethodRawCallback(36, + 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->GetEntityIDs(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void GetEntityIDs(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template + class ExperimentalWithRawCallbackMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() { + ::grpc::Service::experimental().MarkMethodRawCallback(37, + 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->DeleteEntitiesByID(context, request, response, controller); + })); + } + ~ExperimentalWithRawCallbackMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + virtual void DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + }; + template class WithStreamedUnaryMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} @@ -4377,9 +6390,289 @@ class MilvusService final { // replace default version of method with streamed unary virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + template + class WithStreamedUnaryMethod_CreateHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_CreateHybridCollection() { + ::grpc::Service::MarkMethodStreamed(24, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Mapping, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateHybridCollection::StreamedCreateHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_CreateHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CreateHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Mapping* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCreateHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Mapping,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HasHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HasHybridCollection() { + ::grpc::Service::MarkMethodStreamed(25, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasHybridCollection::StreamedHasHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HasHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HasHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHasHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DropHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DropHybridCollection() { + ::grpc::Service::MarkMethodStreamed(26, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropHybridCollection::StreamedDropHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DropHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DropHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDropHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DescribeHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DescribeHybridCollection() { + ::grpc::Service::MarkMethodStreamed(27, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Mapping>(std::bind(&WithStreamedUnaryMethod_DescribeHybridCollection::StreamedDescribeHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DescribeHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DescribeHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Mapping* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDescribeHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Mapping>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_CountHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_CountHybridCollection() { + ::grpc::Service::MarkMethodStreamed(28, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountHybridCollection::StreamedCountHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_CountHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status CountHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedCountHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionRowCount>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ShowHybridCollections : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ShowHybridCollections() { + ::grpc::Service::MarkMethodStreamed(29, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::MappingList>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollections::StreamedShowHybridCollections, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ShowHybridCollections() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ShowHybridCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::MappingList* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedShowHybridCollections(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::MappingList>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_ShowHybridCollectionInfo : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_ShowHybridCollectionInfo() { + ::grpc::Service::MarkMethodStreamed(30, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowHybridCollectionInfo::StreamedShowHybridCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_ShowHybridCollectionInfo() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status ShowHybridCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedShowHybridCollectionInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionInfo>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_PreloadHybridCollection : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_PreloadHybridCollection() { + ::grpc::Service::MarkMethodStreamed(31, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadHybridCollection::StreamedPreloadHybridCollection, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_PreloadHybridCollection() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status PreloadHybridCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedPreloadHybridCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_InsertEntity : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_InsertEntity() { + ::grpc::Service::MarkMethodStreamed(32, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HInsertParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_InsertEntity::StreamedInsertEntity, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_InsertEntity() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status InsertEntity(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HInsertParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedInsertEntity(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HInsertParam,::milvus::grpc::HEntityIDs>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HybridSearch : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HybridSearch() { + ::grpc::Service::MarkMethodStreamed(33, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HybridSearch() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHybridSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_HybridSearchInSegments : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_HybridSearchInSegments() { + ::grpc::Service::MarkMethodStreamed(34, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchInSegmentsParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearchInSegments::StreamedHybridSearchInSegments, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_HybridSearchInSegments() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status HybridSearchInSegments(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchInSegmentsParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedHybridSearchInSegments(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchInSegmentsParam,::milvus::grpc::TopKQueryResult>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetEntityByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetEntityByID() { + ::grpc::Service::MarkMethodStreamed(35, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_GetEntityByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetEntityByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HEntityIdentity,::milvus::grpc::HEntity>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_GetEntityIDs : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_GetEntityIDs() { + ::grpc::Service::MarkMethodStreamed(36, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HGetEntityIDsParam, ::milvus::grpc::HEntityIDs>(std::bind(&WithStreamedUnaryMethod_GetEntityIDs::StreamedGetEntityIDs, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_GetEntityIDs() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status GetEntityIDs(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HGetEntityIDsParam* /*request*/, ::milvus::grpc::HEntityIDs* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedGetEntityIDs(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HGetEntityIDsParam,::milvus::grpc::HEntityIDs>* server_unary_streamer) = 0; + }; + template + class WithStreamedUnaryMethod_DeleteEntitiesByID : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} + public: + WithStreamedUnaryMethod_DeleteEntitiesByID() { + ::grpc::Service::MarkMethodStreamed(37, + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HDeleteByIDParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DeleteEntitiesByID::StreamedDeleteEntitiesByID, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_DeleteEntitiesByID() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status DeleteEntitiesByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HDeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/) override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedDeleteEntitiesByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HDeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.pb.cc index ed3d048ff6..f5fc22f6d1 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.cc @@ -15,12 +15,26 @@ #include // @@protoc_insertion_point(includes) #include +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldParam_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldType_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldValue_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HEntity_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HSearchParam_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Mapping_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PartitionStat_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_milvus_2eproto; 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_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_SegmentStat_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_TermQuery_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldValue_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto; namespace milvus { namespace grpc { class KeyValuePairDefaultTypeInternal { @@ -127,8 +141,131 @@ class GetVectorIDsParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _GetVectorIDsParam_default_instance_; +class VectorFieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldParam_default_instance_; +class FieldTypeDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + int data_type_; + const ::milvus::grpc::VectorFieldParam* vector_param_; +} _FieldType_default_instance_; +class FieldParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _FieldParam_default_instance_; +class VectorFieldValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldValue_default_instance_; +class FieldValueDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_; + bool bool_value_; + const ::milvus::grpc::VectorFieldValue* vector_value_; +} _FieldValue_default_instance_; +class MappingDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _Mapping_default_instance_; +class MappingListDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _MappingList_default_instance_; +class TermQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _TermQuery_default_instance_; +class CompareExprDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CompareExpr_default_instance_; +class RangeQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _RangeQuery_default_instance_; +class VectorQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorQuery_default_instance_; +class BooleanQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _BooleanQuery_default_instance_; +class GeneralQueryDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; + const ::milvus::grpc::BooleanQuery* boolean_query_; + const ::milvus::grpc::TermQuery* term_query_; + const ::milvus::grpc::RangeQuery* range_query_; + const ::milvus::grpc::VectorQuery* vector_query_; +} _GeneralQuery_default_instance_; +class HSearchParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HSearchParam_default_instance_; +class HSearchInSegmentsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HSearchInSegmentsParam_default_instance_; +class AttrRecordDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _AttrRecord_default_instance_; +class HEntityDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntity_default_instance_; +class HQueryResultDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HQueryResult_default_instance_; +class HInsertParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HInsertParam_default_instance_; +class HEntityIdentityDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntityIdentity_default_instance_; +class HEntityIDsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HEntityIDs_default_instance_; +class HGetEntityIDsParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HGetEntityIDsParam_default_instance_; +class HDeleteByIDParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HDeleteByIDParam_default_instance_; +class HIndexParamDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _HIndexParam_default_instance_; } // namespace grpc } // namespace milvus +static void InitDefaultsscc_info_AttrRecord_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_AttrRecord_default_instance_; + new (ptr) ::milvus::grpc::AttrRecord(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::AttrRecord::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_AttrRecord_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_AttrRecord_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -144,6 +281,29 @@ static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_BooleanQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_BooleanQuery_default_instance_; + new (ptr) ::milvus::grpc::BooleanQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + { + void* ptr = &::milvus::grpc::_GeneralQuery_default_instance_; + new (ptr) ::milvus::grpc::GeneralQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::BooleanQuery::InitAsDefaultInstance(); + ::milvus::grpc::GeneralQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_BooleanQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_BooleanQuery_milvus_2eproto}, { + &scc_info_TermQuery_milvus_2eproto.base, + &scc_info_RangeQuery_milvus_2eproto.base, + &scc_info_VectorQuery_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_CollectionInfo_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -234,6 +394,20 @@ static void InitDefaultsscc_info_Command_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Command_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Command_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_CompareExpr_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CompareExpr_default_instance_; + new (ptr) ::milvus::grpc::CompareExpr(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CompareExpr::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CompareExpr_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CompareExpr_milvus_2eproto}, {}}; + static void InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -248,6 +422,52 @@ static void InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_DeleteByIDParam_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_DeleteByIDParam_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_FieldParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldParam_default_instance_; + new (ptr) ::milvus::grpc::FieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_FieldParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_FieldParam_milvus_2eproto}, { + &scc_info_FieldType_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldType_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldType_default_instance_; + new (ptr) ::milvus::grpc::FieldType(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldType::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldType_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldType_milvus_2eproto}, { + &scc_info_VectorFieldParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_FieldValue_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_FieldValue_default_instance_; + new (ptr) ::milvus::grpc::FieldValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::FieldValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_FieldValue_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_FieldValue_milvus_2eproto}, { + &scc_info_VectorFieldValue_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_FlushParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -276,6 +496,159 @@ static void InitDefaultsscc_info_GetVectorIDsParam_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_GetVectorIDsParam_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_GetVectorIDsParam_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_HDeleteByIDParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HDeleteByIDParam_default_instance_; + new (ptr) ::milvus::grpc::HDeleteByIDParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HDeleteByIDParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HDeleteByIDParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HDeleteByIDParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HEntity_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntity_default_instance_; + new (ptr) ::milvus::grpc::HEntity(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntity::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HEntity_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_HEntity_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_AttrRecord_milvus_2eproto.base, + &scc_info_FieldValue_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HEntityIDs_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntityIDs_default_instance_; + new (ptr) ::milvus::grpc::HEntityIDs(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntityIDs::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HEntityIDs_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_HEntityIDs_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_HEntityIdentity_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HEntityIdentity_default_instance_; + new (ptr) ::milvus::grpc::HEntityIdentity(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HEntityIdentity::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HEntityIdentity_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HEntityIdentity_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HGetEntityIDsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HGetEntityIDsParam_default_instance_; + new (ptr) ::milvus::grpc::HGetEntityIDsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HGetEntityIDsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HGetEntityIDsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_HGetEntityIDsParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_HIndexParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HIndexParam_default_instance_; + new (ptr) ::milvus::grpc::HIndexParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HIndexParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HIndexParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HIndexParam_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HInsertParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HInsertParam_default_instance_; + new (ptr) ::milvus::grpc::HInsertParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HInsertParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HInsertParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HInsertParam_milvus_2eproto}, { + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HQueryResult_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HQueryResult_default_instance_; + new (ptr) ::milvus::grpc::HQueryResult(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HQueryResult::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HQueryResult_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HQueryResult_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_HEntity_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HSearchInSegmentsParam_default_instance_; + new (ptr) ::milvus::grpc::HSearchInSegmentsParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HSearchInSegmentsParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_HSearchInSegmentsParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto}, { + &scc_info_HSearchParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_HSearchParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_HSearchParam_default_instance_; + new (ptr) ::milvus::grpc::HSearchParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::HSearchParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HSearchParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HSearchParam_milvus_2eproto}, { + &scc_info_BooleanQuery_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_IndexParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -322,6 +695,38 @@ static void InitDefaultsscc_info_KeyValuePair_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_KeyValuePair_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_KeyValuePair_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_Mapping_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_Mapping_default_instance_; + new (ptr) ::milvus::grpc::Mapping(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::Mapping::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_Mapping_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_Mapping_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_FieldParam_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_MappingList_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_MappingList_default_instance_; + new (ptr) ::milvus::grpc::MappingList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::MappingList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_MappingList_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_MappingList_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_Mapping_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_PartitionList_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -366,6 +771,22 @@ static void InitDefaultsscc_info_PartitionStat_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PartitionStat_milvus_2eproto}, { &scc_info_SegmentStat_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_RangeQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_RangeQuery_default_instance_; + new (ptr) ::milvus::grpc::RangeQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::RangeQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_RangeQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_RangeQuery_milvus_2eproto}, { + &scc_info_CompareExpr_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_RowRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -455,6 +876,21 @@ static void InitDefaultsscc_info_StringReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_TermQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_TermQuery_default_instance_; + new (ptr) ::milvus::grpc::TermQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::TermQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TermQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TermQuery_milvus_2eproto}, { + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -486,6 +922,35 @@ static void InitDefaultsscc_info_VectorData_milvus_2eproto() { &scc_info_Status_status_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base,}}; +static void InitDefaultsscc_info_VectorFieldParam_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldParam_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldParam(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldParam::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_VectorFieldParam_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_VectorFieldParam_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_VectorFieldValue_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorFieldValue_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldValue(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorFieldValue::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldValue_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorFieldValue_milvus_2eproto}, { + &scc_info_RowRecord_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_VectorIdentity_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -515,8 +980,24 @@ 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[26]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_milvus_2eproto = nullptr; +static void InitDefaultsscc_info_VectorQuery_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_VectorQuery_default_instance_; + new (ptr) ::milvus::grpc::VectorQuery(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::VectorQuery::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_VectorQuery_milvus_2eproto}, { + &scc_info_RowRecord_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[50]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -720,6 +1201,205 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, segment_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldParam, dimension_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, data_type_), + offsetof(::milvus::grpc::FieldTypeDefaultTypeInternal, vector_param_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldType, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, int32_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, int64_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, float_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, double_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, string_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, bool_value_), + offsetof(::milvus::grpc::FieldValueDefaultTypeInternal, vector_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FieldValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, collection_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::Mapping, fields_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::MappingList, mapping_list_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, values_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operator__), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CompareExpr, operand_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, operand_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::RangeQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, field_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, query_boost_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, topk_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorQuery, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, occur_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::BooleanQuery, general_query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, boolean_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, term_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, range_query_), + offsetof(::milvus::grpc::GeneralQueryDefaultTypeInternal, vector_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GeneralQuery, query_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, partition_tag_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, general_query_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, segment_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HSearchInSegmentsParam, search_param_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, entity_id_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, field_names_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, attr_records_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, result_values_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, entities_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, row_num_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, score_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, distance_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, partition_tag_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entities_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entity_id_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, extra_params_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIdentity, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntityIDs, entity_id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HGetEntityIDsParam, segment_name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HDeleteByIDParam, id_array_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, index_type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HIndexParam, extra_params_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::milvus::grpc::KeyValuePair)}, @@ -748,6 +1428,30 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 179, -1, sizeof(::milvus::grpc::VectorIdentity)}, { 186, -1, sizeof(::milvus::grpc::VectorData)}, { 193, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, + { 200, -1, sizeof(::milvus::grpc::VectorFieldParam)}, + { 206, -1, sizeof(::milvus::grpc::FieldType)}, + { 214, -1, sizeof(::milvus::grpc::FieldParam)}, + { 223, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 229, -1, sizeof(::milvus::grpc::FieldValue)}, + { 242, -1, sizeof(::milvus::grpc::Mapping)}, + { 251, -1, sizeof(::milvus::grpc::MappingList)}, + { 258, -1, sizeof(::milvus::grpc::TermQuery)}, + { 267, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 274, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 283, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 293, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 300, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 310, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 319, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 326, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 332, -1, sizeof(::milvus::grpc::HEntity)}, + { 342, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 352, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 362, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 369, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 376, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 383, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 390, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -777,6 +1481,30 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_VectorIdentity_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorData_default_instance_), reinterpret_cast(&::milvus::grpc::_GetVectorIDsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldType_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorFieldValue_default_instance_), + reinterpret_cast(&::milvus::grpc::_FieldValue_default_instance_), + reinterpret_cast(&::milvus::grpc::_Mapping_default_instance_), + reinterpret_cast(&::milvus::grpc::_MappingList_default_instance_), + reinterpret_cast(&::milvus::grpc::_TermQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_CompareExpr_default_instance_), + reinterpret_cast(&::milvus::grpc::_RangeQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_VectorQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_BooleanQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_GeneralQuery_default_instance_), + reinterpret_cast(&::milvus::grpc::_HSearchParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HSearchInSegmentsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_AttrRecord_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntity_default_instance_), + reinterpret_cast(&::milvus::grpc::_HQueryResult_default_instance_), + reinterpret_cast(&::milvus::grpc::_HInsertParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntityIdentity_default_instance_), + reinterpret_cast(&::milvus::grpc::_HEntityIDs_default_instance_), + reinterpret_cast(&::milvus::grpc::_HGetEntityIDsParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HDeleteByIDParam_default_instance_), + reinterpret_cast(&::milvus::grpc::_HIndexParam_default_instance_), }; const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = @@ -841,95 +1569,280 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "\001(\0132\023.milvus.grpc.Status\022+\n\013vector_data\030" "\002 \001(\0132\026.milvus.grpc.RowRecord\"B\n\021GetVect" "orIDsParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014s" - "egment_name\030\002 \001(\t2\276\r\n\rMilvusService\022H\n\020C" - "reateCollection\022\035.milvus.grpc.Collection" - "Schema\032\023.milvus.grpc.Status\"\000\022F\n\rHasColl" - "ection\022\033.milvus.grpc.CollectionName\032\026.mi" - "lvus.grpc.BoolReply\"\000\022R\n\022DescribeCollect" - "ion\022\033.milvus.grpc.CollectionName\032\035.milvu" - "s.grpc.CollectionSchema\"\000\022Q\n\017CountCollec" - "tion\022\033.milvus.grpc.CollectionName\032\037.milv" - "us.grpc.CollectionRowCount\"\000\022J\n\017ShowColl" - "ections\022\024.milvus.grpc.Command\032\037.milvus.g" - "rpc.CollectionNameList\"\000\022P\n\022ShowCollecti" - "onInfo\022\033.milvus.grpc.CollectionName\032\033.mi" - "lvus.grpc.CollectionInfo\"\000\022D\n\016DropCollec" - "tion\022\033.milvus.grpc.CollectionName\032\023.milv" - "us.grpc.Status\"\000\022=\n\013CreateIndex\022\027.milvus" - ".grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022" - "G\n\rDescribeIndex\022\033.milvus.grpc.Collectio" - "nName\032\027.milvus.grpc.IndexParam\"\000\022\?\n\tDrop" - "Index\022\033.milvus.grpc.CollectionName\032\023.mil" - "vus.grpc.Status\"\000\022E\n\017CreatePartition\022\033.m" - "ilvus.grpc.PartitionParam\032\023.milvus.grpc." - "Status\"\000\022K\n\016ShowPartitions\022\033.milvus.grpc" - ".CollectionName\032\032.milvus.grpc.PartitionL" - "ist\"\000\022C\n\rDropPartition\022\033.milvus.grpc.Par" - "titionParam\032\023.milvus.grpc.Status\"\000\022<\n\006In" - "sert\022\030.milvus.grpc.InsertParam\032\026.milvus." - "grpc.VectorIds\"\000\022G\n\rGetVectorByID\022\033.milv" - "us.grpc.VectorIdentity\032\027.milvus.grpc.Vec" - "torData\"\000\022H\n\014GetVectorIDs\022\036.milvus.grpc." - "GetVectorIDsParam\032\026.milvus.grpc.VectorId" - "s\"\000\022B\n\006Search\022\030.milvus.grpc.SearchParam\032" - "\034.milvus.grpc.TopKQueryResult\"\000\022J\n\nSearc" - "hByID\022\034.milvus.grpc.SearchByIDParam\032\034.mi" - "lvus.grpc.TopKQueryResult\"\000\022P\n\rSearchInF" - "iles\022\037.milvus.grpc.SearchInFilesParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\0227\n\003Cmd\022\024.m" - "ilvus.grpc.Command\032\030.milvus.grpc.StringR" - "eply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.Delet" - "eByIDParam\032\023.milvus.grpc.Status\"\000\022G\n\021Pre" - "loadCollection\022\033.milvus.grpc.CollectionN" - "ame\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mi" - "lvus.grpc.FlushParam\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\007Compact\022\033.milvus.grpc.CollectionN" - "ame\032\023.milvus.grpc.Status\"\000b\006proto3" + "egment_name\030\002 \001(\t\"%\n\020VectorFieldParam\022\021\n" + "\tdimension\030\001 \001(\003\"w\n\tFieldType\022*\n\tdata_ty" + "pe\030\001 \001(\0162\025.milvus.grpc.DataTypeH\000\0225\n\014vec" + "tor_param\030\002 \001(\0132\035.milvus.grpc.VectorFiel" + "dParamH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 " + "\001(\004\022\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus" + ".grpc.FieldType\022/\n\014extra_params\030\004 \003(\0132\031." + "milvus.grpc.KeyValuePair\"9\n\020VectorFieldV" + "alue\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRec" + "ord\"\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H" + "\000\022\025\n\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030" + "\003 \001(\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014strin" + "g_value\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n" + "\014vector_value\030\007 \001(\0132\035.milvus.grpc.Vector" + "FieldValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006sta" + "tus\030\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollec" + "tion_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'" + "\n\006fields\030\004 \003(\0132\027.milvus.grpc.FieldParam\"" + "^\n\013MappingList\022#\n\006status\030\001 \001(\0132\023.milvus." + "grpc.Status\022*\n\014mapping_list\030\002 \003(\0132\024.milv" + "us.grpc.Mapping\"o\n\tTermQuery\022\022\n\nfield_na" + "me\030\001 \001(\t\022\016\n\006values\030\002 \003(\t\022\r\n\005boost\030\003 \001(\002\022" + "/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyV" + "aluePair\"N\n\013CompareExpr\022.\n\010operator\030\001 \001(" + "\0162\034.milvus.grpc.CompareOperator\022\017\n\007opera" + "nd\030\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfield_name\030\001 " + "\001(\t\022)\n\007operand\030\002 \003(\0132\030.milvus.grpc.Compa" + "reExpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra_params\030\004 " + "\003(\0132\031.milvus.grpc.KeyValuePair\"\236\001\n\013Vecto" + "rQuery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013query_boos" + "t\030\002 \001(\002\022\'\n\007records\030\003 \003(\0132\026.milvus.grpc.R" + "owRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extra_params\030\005" + " \003(\0132\031.milvus.grpc.KeyValuePair\"c\n\014Boole" + "anQuery\022!\n\005occur\030\001 \001(\0162\022.milvus.grpc.Occ" + "ur\0220\n\rgeneral_query\030\002 \003(\0132\031.milvus.grpc." + "GeneralQuery\"\333\001\n\014GeneralQuery\0222\n\rboolean" + "_query\030\001 \001(\0132\031.milvus.grpc.BooleanQueryH" + "\000\022,\n\nterm_query\030\002 \001(\0132\026.milvus.grpc.Term" + "QueryH\000\022.\n\013range_query\030\003 \001(\0132\027.milvus.gr" + "pc.RangeQueryH\000\0220\n\014vector_query\030\004 \001(\0132\030." + "milvus.grpc.VectorQueryH\000B\007\n\005query\"\247\001\n\014H" + "SearchParam\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023" + "partition_tag_array\030\002 \003(\t\0220\n\rgeneral_que" + "ry\030\003 \001(\0132\031.milvus.grpc.GeneralQuery\022/\n\014e" + "xtra_params\030\004 \003(\0132\031.milvus.grpc.KeyValue" + "Pair\"c\n\026HSearchInSegmentsParam\022\030\n\020segmen" + "t_id_array\030\001 \003(\t\022/\n\014search_param\030\002 \001(\0132\031" + ".milvus.grpc.HSearchParam\"\033\n\nAttrRecord\022" + "\r\n\005value\030\001 \003(\t\"\265\001\n\007HEntity\022#\n\006status\030\001 \001" + "(\0132\023.milvus.grpc.Status\022\021\n\tentity_id\030\002 \001" + "(\003\022\023\n\013field_names\030\003 \003(\t\022-\n\014attr_records\030" + "\004 \003(\0132\027.milvus.grpc.AttrRecord\022.\n\rresult" + "_values\030\005 \003(\0132\027.milvus.grpc.FieldValue\"\215" + "\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.milvus" + ".grpc.Status\022&\n\010entities\030\002 \003(\0132\024.milvus." + "grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005score\030\004" + " \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInsertParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\025\n\rpartition_ta" + "g\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milvus.grpc." + "HEntity\022\027\n\017entity_id_array\030\004 \003(\003\022/\n\014extr" + "a_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"6\n\017HEntityIdentity\022\027\n\017collection_name\030" + "\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022#\n\006statu" + "s\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017entity_i" + "d_array\030\002 \003(\003\"C\n\022HGetEntityIDsParam\022\027\n\017c" + "ollection_name\030\001 \001(\t\022\024\n\014segment_name\030\002 \001" + "(\t\"=\n\020HDeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HIndexPara" + "m\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" + "\n\017collection_name\030\002 \001(\t\022\022\n\nindex_type\030\003 " + "\001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc." + "KeyValuePair*\206\001\n\010DataType\022\010\n\004NULL\020\000\022\010\n\004I" + "NT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT64\020\004\022\n" + "\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022\n\n\006DOUBL" + "E\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n\017Compare" + "Operator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002GT\020" + "\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020\000" + "\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\0032\212\026\n" + "\rMilvusService\022H\n\020CreateCollection\022\035.mil" + "vus.grpc.CollectionSchema\032\023.milvus.grpc." + "Status\"\000\022F\n\rHasCollection\022\033.milvus.grpc." + "CollectionName\032\026.milvus.grpc.BoolReply\"\000" + "\022R\n\022DescribeCollection\022\033.milvus.grpc.Col" + "lectionName\032\035.milvus.grpc.CollectionSche" + "ma\"\000\022Q\n\017CountCollection\022\033.milvus.grpc.Co" + "llectionName\032\037.milvus.grpc.CollectionRow" + "Count\"\000\022J\n\017ShowCollections\022\024.milvus.grpc" + ".Command\032\037.milvus.grpc.CollectionNameLis" + "t\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.grpc." + "CollectionName\032\033.milvus.grpc.CollectionI" + "nfo\"\000\022D\n\016DropCollection\022\033.milvus.grpc.Co" + "llectionName\032\023.milvus.grpc.Status\"\000\022=\n\013C" + "reateIndex\022\027.milvus.grpc.IndexParam\032\023.mi" + "lvus.grpc.Status\"\000\022G\n\rDescribeIndex\022\033.mi" + "lvus.grpc.CollectionName\032\027.milvus.grpc.I" + "ndexParam\"\000\022\?\n\tDropIndex\022\033.milvus.grpc.C" + "ollectionName\032\023.milvus.grpc.Status\"\000\022E\n\017" + "CreatePartition\022\033.milvus.grpc.PartitionP" + "aram\032\023.milvus.grpc.Status\"\000\022K\n\016ShowParti" + "tions\022\033.milvus.grpc.CollectionName\032\032.mil" + "vus.grpc.PartitionList\"\000\022C\n\rDropPartitio" + "n\022\033.milvus.grpc.PartitionParam\032\023.milvus." + "grpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.In" + "sertParam\032\026.milvus.grpc.VectorIds\"\000\022G\n\rG" + "etVectorByID\022\033.milvus.grpc.VectorIdentit" + "y\032\027.milvus.grpc.VectorData\"\000\022H\n\014GetVecto" + "rIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026.m" + "ilvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.milvu" + "s.grpc.SearchParam\032\034.milvus.grpc.TopKQue" + "ryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc.S" + "earchByIDParam\032\034.milvus.grpc.TopKQueryRe" + "sult\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc.Se" + "archInFilesParam\032\034.milvus.grpc.TopKQuery" + "Result\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032\030." + "milvus.grpc.StringReply\"\000\022A\n\nDeleteByID\022" + "\034.milvus.grpc.DeleteByIDParam\032\023.milvus.g" + "rpc.Status\"\000\022G\n\021PreloadCollection\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushParam\032" + "\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\022E\n\026CreateHybridCollection\022\024.milvus" + ".grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L\n\023" + "HasHybridCollection\022\033.milvus.grpc.Collec" + "tionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024Dr" + "opHybridCollection\022\033.milvus.grpc.Collect" + "ionName\032\023.milvus.grpc.Status\"\000\022O\n\030Descri" + "beHybridCollection\022\033.milvus.grpc.Collect" + "ionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Count" + "HybridCollection\022\033.milvus.grpc.Collectio" + "nName\032\037.milvus.grpc.CollectionRowCount\"\000" + "\022I\n\025ShowHybridCollections\022\024.milvus.grpc." + "Command\032\030.milvus.grpc.MappingList\"\000\022V\n\030S" + "howHybridCollectionInfo\022\033.milvus.grpc.Co" + "llectionName\032\033.milvus.grpc.CollectionInf" + "o\"\000\022M\n\027PreloadHybridCollection\022\033.milvus." + "grpc.CollectionName\032\023.milvus.grpc.Status" + "\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInsert" + "Param\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hybr" + "idSearch\022\031.milvus.grpc.HSearchParam\032\034.mi" + "lvus.grpc.TopKQueryResult\"\000\022]\n\026HybridSea" + "rchInSegments\022#.milvus.grpc.HSearchInSeg" + "mentsParam\032\034.milvus.grpc.TopKQueryResult" + "\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEntit" + "yIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014Get" + "EntityIDs\022\037.milvus.grpc.HGetEntityIDsPar" + "am\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022DeleteE" + "ntitiesByID\022\035.milvus.grpc.HDeleteByIDPar" + "am\032\023.milvus.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[26] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[49] = { + &scc_info_AttrRecord_milvus_2eproto.base, &scc_info_BoolReply_milvus_2eproto.base, + &scc_info_BooleanQuery_milvus_2eproto.base, &scc_info_CollectionInfo_milvus_2eproto.base, &scc_info_CollectionName_milvus_2eproto.base, &scc_info_CollectionNameList_milvus_2eproto.base, &scc_info_CollectionRowCount_milvus_2eproto.base, &scc_info_CollectionSchema_milvus_2eproto.base, &scc_info_Command_milvus_2eproto.base, + &scc_info_CompareExpr_milvus_2eproto.base, &scc_info_DeleteByIDParam_milvus_2eproto.base, + &scc_info_FieldParam_milvus_2eproto.base, + &scc_info_FieldType_milvus_2eproto.base, + &scc_info_FieldValue_milvus_2eproto.base, &scc_info_FlushParam_milvus_2eproto.base, &scc_info_GetVectorIDsParam_milvus_2eproto.base, + &scc_info_HDeleteByIDParam_milvus_2eproto.base, + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_HEntityIDs_milvus_2eproto.base, + &scc_info_HEntityIdentity_milvus_2eproto.base, + &scc_info_HGetEntityIDsParam_milvus_2eproto.base, + &scc_info_HIndexParam_milvus_2eproto.base, + &scc_info_HInsertParam_milvus_2eproto.base, + &scc_info_HQueryResult_milvus_2eproto.base, + &scc_info_HSearchInSegmentsParam_milvus_2eproto.base, + &scc_info_HSearchParam_milvus_2eproto.base, &scc_info_IndexParam_milvus_2eproto.base, &scc_info_InsertParam_milvus_2eproto.base, &scc_info_KeyValuePair_milvus_2eproto.base, + &scc_info_Mapping_milvus_2eproto.base, + &scc_info_MappingList_milvus_2eproto.base, &scc_info_PartitionList_milvus_2eproto.base, &scc_info_PartitionParam_milvus_2eproto.base, &scc_info_PartitionStat_milvus_2eproto.base, + &scc_info_RangeQuery_milvus_2eproto.base, &scc_info_RowRecord_milvus_2eproto.base, &scc_info_SearchByIDParam_milvus_2eproto.base, &scc_info_SearchInFilesParam_milvus_2eproto.base, &scc_info_SearchParam_milvus_2eproto.base, &scc_info_SegmentStat_milvus_2eproto.base, &scc_info_StringReply_milvus_2eproto.base, + &scc_info_TermQuery_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorData_milvus_2eproto.base, + &scc_info_VectorFieldParam_milvus_2eproto.base, + &scc_info_VectorFieldValue_milvus_2eproto.base, &scc_info_VectorIdentity_milvus_2eproto.base, &scc_info_VectorIds_milvus_2eproto.base, + &scc_info_VectorQuery_milvus_2eproto.base, }; 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", 4194, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 26, 1, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8393, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 49, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 26, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 50, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. static bool dynamic_init_dummy_milvus_2eproto = ( ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_milvus_2eproto), true); namespace milvus { namespace grpc { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[0]; +} +bool DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 20: + case 30: + case 40: + case 41: + case 100: + case 9999: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[1]; +} +bool CompareOperator_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_milvus_2eproto); + return file_level_enum_descriptors_milvus_2eproto[2]; +} +bool Occur_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + // =================================================================== @@ -10378,6 +11291,9462 @@ void GetVectorIDsParam::InternalSwap(GetVectorIDsParam* other) { } +// =================================================================== + +void VectorFieldParam::InitAsDefaultInstance() { +} +class VectorFieldParam::_Internal { + public: +}; + +VectorFieldParam::VectorFieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldParam) +} +VectorFieldParam::VectorFieldParam(const VectorFieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dimension_ = from.dimension_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldParam) +} + +void VectorFieldParam::SharedCtor() { + dimension_ = PROTOBUF_LONGLONG(0); +} + +VectorFieldParam::~VectorFieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldParam) + SharedDtor(); +} + +void VectorFieldParam::SharedDtor() { +} + +void VectorFieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldParam& VectorFieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dimension_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldParam::_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) { + // int64 dimension = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + 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 VectorFieldParam::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.VectorFieldParam) + 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)) { + // int64 dimension = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &dimension_))); + } 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.VectorFieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->dimension(), 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.VectorFieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 dimension = 1; + if (this->dimension() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->dimension(), 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.VectorFieldParam) + return target; +} + +size_t VectorFieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldParam) + 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; + + // int64 dimension = 1; + if (this->dimension() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->dimension()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldParam) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldParam) + MergeFrom(*source); + } +} + +void VectorFieldParam::MergeFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldParam) + 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.dimension() != 0) { + set_dimension(from.dimension()); + } +} + +void VectorFieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldParam::CopyFrom(const VectorFieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldParam::IsInitialized() const { + return true; +} + +void VectorFieldParam::InternalSwap(VectorFieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(dimension_, other->dimension_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldType::InitAsDefaultInstance() { + ::milvus::grpc::_FieldType_default_instance_.data_type_ = 0; + ::milvus::grpc::_FieldType_default_instance_.vector_param_ = const_cast< ::milvus::grpc::VectorFieldParam*>( + ::milvus::grpc::VectorFieldParam::internal_default_instance()); +} +class FieldType::_Internal { + public: + static const ::milvus::grpc::VectorFieldParam& vector_param(const FieldType* msg); +}; + +const ::milvus::grpc::VectorFieldParam& +FieldType::_Internal::vector_param(const FieldType* msg) { + return *msg->value_.vector_param_; +} +void FieldType::set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (vector_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_param, submessage_arena); + } + set_has_vector_param(); + value_.vector_param_ = vector_param; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldType.vector_param) +} +FieldType::FieldType() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldType) +} +FieldType::FieldType(const FieldType& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldType) +} + +void FieldType::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldType_milvus_2eproto.base); + clear_has_value(); +} + +FieldType::~FieldType() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldType) + SharedDtor(); +} + +void FieldType::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void FieldType::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldType& FieldType::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldType_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldType::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.FieldType) + switch (value_case()) { + case kDataType: { + // No need to clear + break; + } + case kVectorParam: { + delete value_.vector_param_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void FieldType::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldType::_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) { + // .milvus.grpc.DataType data_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_data_type(static_cast<::milvus::grpc::DataType>(val)); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_vector_param(), ptr); + 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 FieldType::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.FieldType) + 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)) { + // .milvus.grpc.DataType data_type = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_data_type(static_cast< ::milvus::grpc::DataType >(value)); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_param())); + } 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.FieldType) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldType) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldType::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->data_type(), output); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::vector_param(this), 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.FieldType) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldType::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.DataType data_type = 1; + if (has_data_type()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->data_type(), target); + } + + // .milvus.grpc.VectorFieldParam vector_param = 2; + if (has_vector_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::vector_param(this), 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.FieldType) + return target; +} + +size_t FieldType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldType) + 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; + + switch (value_case()) { + // .milvus.grpc.DataType data_type = 1; + case kDataType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->data_type()); + break; + } + // .milvus.grpc.VectorFieldParam vector_param = 2; + case kVectorParam: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.vector_param_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + const FieldType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldType) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldType) + MergeFrom(*source); + } +} + +void FieldType::MergeFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldType) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kDataType: { + set_data_type(from.data_type()); + break; + } + case kVectorParam: { + mutable_vector_param()->::milvus::grpc::VectorFieldParam::MergeFrom(from.vector_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void FieldType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldType::CopyFrom(const FieldType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldType::IsInitialized() const { + return true; +} + +void FieldType::InternalSwap(FieldType* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldType::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldParam::InitAsDefaultInstance() { + ::milvus::grpc::_FieldParam_default_instance_._instance.get_mutable()->type_ = const_cast< ::milvus::grpc::FieldType*>( + ::milvus::grpc::FieldType::internal_default_instance()); +} +class FieldParam::_Internal { + public: + static const ::milvus::grpc::FieldType& type(const FieldParam* msg); +}; + +const ::milvus::grpc::FieldType& +FieldParam::_Internal::type(const FieldParam* msg) { + return *msg->type_; +} +FieldParam::FieldParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldParam) +} +FieldParam::FieldParam(const FieldParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.name().empty()) { + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + type_ = new ::milvus::grpc::FieldType(*from.type_); + } else { + type_ = nullptr; + } + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldParam) +} + +void FieldParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldParam_milvus_2eproto.base); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&type_, 0, static_cast( + reinterpret_cast(&id_) - + reinterpret_cast(&type_)) + sizeof(id_)); +} + +FieldParam::~FieldParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldParam) + SharedDtor(); +} + +void FieldParam::SharedDtor() { + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete type_; +} + +void FieldParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldParam& FieldParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldParam::_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) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_name(), ptr, ctx, "milvus.grpc.FieldParam.name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.FieldType type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 FieldParam::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.FieldParam) + 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)) { + // uint64 id = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &id_))); + } else { + goto handle_unusual; + } + break; + } + + // string name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldParam.name")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.FieldType type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_type())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.FieldParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(1, this->id(), output); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::type(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.FieldParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->name().data(), static_cast(this->name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldParam.name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::type(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.FieldParam) + return target; +} + +size_t FieldParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->name()); + } + + // .milvus.grpc.FieldType type = 3; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + const FieldParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldParam) + MergeFrom(*source); + } +} + +void FieldParam::MergeFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.name().size() > 0) { + + name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (from.has_type()) { + mutable_type()->::milvus::grpc::FieldType::MergeFrom(from.type()); + } + if (from.id() != 0) { + set_id(from.id()); + } +} + +void FieldParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldParam::CopyFrom(const FieldParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldParam::IsInitialized() const { + return true; +} + +void FieldParam::InternalSwap(FieldParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(type_, other->type_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorFieldValue::InitAsDefaultInstance() { +} +class VectorFieldValue::_Internal { + public: +}; + +VectorFieldValue::VectorFieldValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldValue) +} +VectorFieldValue::VectorFieldValue(const VectorFieldValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + value_(from.value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldValue) +} + +void VectorFieldValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldValue_milvus_2eproto.base); +} + +VectorFieldValue::~VectorFieldValue() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldValue) + SharedDtor(); +} + +void VectorFieldValue::SharedDtor() { +} + +void VectorFieldValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorFieldValue& VectorFieldValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldValue_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorFieldValue::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorFieldValue::_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) { + // repeated .milvus.grpc.RowRecord value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_value(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } 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 VectorFieldValue::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.VectorFieldValue) + 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)) { + // repeated .milvus.grpc.RowRecord value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_value())); + } 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.VectorFieldValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorFieldValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, + this->value(static_cast(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.VectorFieldValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + for (unsigned int i = 0, + n = static_cast(this->value_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->value(static_cast(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.VectorFieldValue) + return target; +} + +size_t VectorFieldValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldValue) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord value = 1; + { + unsigned int count = static_cast(this->value_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->value(static_cast(i))); + } + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorFieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldValue) + GOOGLE_DCHECK_NE(&from, this); + const VectorFieldValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldValue) + MergeFrom(*source); + } +} + +void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); +} + +void VectorFieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorFieldValue::CopyFrom(const VectorFieldValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorFieldValue::IsInitialized() const { + return true; +} + +void VectorFieldValue::InternalSwap(VectorFieldValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&value_)->InternalSwap(CastToBase(&other->value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void FieldValue::InitAsDefaultInstance() { + ::milvus::grpc::_FieldValue_default_instance_.int32_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.int64_value_ = PROTOBUF_LONGLONG(0); + ::milvus::grpc::_FieldValue_default_instance_.float_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.double_value_ = 0; + ::milvus::grpc::_FieldValue_default_instance_.string_value_.UnsafeSetDefault( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::milvus::grpc::_FieldValue_default_instance_.bool_value_ = false; + ::milvus::grpc::_FieldValue_default_instance_.vector_value_ = const_cast< ::milvus::grpc::VectorFieldValue*>( + ::milvus::grpc::VectorFieldValue::internal_default_instance()); +} +class FieldValue::_Internal { + public: + static const ::milvus::grpc::VectorFieldValue& vector_value(const FieldValue* msg); +}; + +const ::milvus::grpc::VectorFieldValue& +FieldValue::_Internal::vector_value(const FieldValue* msg) { + return *msg->value_.vector_value_; +} +void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (vector_value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_value, submessage_arena); + } + set_has_vector_value(); + value_.vector_value_ = vector_value; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.vector_value) +} +FieldValue::FieldValue() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.FieldValue) +} +FieldValue::FieldValue(const FieldValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_value(); + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case kStringValue: { + set_string_value(from.string_value()); + break; + } + case kBoolValue: { + set_bool_value(from.bool_value()); + break; + } + case kVectorValue: { + mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.FieldValue) +} + +void FieldValue::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_FieldValue_milvus_2eproto.base); + clear_has_value(); +} + +FieldValue::~FieldValue() { + // @@protoc_insertion_point(destructor:milvus.grpc.FieldValue) + SharedDtor(); +} + +void FieldValue::SharedDtor() { + if (has_value()) { + clear_value(); + } +} + +void FieldValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const FieldValue& FieldValue::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_FieldValue_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void FieldValue::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.FieldValue) + switch (value_case()) { + case kInt32Value: { + // No need to clear + break; + } + case kInt64Value: { + // No need to clear + break; + } + case kFloatValue: { + // No need to clear + break; + } + case kDoubleValue: { + // No need to clear + break; + } + case kStringValue: { + value_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + break; + } + case kBoolValue: { + // No need to clear + break; + } + case kVectorValue: { + delete value_.vector_value_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void FieldValue::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_value(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* FieldValue::_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) { + // int32 int32_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + set_int32_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 int64_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + set_int64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float float_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + set_float_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // double double_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) { + set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // string string_value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_string_value(), ptr, ctx, "milvus.grpc.FieldValue.string_value"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool bool_value = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorFieldValue vector_value = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(mutable_vector_value(), ptr); + 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 FieldValue::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.FieldValue) + 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)) { + // int32 int32_value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &value_.int32_value_))); + set_has_int32_value(); + } else { + goto handle_unusual; + } + break; + } + + // int64 int64_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &value_.int64_value_))); + set_has_int64_value(); + } else { + goto handle_unusual; + } + break; + } + + // float float_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &value_.float_value_))); + set_has_float_value(); + } else { + goto handle_unusual; + } + break; + } + + // double double_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (33 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, &value_.double_value_))); + set_has_double_value(); + } else { + goto handle_unusual; + } + break; + } + + // string string_value = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_string_value())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.FieldValue.string_value")); + } else { + goto handle_unusual; + } + break; + } + + // bool bool_value = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + clear_value(); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( + input, &value_.bool_value_))); + set_has_bool_value(); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_value())); + } 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.FieldValue) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.FieldValue) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void FieldValue::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->int32_value(), output); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->int64_value(), output); + } + + // float float_value = 3; + if (has_float_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->float_value(), output); + } + + // double double_value = 4; + if (has_double_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(4, this->double_value(), output); + } + + // string string_value = 5; + if (has_string_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldValue.string_value"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 5, this->string_value(), output); + } + + // bool bool_value = 6; + if (has_bool_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->bool_value(), output); + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + if (has_vector_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, _Internal::vector_value(this), 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.FieldValue) +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldValue::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 int32_value = 1; + if (has_int32_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->int32_value(), target); + } + + // int64 int64_value = 2; + if (has_int64_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->int64_value(), target); + } + + // float float_value = 3; + if (has_float_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->float_value(), target); + } + + // double double_value = 4; + if (has_double_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->double_value(), target); + } + + // string string_value = 5; + if (has_string_value()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->string_value().data(), static_cast(this->string_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.FieldValue.string_value"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 5, this->string_value(), target); + } + + // bool bool_value = 6; + if (has_bool_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->bool_value(), target); + } + + // .milvus.grpc.VectorFieldValue vector_value = 7; + if (has_vector_value()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 7, _Internal::vector_value(this), 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.FieldValue) + return target; +} + +size_t FieldValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.FieldValue) + 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; + + switch (value_case()) { + // int32 int32_value = 1; + case kInt32Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->int32_value()); + break; + } + // int64 int64_value = 2; + case kInt64Value: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->int64_value()); + break; + } + // float float_value = 3; + case kFloatValue: { + total_size += 1 + 4; + break; + } + // double double_value = 4; + case kDoubleValue: { + total_size += 1 + 8; + break; + } + // string string_value = 5; + case kStringValue: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->string_value()); + break; + } + // bool bool_value = 6; + case kBoolValue: { + total_size += 1 + 1; + break; + } + // .milvus.grpc.VectorFieldValue vector_value = 7; + case kVectorValue: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.vector_value_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + const FieldValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.FieldValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.FieldValue) + MergeFrom(*source); + } +} + +void FieldValue::MergeFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.FieldValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.value_case()) { + case kInt32Value: { + set_int32_value(from.int32_value()); + break; + } + case kInt64Value: { + set_int64_value(from.int64_value()); + break; + } + case kFloatValue: { + set_float_value(from.float_value()); + break; + } + case kDoubleValue: { + set_double_value(from.double_value()); + break; + } + case kStringValue: { + set_string_value(from.string_value()); + break; + } + case kBoolValue: { + set_bool_value(from.bool_value()); + break; + } + case kVectorValue: { + mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void FieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldValue::CopyFrom(const FieldValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.FieldValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldValue::IsInitialized() const { + return true; +} + +void FieldValue::InternalSwap(FieldValue* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldValue::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void Mapping::InitAsDefaultInstance() { + ::milvus::grpc::_Mapping_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class Mapping::_Internal { + public: + static const ::milvus::grpc::Status& status(const Mapping* msg); +}; + +const ::milvus::grpc::Status& +Mapping::_Internal::status(const Mapping* msg) { + return *msg->status_; +} +void Mapping::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +Mapping::Mapping() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.Mapping) +} +Mapping::Mapping(const Mapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + fields_(from.fields_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + collection_id_ = from.collection_id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.Mapping) +} + +void Mapping::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Mapping_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&collection_id_) - + reinterpret_cast(&status_)) + sizeof(collection_id_)); +} + +Mapping::~Mapping() { + // @@protoc_insertion_point(destructor:milvus.grpc.Mapping) + SharedDtor(); +} + +void Mapping::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void Mapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const Mapping& Mapping::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Mapping_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void Mapping::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + collection_id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* Mapping::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 collection_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + collection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.Mapping.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.FieldParam fields = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 Mapping::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.Mapping) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // uint64 collection_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &collection_id_))); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.Mapping.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.FieldParam fields = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_fields())); + } 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.Mapping) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.Mapping) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void Mapping::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->collection_id(), output); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->collection_name(), output); + } + + // repeated .milvus.grpc.FieldParam fields = 4; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->fields(static_cast(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.Mapping) +} + +::PROTOBUF_NAMESPACE_ID::uint8* Mapping::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->collection_id(), target); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.Mapping.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->collection_name(), target); + } + + // repeated .milvus.grpc.FieldParam fields = 4; + for (unsigned int i = 0, + n = static_cast(this->fields_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->fields(static_cast(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.Mapping) + return target; +} + +size_t Mapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Mapping) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.FieldParam fields = 4; + { + unsigned int count = static_cast(this->fields_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->fields(static_cast(i))); + } + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // uint64 collection_id = 2; + if (this->collection_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->collection_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Mapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + const Mapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Mapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Mapping) + MergeFrom(*source); + } +} + +void Mapping::MergeFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Mapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.collection_id() != 0) { + set_collection_id(from.collection_id()); + } +} + +void Mapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Mapping::CopyFrom(const Mapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Mapping::IsInitialized() const { + return true; +} + +void Mapping::InternalSwap(Mapping* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&fields_)->InternalSwap(CastToBase(&other->fields_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); + swap(collection_id_, other->collection_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Mapping::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void MappingList::InitAsDefaultInstance() { + ::milvus::grpc::_MappingList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class MappingList::_Internal { + public: + static const ::milvus::grpc::Status& status(const MappingList* msg); +}; + +const ::milvus::grpc::Status& +MappingList::_Internal::status(const MappingList* msg) { + return *msg->status_; +} +void MappingList::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +MappingList::MappingList() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.MappingList) +} +MappingList::MappingList(const MappingList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + mapping_list_(from.mapping_list_) { + _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.MappingList) +} + +void MappingList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MappingList_milvus_2eproto.base); + status_ = nullptr; +} + +MappingList::~MappingList() { + // @@protoc_insertion_point(destructor:milvus.grpc.MappingList) + SharedDtor(); +} + +void MappingList::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void MappingList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const MappingList& MappingList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MappingList_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void MappingList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mapping_list_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* MappingList::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_mapping_list(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool MappingList::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.MappingList) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_mapping_list())); + } 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.MappingList) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.MappingList) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void MappingList::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->mapping_list(static_cast(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.MappingList) +} + +::PROTOBUF_NAMESPACE_ID::uint8* MappingList::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.grpc.Mapping mapping_list = 2; + for (unsigned int i = 0, + n = static_cast(this->mapping_list_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->mapping_list(static_cast(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.MappingList) + return target; +} + +size_t MappingList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.MappingList) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.Mapping mapping_list = 2; + { + unsigned int count = static_cast(this->mapping_list_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->mapping_list(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MappingList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + const MappingList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.MappingList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.MappingList) + MergeFrom(*source); + } +} + +void MappingList::MergeFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.MappingList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + mapping_list_.MergeFrom(from.mapping_list_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void MappingList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MappingList::CopyFrom(const MappingList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.MappingList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MappingList::IsInitialized() const { + return true; +} + +void MappingList::InternalSwap(MappingList* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&mapping_list_)->InternalSwap(CastToBase(&other->mapping_list_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MappingList::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void TermQuery::InitAsDefaultInstance() { +} +class TermQuery::_Internal { + public: +}; + +TermQuery::TermQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.TermQuery) +} +TermQuery::TermQuery(const TermQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + values_(from.values_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + boost_ = from.boost_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.TermQuery) +} + +void TermQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; +} + +TermQuery::~TermQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.TermQuery) + SharedDtor(); +} + +void TermQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void TermQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const TermQuery& TermQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TermQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void TermQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + values_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* TermQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.TermQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string values = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_values(), ptr, ctx, "milvus.grpc.TermQuery.values"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // float boost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 TermQuery::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.TermQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.TermQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string values = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_values())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(this->values_size() - 1).data(), + static_cast(this->values(this->values_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.TermQuery.values")); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.TermQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.TermQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void TermQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated string values = 2; + for (int i = 0, n = this->values_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(i).data(), static_cast(this->values(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.values"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->values(i), output); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.TermQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* TermQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated string values = 2; + for (int i = 0, n = this->values_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->values(i).data(), static_cast(this->values(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.TermQuery.values"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->values(i), target); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.TermQuery) + return target; +} + +size_t TermQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TermQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string values = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->values_size()); + for (int i = 0, n = this->values_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->values(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TermQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + const TermQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TermQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TermQuery) + MergeFrom(*source); + } +} + +void TermQuery::MergeFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TermQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + values_.MergeFrom(from.values_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void TermQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TermQuery::CopyFrom(const TermQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TermQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TermQuery::IsInitialized() const { + return true; +} + +void TermQuery::InternalSwap(TermQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + values_.InternalSwap(CastToBase(&other->values_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata TermQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void CompareExpr::InitAsDefaultInstance() { +} +class CompareExpr::_Internal { + public: +}; + +CompareExpr::CompareExpr() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.CompareExpr) +} +CompareExpr::CompareExpr(const CompareExpr& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.operand().empty()) { + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + operator__ = from.operator__; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CompareExpr) +} + +void CompareExpr::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CompareExpr_milvus_2eproto.base); + operand_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; +} + +CompareExpr::~CompareExpr() { + // @@protoc_insertion_point(destructor:milvus.grpc.CompareExpr) + SharedDtor(); +} + +void CompareExpr::SharedDtor() { + operand_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void CompareExpr::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const CompareExpr& CompareExpr::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CompareExpr_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void CompareExpr::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + operator__ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* CompareExpr::_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) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_operator_(static_cast<::milvus::grpc::CompareOperator>(val)); + } else goto handle_unusual; + continue; + // string operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_operand(), ptr, ctx, "milvus.grpc.CompareExpr.operand"); + 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 CompareExpr::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.CompareExpr) + 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)) { + // .milvus.grpc.CompareOperator operator = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_operator_(static_cast< ::milvus::grpc::CompareOperator >(value)); + } else { + goto handle_unusual; + } + break; + } + + // string operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_operand())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.CompareExpr.operand")); + } 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.CompareExpr) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.CompareExpr) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void CompareExpr::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->operator_(), output); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->operand(), 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.CompareExpr) +} + +::PROTOBUF_NAMESPACE_ID::uint8* CompareExpr::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->operator_(), target); + } + + // string operand = 2; + if (this->operand().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->operand().data(), static_cast(this->operand().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.CompareExpr.operand"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->operand(), 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.CompareExpr) + return target; +} + +size_t CompareExpr::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CompareExpr) + 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 operand = 2; + if (this->operand().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->operand()); + } + + // .milvus.grpc.CompareOperator operator = 1; + if (this->operator_() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->operator_()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void CompareExpr::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CompareExpr) + GOOGLE_DCHECK_NE(&from, this); + const CompareExpr* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CompareExpr) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CompareExpr) + MergeFrom(*source); + } +} + +void CompareExpr::MergeFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CompareExpr) + 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.operand().size() > 0) { + + operand_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.operand_); + } + if (from.operator_() != 0) { + set_operator_(from.operator_()); + } +} + +void CompareExpr::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void CompareExpr::CopyFrom(const CompareExpr& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CompareExpr) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CompareExpr::IsInitialized() const { + return true; +} + +void CompareExpr::InternalSwap(CompareExpr* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + operand_.Swap(&other->operand_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(operator__, other->operator__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CompareExpr::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void RangeQuery::InitAsDefaultInstance() { +} +class RangeQuery::_Internal { + public: +}; + +RangeQuery::RangeQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.RangeQuery) +} +RangeQuery::RangeQuery(const RangeQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + operand_(from.operand_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + boost_ = from.boost_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.RangeQuery) +} + +void RangeQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RangeQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; +} + +RangeQuery::~RangeQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.RangeQuery) + SharedDtor(); +} + +void RangeQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RangeQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const RangeQuery& RangeQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RangeQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void RangeQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + operand_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + boost_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* RangeQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.RangeQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_operand(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // float boost = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) { + boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 RangeQuery::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.RangeQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.RangeQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_operand())); + } else { + goto handle_unusual; + } + break; + } + + // float boost = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (29 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.RangeQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.RangeQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void RangeQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->operand(static_cast(i)), + output); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(3, this->boost(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.RangeQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* RangeQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.RangeQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // repeated .milvus.grpc.CompareExpr operand = 2; + for (unsigned int i = 0, + n = static_cast(this->operand_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->operand(static_cast(i)), target); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->boost(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.RangeQuery) + return target; +} + +size_t RangeQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.RangeQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.CompareExpr operand = 2; + { + unsigned int count = static_cast(this->operand_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->operand(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // float boost = 3; + if (!(this->boost() <= 0 && this->boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RangeQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + const RangeQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.RangeQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.RangeQuery) + MergeFrom(*source); + } +} + +void RangeQuery::MergeFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.RangeQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + operand_.MergeFrom(from.operand_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (!(from.boost() <= 0 && from.boost() >= 0)) { + set_boost(from.boost()); + } +} + +void RangeQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RangeQuery::CopyFrom(const RangeQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.RangeQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RangeQuery::IsInitialized() const { + return true; +} + +void RangeQuery::InternalSwap(RangeQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&operand_)->InternalSwap(CastToBase(&other->operand_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(boost_, other->boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RangeQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void VectorQuery::InitAsDefaultInstance() { +} +class VectorQuery::_Internal { + public: +}; + +VectorQuery::VectorQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.VectorQuery) +} +VectorQuery::VectorQuery(const VectorQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + records_(from.records_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.field_name().empty()) { + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + ::memcpy(&topk_, &from.topk_, + static_cast(reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorQuery) +} + +void VectorQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorQuery_milvus_2eproto.base); + field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); +} + +VectorQuery::~VectorQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorQuery) + SharedDtor(); +} + +void VectorQuery::SharedDtor() { + field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void VectorQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const VectorQuery& VectorQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void VectorQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + records_.Clear(); + extra_params_.Clear(); + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&topk_, 0, static_cast( + reinterpret_cast(&query_boost_) - + reinterpret_cast(&topk_)) + sizeof(query_boost_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* VectorQuery::_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 field_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_field_name(), ptr, ctx, "milvus.grpc.VectorQuery.field_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float query_boost = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) { + query_boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.RowRecord records = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // int64 topk = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 VectorQuery::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.VectorQuery) + 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 field_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_field_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.VectorQuery.field_name")); + } else { + goto handle_unusual; + } + break; + } + + // float query_boost = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (21 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, &query_boost_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.RowRecord records = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_records())); + } else { + goto handle_unusual; + } + break; + } + + // int64 topk = 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>( + input, &topk_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.VectorQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void VectorQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->field_name(), output); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(2, this->query_boost(), output); + } + + // repeated .milvus.grpc.RowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, + this->records(static_cast(i)), + output); + } + + // int64 topk = 4; + if (this->topk() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->topk(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(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.VectorQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* VectorQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string field_name = 1; + if (this->field_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_name().data(), static_cast(this->field_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.VectorQuery.field_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->field_name(), target); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->query_boost(), target); + } + + // repeated .milvus.grpc.RowRecord records = 3; + for (unsigned int i = 0, + n = static_cast(this->records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, this->records(static_cast(i)), target); + } + + // int64 topk = 4; + if (this->topk() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->topk(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(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.VectorQuery) + return target; +} + +size_t VectorQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.RowRecord records = 3; + { + unsigned int count = static_cast(this->records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->records(static_cast(i))); + } + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string field_name = 1; + if (this->field_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_name()); + } + + // int64 topk = 4; + if (this->topk() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->topk()); + } + + // float query_boost = 2; + if (!(this->query_boost() <= 0 && this->query_boost() >= 0)) { + total_size += 1 + 4; + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void VectorQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + const VectorQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorQuery) + MergeFrom(*source); + } +} + +void VectorQuery::MergeFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + records_.MergeFrom(from.records_); + extra_params_.MergeFrom(from.extra_params_); + if (from.field_name().size() > 0) { + + field_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.field_name_); + } + if (from.topk() != 0) { + set_topk(from.topk()); + } + if (!(from.query_boost() <= 0 && from.query_boost() >= 0)) { + set_query_boost(from.query_boost()); + } +} + +void VectorQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void VectorQuery::CopyFrom(const VectorQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool VectorQuery::IsInitialized() const { + return true; +} + +void VectorQuery::InternalSwap(VectorQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&records_)->InternalSwap(CastToBase(&other->records_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(topk_, other->topk_); + swap(query_boost_, other->query_boost_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata VectorQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void BooleanQuery::InitAsDefaultInstance() { +} +class BooleanQuery::_Internal { + public: +}; + +BooleanQuery::BooleanQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.BooleanQuery) +} +BooleanQuery::BooleanQuery(const BooleanQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + general_query_(from.general_query_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + occur_ = from.occur_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.BooleanQuery) +} + +void BooleanQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_milvus_2eproto.base); + occur_ = 0; +} + +BooleanQuery::~BooleanQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.BooleanQuery) + SharedDtor(); +} + +void BooleanQuery::SharedDtor() { +} + +void BooleanQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const BooleanQuery& BooleanQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void BooleanQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + general_query_.Clear(); + occur_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* BooleanQuery::_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) { + // .milvus.grpc.Occur occur = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_occur(static_cast<::milvus::grpc::Occur>(val)); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_general_query(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool BooleanQuery::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.BooleanQuery) + 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)) { + // .milvus.grpc.Occur occur = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_occur(static_cast< ::milvus::grpc::Occur >(value)); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_general_query())); + } 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.BooleanQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.BooleanQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void BooleanQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 1, this->occur(), output); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->general_query(static_cast(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.BooleanQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* BooleanQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->occur(), target); + } + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + for (unsigned int i = 0, + n = static_cast(this->general_query_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->general_query(static_cast(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.BooleanQuery) + return target; +} + +size_t BooleanQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.BooleanQuery) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.GeneralQuery general_query = 2; + { + unsigned int count = static_cast(this->general_query_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->general_query(static_cast(i))); + } + } + + // .milvus.grpc.Occur occur = 1; + if (this->occur() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->occur()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BooleanQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + const BooleanQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.BooleanQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.BooleanQuery) + MergeFrom(*source); + } +} + +void BooleanQuery::MergeFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.BooleanQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + general_query_.MergeFrom(from.general_query_); + if (from.occur() != 0) { + set_occur(from.occur()); + } +} + +void BooleanQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void BooleanQuery::CopyFrom(const BooleanQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.BooleanQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BooleanQuery::IsInitialized() const { + return true; +} + +void BooleanQuery::InternalSwap(BooleanQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&general_query_)->InternalSwap(CastToBase(&other->general_query_)); + swap(occur_, other->occur_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata BooleanQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void GeneralQuery::InitAsDefaultInstance() { + ::milvus::grpc::_GeneralQuery_default_instance_.boolean_query_ = const_cast< ::milvus::grpc::BooleanQuery*>( + ::milvus::grpc::BooleanQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.term_query_ = const_cast< ::milvus::grpc::TermQuery*>( + ::milvus::grpc::TermQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.range_query_ = const_cast< ::milvus::grpc::RangeQuery*>( + ::milvus::grpc::RangeQuery::internal_default_instance()); + ::milvus::grpc::_GeneralQuery_default_instance_.vector_query_ = const_cast< ::milvus::grpc::VectorQuery*>( + ::milvus::grpc::VectorQuery::internal_default_instance()); +} +class GeneralQuery::_Internal { + public: + static const ::milvus::grpc::BooleanQuery& boolean_query(const GeneralQuery* msg); + static const ::milvus::grpc::TermQuery& term_query(const GeneralQuery* msg); + static const ::milvus::grpc::RangeQuery& range_query(const GeneralQuery* msg); + static const ::milvus::grpc::VectorQuery& vector_query(const GeneralQuery* msg); +}; + +const ::milvus::grpc::BooleanQuery& +GeneralQuery::_Internal::boolean_query(const GeneralQuery* msg) { + return *msg->query_.boolean_query_; +} +const ::milvus::grpc::TermQuery& +GeneralQuery::_Internal::term_query(const GeneralQuery* msg) { + return *msg->query_.term_query_; +} +const ::milvus::grpc::RangeQuery& +GeneralQuery::_Internal::range_query(const GeneralQuery* msg) { + return *msg->query_.range_query_; +} +const ::milvus::grpc::VectorQuery& +GeneralQuery::_Internal::vector_query(const GeneralQuery* msg) { + return *msg->query_.vector_query_; +} +void GeneralQuery::set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (boolean_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + boolean_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, boolean_query, submessage_arena); + } + set_has_boolean_query(); + query_.boolean_query_ = boolean_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.boolean_query) +} +void GeneralQuery::set_allocated_term_query(::milvus::grpc::TermQuery* term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (term_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + term_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, term_query, submessage_arena); + } + set_has_term_query(); + query_.term_query_ = term_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.term_query) +} +void GeneralQuery::set_allocated_range_query(::milvus::grpc::RangeQuery* range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (range_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + range_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, range_query, submessage_arena); + } + set_has_range_query(); + query_.range_query_ = range_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.range_query) +} +void GeneralQuery::set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + clear_query(); + if (vector_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + vector_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, vector_query, submessage_arena); + } + set_has_vector_query(); + query_.vector_query_ = vector_query; + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GeneralQuery.vector_query) +} +GeneralQuery::GeneralQuery() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.GeneralQuery) +} +GeneralQuery::GeneralQuery(const GeneralQuery& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + clear_has_query(); + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.GeneralQuery) +} + +void GeneralQuery::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BooleanQuery_milvus_2eproto.base); + clear_has_query(); +} + +GeneralQuery::~GeneralQuery() { + // @@protoc_insertion_point(destructor:milvus.grpc.GeneralQuery) + SharedDtor(); +} + +void GeneralQuery::SharedDtor() { + if (has_query()) { + clear_query(); + } +} + +void GeneralQuery::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const GeneralQuery& GeneralQuery::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BooleanQuery_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void GeneralQuery::clear_query() { +// @@protoc_insertion_point(one_of_clear_start:milvus.grpc.GeneralQuery) + switch (query_case()) { + case kBooleanQuery: { + delete query_.boolean_query_; + break; + } + case kTermQuery: { + delete query_.term_query_; + break; + } + case kRangeQuery: { + delete query_.range_query_; + break; + } + case kVectorQuery: { + delete query_.vector_query_; + break; + } + case QUERY_NOT_SET: { + break; + } + } + _oneof_case_[0] = QUERY_NOT_SET; +} + + +void GeneralQuery::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_query(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* GeneralQuery::_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) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_boolean_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.TermQuery term_query = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_term_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.RangeQuery range_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_range_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(mutable_vector_query(), ptr); + 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 GeneralQuery::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.GeneralQuery) + 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)) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_boolean_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.TermQuery term_query = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_term_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.RangeQuery range_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_range_query())); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.VectorQuery vector_query = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_vector_query())); + } 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.GeneralQuery) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.GeneralQuery) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void GeneralQuery::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::boolean_query(this), output); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::term_query(this), output); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::range_query(this), output); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, _Internal::vector_query(this), 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.GeneralQuery) +} + +::PROTOBUF_NAMESPACE_ID::uint8* GeneralQuery::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.BooleanQuery boolean_query = 1; + if (has_boolean_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::boolean_query(this), target); + } + + // .milvus.grpc.TermQuery term_query = 2; + if (has_term_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::term_query(this), target); + } + + // .milvus.grpc.RangeQuery range_query = 3; + if (has_range_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::range_query(this), target); + } + + // .milvus.grpc.VectorQuery vector_query = 4; + if (has_vector_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, _Internal::vector_query(this), 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.GeneralQuery) + return target; +} + +size_t GeneralQuery::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.GeneralQuery) + 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; + + switch (query_case()) { + // .milvus.grpc.BooleanQuery boolean_query = 1; + case kBooleanQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.boolean_query_); + break; + } + // .milvus.grpc.TermQuery term_query = 2; + case kTermQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.term_query_); + break; + } + // .milvus.grpc.RangeQuery range_query = 3; + case kRangeQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.range_query_); + break; + } + // .milvus.grpc.VectorQuery vector_query = 4; + case kVectorQuery: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *query_.vector_query_); + break; + } + case QUERY_NOT_SET: { + break; + } + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GeneralQuery::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + const GeneralQuery* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.GeneralQuery) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.GeneralQuery) + MergeFrom(*source); + } +} + +void GeneralQuery::MergeFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.GeneralQuery) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.query_case()) { + case kBooleanQuery: { + mutable_boolean_query()->::milvus::grpc::BooleanQuery::MergeFrom(from.boolean_query()); + break; + } + case kTermQuery: { + mutable_term_query()->::milvus::grpc::TermQuery::MergeFrom(from.term_query()); + break; + } + case kRangeQuery: { + mutable_range_query()->::milvus::grpc::RangeQuery::MergeFrom(from.range_query()); + break; + } + case kVectorQuery: { + mutable_vector_query()->::milvus::grpc::VectorQuery::MergeFrom(from.vector_query()); + break; + } + case QUERY_NOT_SET: { + break; + } + } +} + +void GeneralQuery::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GeneralQuery::CopyFrom(const GeneralQuery& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.GeneralQuery) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GeneralQuery::IsInitialized() const { + return true; +} + +void GeneralQuery::InternalSwap(GeneralQuery* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(query_, other->query_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata GeneralQuery::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HSearchParam::InitAsDefaultInstance() { + ::milvus::grpc::_HSearchParam_default_instance_._instance.get_mutable()->general_query_ = const_cast< ::milvus::grpc::GeneralQuery*>( + ::milvus::grpc::GeneralQuery::internal_default_instance()); +} +class HSearchParam::_Internal { + public: + static const ::milvus::grpc::GeneralQuery& general_query(const HSearchParam* msg); +}; + +const ::milvus::grpc::GeneralQuery& +HSearchParam::_Internal::general_query(const HSearchParam* msg) { + return *msg->general_query_; +} +HSearchParam::HSearchParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HSearchParam) +} +HSearchParam::HSearchParam(const HSearchParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + partition_tag_array_(from.partition_tag_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + general_query_ = new ::milvus::grpc::GeneralQuery(*from.general_query_); + } else { + general_query_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HSearchParam) +} + +void HSearchParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HSearchParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + general_query_ = nullptr; +} + +HSearchParam::~HSearchParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HSearchParam) + SharedDtor(); +} + +void HSearchParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete general_query_; +} + +void HSearchParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HSearchParam& HSearchParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HSearchParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HSearchParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partition_tag_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HSearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HSearchParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string partition_tag_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag_array(), ptr, ctx, "milvus.grpc.HSearchParam.partition_tag_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_general_query(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 HSearchParam::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.HSearchParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_tag_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_tag_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(this->partition_tag_array_size() - 1).data(), + static_cast(this->partition_tag_array(this->partition_tag_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchParam.partition_tag_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.GeneralQuery general_query = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_general_query())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HSearchParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HSearchParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HSearchParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.partition_tag_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 2, this->partition_tag_array(i), output); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::general_query(this), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.HSearchParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HSearchParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated string partition_tag_array = 2; + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag_array(i).data(), static_cast(this->partition_tag_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchParam.partition_tag_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(2, this->partition_tag_array(i), target); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::general_query(this), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.HSearchParam) + return target; +} + +size_t HSearchParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HSearchParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string partition_tag_array = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_array_size()); + for (int i = 0, n = this->partition_tag_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag_array(i)); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.GeneralQuery general_query = 3; + if (this->has_general_query()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *general_query_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HSearchParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HSearchParam) + GOOGLE_DCHECK_NE(&from, this); + const HSearchParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HSearchParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HSearchParam) + MergeFrom(*source); + } +} + +void HSearchParam::MergeFrom(const HSearchParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HSearchParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partition_tag_array_.MergeFrom(from.partition_tag_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_general_query()) { + mutable_general_query()->::milvus::grpc::GeneralQuery::MergeFrom(from.general_query()); + } +} + +void HSearchParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HSearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HSearchParam::CopyFrom(const HSearchParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HSearchParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HSearchParam::IsInitialized() const { + return true; +} + +void HSearchParam::InternalSwap(HSearchParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(general_query_, other->general_query_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HSearchParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HSearchInSegmentsParam::InitAsDefaultInstance() { + ::milvus::grpc::_HSearchInSegmentsParam_default_instance_._instance.get_mutable()->search_param_ = const_cast< ::milvus::grpc::HSearchParam*>( + ::milvus::grpc::HSearchParam::internal_default_instance()); +} +class HSearchInSegmentsParam::_Internal { + public: + static const ::milvus::grpc::HSearchParam& search_param(const HSearchInSegmentsParam* msg); +}; + +const ::milvus::grpc::HSearchParam& +HSearchInSegmentsParam::_Internal::search_param(const HSearchInSegmentsParam* msg) { + return *msg->search_param_; +} +HSearchInSegmentsParam::HSearchInSegmentsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HSearchInSegmentsParam) +} +HSearchInSegmentsParam::HSearchInSegmentsParam(const HSearchInSegmentsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + segment_id_array_(from.segment_id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_search_param()) { + search_param_ = new ::milvus::grpc::HSearchParam(*from.search_param_); + } else { + search_param_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HSearchInSegmentsParam) +} + +void HSearchInSegmentsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HSearchInSegmentsParam_milvus_2eproto.base); + search_param_ = nullptr; +} + +HSearchInSegmentsParam::~HSearchInSegmentsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HSearchInSegmentsParam) + SharedDtor(); +} + +void HSearchInSegmentsParam::SharedDtor() { + if (this != internal_default_instance()) delete search_param_; +} + +void HSearchInSegmentsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HSearchInSegmentsParam& HSearchInSegmentsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HSearchInSegmentsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HSearchInSegmentsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + segment_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HSearchInSegmentsParam::_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) { + // repeated string segment_id_array = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_segment_id_array(), ptr, ctx, "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } else goto handle_unusual; + continue; + // .milvus.grpc.HSearchParam search_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(mutable_search_param(), ptr); + 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 HSearchInSegmentsParam::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.HSearchInSegmentsParam) + 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)) { + // repeated string segment_id_array = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_segment_id_array())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(this->segment_id_array_size() - 1).data(), + static_cast(this->segment_id_array(this->segment_id_array_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.HSearchParam search_param = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_search_param())); + } 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.HSearchInSegmentsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HSearchInSegmentsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HSearchInSegmentsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->segment_id_array(i), output); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, _Internal::search_param(this), 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.HSearchInSegmentsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HSearchInSegmentsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_id_array(i).data(), static_cast(this->segment_id_array(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HSearchInSegmentsParam.segment_id_array"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->segment_id_array(i), target); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, _Internal::search_param(this), 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.HSearchInSegmentsParam) + return target; +} + +size_t HSearchInSegmentsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HSearchInSegmentsParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string segment_id_array = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->segment_id_array_size()); + for (int i = 0, n = this->segment_id_array_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_id_array(i)); + } + + // .milvus.grpc.HSearchParam search_param = 2; + if (this->has_search_param()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *search_param_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HSearchInSegmentsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HSearchInSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + const HSearchInSegmentsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HSearchInSegmentsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HSearchInSegmentsParam) + MergeFrom(*source); + } +} + +void HSearchInSegmentsParam::MergeFrom(const HSearchInSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HSearchInSegmentsParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + segment_id_array_.MergeFrom(from.segment_id_array_); + if (from.has_search_param()) { + mutable_search_param()->::milvus::grpc::HSearchParam::MergeFrom(from.search_param()); + } +} + +void HSearchInSegmentsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HSearchInSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HSearchInSegmentsParam::CopyFrom(const HSearchInSegmentsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HSearchInSegmentsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HSearchInSegmentsParam::IsInitialized() const { + return true; +} + +void HSearchInSegmentsParam::InternalSwap(HSearchInSegmentsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + segment_id_array_.InternalSwap(CastToBase(&other->segment_id_array_)); + swap(search_param_, other->search_param_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HSearchInSegmentsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void AttrRecord::InitAsDefaultInstance() { +} +class AttrRecord::_Internal { + public: +}; + +AttrRecord::AttrRecord() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.AttrRecord) +} +AttrRecord::AttrRecord(const AttrRecord& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + value_(from.value_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:milvus.grpc.AttrRecord) +} + +void AttrRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_AttrRecord_milvus_2eproto.base); +} + +AttrRecord::~AttrRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.AttrRecord) + SharedDtor(); +} + +void AttrRecord::SharedDtor() { +} + +void AttrRecord::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const AttrRecord& AttrRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_AttrRecord_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void AttrRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* AttrRecord::_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) { + // repeated string value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_value(), ptr, ctx, "milvus.grpc.AttrRecord.value"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); + } 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 AttrRecord::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.AttrRecord) + 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)) { + // repeated string value = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_value())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(this->value_size() - 1).data(), + static_cast(this->value(this->value_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.AttrRecord.value")); + } 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.AttrRecord) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.AttrRecord) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void AttrRecord::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string value = 1; + for (int i = 0, n = this->value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(i).data(), static_cast(this->value(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.AttrRecord.value"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 1, this->value(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.AttrRecord) +} + +::PROTOBUF_NAMESPACE_ID::uint8* AttrRecord::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string value = 1; + for (int i = 0, n = this->value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->value(i).data(), static_cast(this->value(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.AttrRecord.value"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(1, this->value(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.AttrRecord) + return target; +} + +size_t AttrRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.AttrRecord) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string value = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->value_size()); + for (int i = 0, n = this->value_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->value(i)); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AttrRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + const AttrRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.AttrRecord) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.AttrRecord) + MergeFrom(*source); + } +} + +void AttrRecord::MergeFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.AttrRecord) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); +} + +void AttrRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttrRecord::CopyFrom(const AttrRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.AttrRecord) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttrRecord::IsInitialized() const { + return true; +} + +void AttrRecord::InternalSwap(AttrRecord* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + value_.InternalSwap(CastToBase(&other->value_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AttrRecord::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntity::InitAsDefaultInstance() { + ::milvus::grpc::_HEntity_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HEntity::_Internal { + public: + static const ::milvus::grpc::Status& status(const HEntity* msg); +}; + +const ::milvus::grpc::Status& +HEntity::_Internal::status(const HEntity* msg) { + return *msg->status_; +} +void HEntity::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HEntity::HEntity() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntity) +} +HEntity::HEntity(const HEntity& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + field_names_(from.field_names_), + attr_records_(from.attr_records_), + result_values_(from.result_values_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + entity_id_ = from.entity_id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntity) +} + +void HEntity::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntity_milvus_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&entity_id_) - + reinterpret_cast(&status_)) + sizeof(entity_id_)); +} + +HEntity::~HEntity() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntity) + SharedDtor(); +} + +void HEntity::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HEntity::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntity& HEntity::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntity_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntity::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_names_.Clear(); + attr_records_.Clear(); + result_values_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + entity_id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntity::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 entity_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + entity_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string field_names = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_field_names(), ptr, ctx, "milvus.grpc.HEntity.field_names"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.AttrRecord attr_records = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_attr_records(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.FieldValue result_values = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_result_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 HEntity::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.HEntity) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // int64 entity_id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &entity_id_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated string field_names = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_field_names())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(this->field_names_size() - 1).data(), + static_cast(this->field_names(this->field_names_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HEntity.field_names")); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_attr_records())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_result_values())); + } 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.HEntity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntity) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntity::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->entity_id(), output); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntity.field_names"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 3, this->field_names(i), output); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + for (unsigned int i = 0, + n = static_cast(this->attr_records_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->attr_records(static_cast(i)), + output); + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + for (unsigned int i = 0, + n = static_cast(this->result_values_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->result_values(static_cast(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.HEntity) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntity::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->entity_id(), target); + } + + // repeated string field_names = 3; + for (int i = 0, n = this->field_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->field_names(i).data(), static_cast(this->field_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntity.field_names"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(3, this->field_names(i), target); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + for (unsigned int i = 0, + n = static_cast(this->attr_records_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->attr_records(static_cast(i)), target); + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + for (unsigned int i = 0, + n = static_cast(this->result_values_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->result_values(static_cast(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.HEntity) + return target; +} + +size_t HEntity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntity) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string field_names = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->field_names_size()); + for (int i = 0, n = this->field_names_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->field_names(i)); + } + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + { + unsigned int count = static_cast(this->attr_records_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->attr_records(static_cast(i))); + } + } + + // repeated .milvus.grpc.FieldValue result_values = 5; + { + unsigned int count = static_cast(this->result_values_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->result_values(static_cast(i))); + } + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int64 entity_id = 2; + if (this->entity_id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->entity_id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntity::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntity) + GOOGLE_DCHECK_NE(&from, this); + const HEntity* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntity) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntity) + MergeFrom(*source); + } +} + +void HEntity::MergeFrom(const HEntity& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntity) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + field_names_.MergeFrom(from.field_names_); + attr_records_.MergeFrom(from.attr_records_); + result_values_.MergeFrom(from.result_values_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.entity_id() != 0) { + set_entity_id(from.entity_id()); + } +} + +void HEntity::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntity::CopyFrom(const HEntity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntity::IsInitialized() const { + return true; +} + +void HEntity::InternalSwap(HEntity* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + field_names_.InternalSwap(CastToBase(&other->field_names_)); + CastToBase(&attr_records_)->InternalSwap(CastToBase(&other->attr_records_)); + CastToBase(&result_values_)->InternalSwap(CastToBase(&other->result_values_)); + swap(status_, other->status_); + swap(entity_id_, other->entity_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntity::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HQueryResult::InitAsDefaultInstance() { + ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HQueryResult::_Internal { + public: + static const ::milvus::grpc::Status& status(const HQueryResult* msg); +}; + +const ::milvus::grpc::Status& +HQueryResult::_Internal::status(const HQueryResult* msg) { + return *msg->status_; +} +void HQueryResult::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HQueryResult::HQueryResult() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HQueryResult) +} +HQueryResult::HQueryResult(const HQueryResult& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entities_(from.entities_), + score_(from.score_), + distance_(from.distance_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + row_num_ = from.row_num_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HQueryResult) +} + +void HQueryResult::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HQueryResult_milvus_2eproto.base); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&row_num_) - + reinterpret_cast(&status_)) + sizeof(row_num_)); +} + +HQueryResult::~HQueryResult() { + // @@protoc_insertion_point(destructor:milvus.grpc.HQueryResult) + SharedDtor(); +} + +void HQueryResult::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HQueryResult::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HQueryResult& HQueryResult::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HQueryResult_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HQueryResult::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entities_.Clear(); + score_.Clear(); + distance_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + row_num_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HQueryResult::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.HEntity entities = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_entities(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + // int64 row_num = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + row_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated float score = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_score(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37) { + add_score(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // repeated float distance = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_distance(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45) { + add_distance(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } 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 HQueryResult::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.HQueryResult) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.HEntity entities = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_entities())); + } else { + goto handle_unusual; + } + break; + } + + // int64 row_num = 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>( + input, &row_num_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float score = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_score()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 34u, input, this->mutable_score()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated float distance = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_distance()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( + 1, 42u, input, this->mutable_distance()))); + } 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.HQueryResult) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HQueryResult) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HQueryResult::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.grpc.HEntity entities = 2; + for (unsigned int i = 0, + n = static_cast(this->entities_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->entities(static_cast(i)), + output); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->row_num(), output); + } + + // repeated float score = 4; + if (this->score_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_score_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->score().data(), this->score_size(), output); + } + + // repeated float distance = 5; + if (this->distance_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(5, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_distance_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray( + this->distance().data(), this->distance_size(), 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.HQueryResult) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HQueryResult::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.grpc.HEntity entities = 2; + for (unsigned int i = 0, + n = static_cast(this->entities_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->entities(static_cast(i)), target); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->row_num(), target); + } + + // repeated float score = 4; + if (this->score_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _score_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->score_, target); + } + + // repeated float distance = 5; + if (this->distance_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 5, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _distance_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->distance_, 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.HQueryResult) + return target; +} + +size_t HQueryResult::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HQueryResult) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.HEntity entities = 2; + { + unsigned int count = static_cast(this->entities_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->entities(static_cast(i))); + } + } + + // repeated float score = 4; + { + unsigned int count = static_cast(this->score_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _score_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated float distance = 5; + { + unsigned int count = static_cast(this->distance_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _distance_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int64 row_num = 3; + if (this->row_num() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->row_num()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HQueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HQueryResult) + GOOGLE_DCHECK_NE(&from, this); + const HQueryResult* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HQueryResult) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HQueryResult) + MergeFrom(*source); + } +} + +void HQueryResult::MergeFrom(const HQueryResult& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HQueryResult) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entities_.MergeFrom(from.entities_); + score_.MergeFrom(from.score_); + distance_.MergeFrom(from.distance_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.row_num() != 0) { + set_row_num(from.row_num()); + } +} + +void HQueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HQueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HQueryResult::CopyFrom(const HQueryResult& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HQueryResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HQueryResult::IsInitialized() const { + return true; +} + +void HQueryResult::InternalSwap(HQueryResult* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&entities_)->InternalSwap(CastToBase(&other->entities_)); + score_.InternalSwap(&other->score_); + distance_.InternalSwap(&other->distance_); + swap(status_, other->status_); + swap(row_num_, other->row_num_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HQueryResult::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HInsertParam::InitAsDefaultInstance() { + ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entities_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::HEntity::internal_default_instance()); +} +class HInsertParam::_Internal { + public: + static const ::milvus::grpc::HEntity& entities(const HInsertParam* msg); +}; + +const ::milvus::grpc::HEntity& +HInsertParam::_Internal::entities(const HInsertParam* msg) { + return *msg->entities_; +} +HInsertParam::HInsertParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HInsertParam) +} +HInsertParam::HInsertParam(const HInsertParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entity_id_array_(from.entity_id_array_), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.partition_tag().empty()) { + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_entities()) { + entities_ = new ::milvus::grpc::HEntity(*from.entities_); + } else { + entities_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HInsertParam) +} + +void HInsertParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HInsertParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + entities_ = nullptr; +} + +HInsertParam::~HInsertParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HInsertParam) + SharedDtor(); +} + +void HInsertParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete entities_; +} + +void HInsertParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HInsertParam& HInsertParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HInsertParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HInsertParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entity_id_array_.Clear(); + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HInsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HInsertParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string partition_tag = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "milvus.grpc.HInsertParam.partition_tag"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.grpc.HEntity entities = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(mutable_entities(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } 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 HInsertParam::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.HInsertParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HInsertParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string partition_tag = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_partition_tag())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HInsertParam.partition_tag")); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.grpc.HEntity entities = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_entities())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 34u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HInsertParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HInsertParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HInsertParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.partition_tag"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->partition_tag(), output); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, _Internal::entities(this), output); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(4, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, + this->extra_params(static_cast(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.HInsertParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HInsertParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_tag().data(), static_cast(this->partition_tag().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HInsertParam.partition_tag"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->partition_tag(), target); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, _Internal::entities(this), target); + } + + // repeated int64 entity_id_array = 4; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->extra_params(static_cast(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.HInsertParam) + return target; +} + +size_t HInsertParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HInsertParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 entity_id_array = 4; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string partition_tag = 2; + if (this->partition_tag().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_tag()); + } + + // .milvus.grpc.HEntity entities = 3; + if (this->has_entities()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *entities_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HInsertParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HInsertParam) + GOOGLE_DCHECK_NE(&from, this); + const HInsertParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HInsertParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HInsertParam) + MergeFrom(*source); + } +} + +void HInsertParam::MergeFrom(const HInsertParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HInsertParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entity_id_array_.MergeFrom(from.entity_id_array_); + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.partition_tag().size() > 0) { + + partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); + } + if (from.has_entities()) { + mutable_entities()->::milvus::grpc::HEntity::MergeFrom(from.entities()); + } +} + +void HInsertParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HInsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HInsertParam::CopyFrom(const HInsertParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HInsertParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HInsertParam::IsInitialized() const { + return true; +} + +void HInsertParam::InternalSwap(HInsertParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_array_.InternalSwap(&other->entity_id_array_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(entities_, other->entities_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HInsertParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntityIdentity::InitAsDefaultInstance() { +} +class HEntityIdentity::_Internal { + public: +}; + +HEntityIdentity::HEntityIdentity() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntityIdentity) +} +HEntityIdentity::HEntityIdentity(const HEntityIdentity& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntityIdentity) +} + +void HEntityIdentity::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntityIdentity_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + id_ = PROTOBUF_LONGLONG(0); +} + +HEntityIdentity::~HEntityIdentity() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntityIdentity) + SharedDtor(); +} + +void HEntityIdentity::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HEntityIdentity::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntityIdentity& HEntityIdentity::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntityIdentity_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntityIdentity::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + id_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntityIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HEntityIdentity.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + 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 HEntityIdentity::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.HEntityIdentity) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HEntityIdentity.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // int64 id = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &id_))); + } 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.HEntityIdentity) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntityIdentity) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntityIdentity::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntityIdentity.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // int64 id = 2; + if (this->id() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->id(), 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.HEntityIdentity) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntityIdentity::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HEntityIdentity.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // int64 id = 2; + if (this->id() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->id(), 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.HEntityIdentity) + return target; +} + +size_t HEntityIdentity::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntityIdentity) + 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 collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // int64 id = 2; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->id()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntityIdentity::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntityIdentity) + GOOGLE_DCHECK_NE(&from, this); + const HEntityIdentity* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntityIdentity) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntityIdentity) + MergeFrom(*source); + } +} + +void HEntityIdentity::MergeFrom(const HEntityIdentity& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntityIdentity) + 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.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.id() != 0) { + set_id(from.id()); + } +} + +void HEntityIdentity::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntityIdentity::CopyFrom(const HEntityIdentity& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntityIdentity) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntityIdentity::IsInitialized() const { + return true; +} + +void HEntityIdentity::InternalSwap(HEntityIdentity* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntityIdentity::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HEntityIDs::InitAsDefaultInstance() { + ::milvus::grpc::_HEntityIDs_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HEntityIDs::_Internal { + public: + static const ::milvus::grpc::Status& status(const HEntityIDs* msg); +}; + +const ::milvus::grpc::Status& +HEntityIDs::_Internal::status(const HEntityIDs* msg) { + return *msg->status_; +} +void HEntityIDs::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HEntityIDs::HEntityIDs() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HEntityIDs) +} +HEntityIDs::HEntityIDs(const HEntityIDs& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + entity_id_array_(from.entity_id_array_) { + _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.HEntityIDs) +} + +void HEntityIDs::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntityIDs_milvus_2eproto.base); + status_ = nullptr; +} + +HEntityIDs::~HEntityIDs() { + // @@protoc_insertion_point(destructor:milvus.grpc.HEntityIDs) + SharedDtor(); +} + +void HEntityIDs::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void HEntityIDs::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HEntityIDs& HEntityIDs::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HEntityIDs_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HEntityIDs::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + entity_id_array_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HEntityIDs::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 entity_id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_entity_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + 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 HEntityIDs::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.HEntityIDs) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 entity_id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_entity_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_entity_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HEntityIDs) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HEntityIDs) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HEntityIDs::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HEntityIDs) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HEntityIDs::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated int64 entity_id_array = 2; + if (this->entity_id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _entity_id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_array_, 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.HEntityIDs) + return target; +} + +size_t HEntityIDs::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HEntityIDs) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 entity_id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _entity_id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HEntityIDs::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HEntityIDs) + GOOGLE_DCHECK_NE(&from, this); + const HEntityIDs* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HEntityIDs) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HEntityIDs) + MergeFrom(*source); + } +} + +void HEntityIDs::MergeFrom(const HEntityIDs& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HEntityIDs) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + entity_id_array_.MergeFrom(from.entity_id_array_); + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } +} + +void HEntityIDs::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HEntityIDs) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HEntityIDs::CopyFrom(const HEntityIDs& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HEntityIDs) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HEntityIDs::IsInitialized() const { + return true; +} + +void HEntityIDs::InternalSwap(HEntityIDs* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_array_.InternalSwap(&other->entity_id_array_); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HEntityIDs::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HGetEntityIDsParam::InitAsDefaultInstance() { +} +class HGetEntityIDsParam::_Internal { + public: +}; + +HGetEntityIDsParam::HGetEntityIDsParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HGetEntityIDsParam) +} +HGetEntityIDsParam::HGetEntityIDsParam(const HGetEntityIDsParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.segment_name().empty()) { + segment_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.segment_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HGetEntityIDsParam) +} + +void HGetEntityIDsParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HGetEntityIDsParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HGetEntityIDsParam::~HGetEntityIDsParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HGetEntityIDsParam) + SharedDtor(); +} + +void HGetEntityIDsParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HGetEntityIDsParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HGetEntityIDsParam& HGetEntityIDsParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HGetEntityIDsParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HGetEntityIDsParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HGetEntityIDsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HGetEntityIDsParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string segment_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_segment_name(), ptr, ctx, "milvus.grpc.HGetEntityIDsParam.segment_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 HGetEntityIDsParam::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.HGetEntityIDsParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HGetEntityIDsParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string segment_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_segment_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HGetEntityIDsParam.segment_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.HGetEntityIDsParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HGetEntityIDsParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HGetEntityIDsParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.segment_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->segment_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.HGetEntityIDsParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HGetEntityIDsParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->segment_name().data(), static_cast(this->segment_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HGetEntityIDsParam.segment_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->segment_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.HGetEntityIDsParam) + return target; +} + +size_t HGetEntityIDsParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HGetEntityIDsParam) + 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 collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string segment_name = 2; + if (this->segment_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->segment_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HGetEntityIDsParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HGetEntityIDsParam) + GOOGLE_DCHECK_NE(&from, this); + const HGetEntityIDsParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HGetEntityIDsParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HGetEntityIDsParam) + MergeFrom(*source); + } +} + +void HGetEntityIDsParam::MergeFrom(const HGetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HGetEntityIDsParam) + 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.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.segment_name().size() > 0) { + + segment_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.segment_name_); + } +} + +void HGetEntityIDsParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HGetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HGetEntityIDsParam::CopyFrom(const HGetEntityIDsParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HGetEntityIDsParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HGetEntityIDsParam::IsInitialized() const { + return true; +} + +void HGetEntityIDsParam::InternalSwap(HGetEntityIDsParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + segment_name_.Swap(&other->segment_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HGetEntityIDsParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HDeleteByIDParam::InitAsDefaultInstance() { +} +class HDeleteByIDParam::_Internal { + public: +}; + +HDeleteByIDParam::HDeleteByIDParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HDeleteByIDParam) +} +HDeleteByIDParam::HDeleteByIDParam(const HDeleteByIDParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + id_array_(from.id_array_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HDeleteByIDParam) +} + +void HDeleteByIDParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HDeleteByIDParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +HDeleteByIDParam::~HDeleteByIDParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HDeleteByIDParam) + SharedDtor(); +} + +void HDeleteByIDParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void HDeleteByIDParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HDeleteByIDParam& HDeleteByIDParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HDeleteByIDParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HDeleteByIDParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_array_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HDeleteByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // string collection_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HDeleteByIDParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated int64 id_array = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id_array(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + 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 HDeleteByIDParam::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.HDeleteByIDParam) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // string collection_name = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HDeleteByIDParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 id_array = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_id_array()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 18u, input, this->mutable_id_array()))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.grpc.HDeleteByIDParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HDeleteByIDParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HDeleteByIDParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HDeleteByIDParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->collection_name(), output); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_array_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id_array(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.grpc.HDeleteByIDParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HDeleteByIDParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HDeleteByIDParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 1, this->collection_name(), target); + } + + // repeated int64 id_array = 2; + if (this->id_array_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 2, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _id_array_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_array_, 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.HDeleteByIDParam) + return target; +} + +size_t HDeleteByIDParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HDeleteByIDParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int64 id_array = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_array_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _id_array_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // string collection_name = 1; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HDeleteByIDParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HDeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + const HDeleteByIDParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HDeleteByIDParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HDeleteByIDParam) + MergeFrom(*source); + } +} + +void HDeleteByIDParam::MergeFrom(const HDeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HDeleteByIDParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + id_array_.MergeFrom(from.id_array_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } +} + +void HDeleteByIDParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HDeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HDeleteByIDParam::CopyFrom(const HDeleteByIDParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HDeleteByIDParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HDeleteByIDParam::IsInitialized() const { + return true; +} + +void HDeleteByIDParam::InternalSwap(HDeleteByIDParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + id_array_.InternalSwap(&other->id_array_); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HDeleteByIDParam::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void HIndexParam::InitAsDefaultInstance() { + ::milvus::grpc::_HIndexParam_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( + ::milvus::grpc::Status::internal_default_instance()); +} +class HIndexParam::_Internal { + public: + static const ::milvus::grpc::Status& status(const HIndexParam* msg); +}; + +const ::milvus::grpc::Status& +HIndexParam::_Internal::status(const HIndexParam* msg) { + return *msg->status_; +} +void HIndexParam::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +HIndexParam::HIndexParam() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.grpc.HIndexParam) +} +HIndexParam::HIndexParam(const HIndexParam& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + extra_params_(from.extra_params_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + status_ = new ::milvus::grpc::Status(*from.status_); + } else { + status_ = nullptr; + } + index_type_ = from.index_type_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.HIndexParam) +} + +void HIndexParam::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HIndexParam_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ::memset(&status_, 0, static_cast( + reinterpret_cast(&index_type_) - + reinterpret_cast(&status_)) + sizeof(index_type_)); +} + +HIndexParam::~HIndexParam() { + // @@protoc_insertion_point(destructor:milvus.grpc.HIndexParam) + SharedDtor(); +} + +void HIndexParam::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete status_; +} + +void HIndexParam::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const HIndexParam& HIndexParam::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_HIndexParam_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void HIndexParam::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extra_params_.Clear(); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + index_type_ = 0; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* HIndexParam::_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) { + // .milvus.grpc.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.HIndexParam.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 index_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + index_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_extra_params(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 34); + } 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 HIndexParam::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.HIndexParam) + 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)) { + // .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_status())); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.grpc.HIndexParam.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // int32 index_type = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>( + input, &index_type_))); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } 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.HIndexParam) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.grpc.HIndexParam) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void HIndexParam::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HIndexParam.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->collection_name(), output); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(3, this->index_type(), output); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, + this->extra_params(static_cast(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.HIndexParam) +} + +::PROTOBUF_NAMESPACE_ID::uint8* HIndexParam::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.grpc.HIndexParam.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->collection_name(), target); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->index_type(), target); + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 4, this->extra_params(static_cast(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.HIndexParam) + return target; +} + +size_t HIndexParam::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.HIndexParam) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + { + unsigned int count = static_cast(this->extra_params_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->extra_params(static_cast(i))); + } + } + + // string collection_name = 2; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // .milvus.grpc.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + // int32 index_type = 3; + if (this->index_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->index_type()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void HIndexParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.HIndexParam) + GOOGLE_DCHECK_NE(&from, this); + const HIndexParam* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.HIndexParam) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.HIndexParam) + MergeFrom(*source); + } +} + +void HIndexParam::MergeFrom(const HIndexParam& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.HIndexParam) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extra_params_.MergeFrom(from.extra_params_); + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.has_status()) { + mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); + } + if (from.index_type() != 0) { + set_index_type(from.index_type()); + } +} + +void HIndexParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.HIndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void HIndexParam::CopyFrom(const HIndexParam& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.HIndexParam) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool HIndexParam::IsInitialized() const { + return true; +} + +void HIndexParam::InternalSwap(HIndexParam* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(status_, other->status_); + swap(index_type_, other->index_type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata HIndexParam::GetMetadata() const { + return GetMetadataStatic(); +} + + // @@protoc_insertion_point(namespace_scope) } // namespace grpc } // namespace milvus @@ -10460,6 +20829,78 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorData* Arena::CreateMaybeMessa template<> PROTOBUF_NOINLINE ::milvus::grpc::GetVectorIDsParam* Arena::CreateMaybeMessage< ::milvus::grpc::GetVectorIDsParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::GetVectorIDsParam >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldType* Arena::CreateMaybeMessage< ::milvus::grpc::FieldType >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldType >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage< ::milvus::grpc::FieldParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldValue >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::FieldValue >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::FieldValue >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::Mapping* Arena::CreateMaybeMessage< ::milvus::grpc::Mapping >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::Mapping >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::MappingList* Arena::CreateMaybeMessage< ::milvus::grpc::MappingList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::MappingList >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage< ::milvus::grpc::TermQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::TermQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage< ::milvus::grpc::CompareExpr >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CompareExpr >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage< ::milvus::grpc::RangeQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::RangeQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage< ::milvus::grpc::VectorQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage< ::milvus::grpc::BooleanQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::BooleanQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage< ::milvus::grpc::GeneralQuery >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::GeneralQuery >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HSearchParam* Arena::CreateMaybeMessage< ::milvus::grpc::HSearchParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HSearchParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HSearchInSegmentsParam* Arena::CreateMaybeMessage< ::milvus::grpc::HSearchInSegmentsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HSearchInSegmentsParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::AttrRecord* Arena::CreateMaybeMessage< ::milvus::grpc::AttrRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::AttrRecord >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntity* Arena::CreateMaybeMessage< ::milvus::grpc::HEntity >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntity >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HQueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::HQueryResult >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HQueryResult >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HInsertParam* Arena::CreateMaybeMessage< ::milvus::grpc::HInsertParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HInsertParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntityIdentity* Arena::CreateMaybeMessage< ::milvus::grpc::HEntityIdentity >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntityIdentity >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HEntityIDs* Arena::CreateMaybeMessage< ::milvus::grpc::HEntityIDs >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HEntityIDs >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HGetEntityIDsParam* Arena::CreateMaybeMessage< ::milvus::grpc::HGetEntityIDsParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HGetEntityIDsParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HDeleteByIDParam* Arena::CreateMaybeMessage< ::milvus::grpc::HDeleteByIDParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HDeleteByIDParam >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::grpc::HIndexParam* Arena::CreateMaybeMessage< ::milvus::grpc::HIndexParam >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::HIndexParam >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.h b/sdk/grpc-gen/gen-milvus/milvus.pb.h index 88113f73f7..0bd2527120 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.h @@ -31,6 +31,7 @@ #include #include // IWYU pragma: export #include // IWYU pragma: export +#include #include #include "status.pb.h" // @@protoc_insertion_point(includes) @@ -48,7 +49,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[50] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -57,9 +58,15 @@ struct TableStruct_milvus_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto; namespace milvus { namespace grpc { +class AttrRecord; +class AttrRecordDefaultTypeInternal; +extern AttrRecordDefaultTypeInternal _AttrRecord_default_instance_; class BoolReply; class BoolReplyDefaultTypeInternal; extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_; +class BooleanQuery; +class BooleanQueryDefaultTypeInternal; +extern BooleanQueryDefaultTypeInternal _BooleanQuery_default_instance_; class CollectionInfo; class CollectionInfoDefaultTypeInternal; extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_; @@ -78,15 +85,60 @@ extern CollectionSchemaDefaultTypeInternal _CollectionSchema_default_instance_; class Command; class CommandDefaultTypeInternal; extern CommandDefaultTypeInternal _Command_default_instance_; +class CompareExpr; +class CompareExprDefaultTypeInternal; +extern CompareExprDefaultTypeInternal _CompareExpr_default_instance_; class DeleteByIDParam; class DeleteByIDParamDefaultTypeInternal; extern DeleteByIDParamDefaultTypeInternal _DeleteByIDParam_default_instance_; +class FieldParam; +class FieldParamDefaultTypeInternal; +extern FieldParamDefaultTypeInternal _FieldParam_default_instance_; +class FieldType; +class FieldTypeDefaultTypeInternal; +extern FieldTypeDefaultTypeInternal _FieldType_default_instance_; +class FieldValue; +class FieldValueDefaultTypeInternal; +extern FieldValueDefaultTypeInternal _FieldValue_default_instance_; class FlushParam; class FlushParamDefaultTypeInternal; extern FlushParamDefaultTypeInternal _FlushParam_default_instance_; +class GeneralQuery; +class GeneralQueryDefaultTypeInternal; +extern GeneralQueryDefaultTypeInternal _GeneralQuery_default_instance_; class GetVectorIDsParam; class GetVectorIDsParamDefaultTypeInternal; extern GetVectorIDsParamDefaultTypeInternal _GetVectorIDsParam_default_instance_; +class HDeleteByIDParam; +class HDeleteByIDParamDefaultTypeInternal; +extern HDeleteByIDParamDefaultTypeInternal _HDeleteByIDParam_default_instance_; +class HEntity; +class HEntityDefaultTypeInternal; +extern HEntityDefaultTypeInternal _HEntity_default_instance_; +class HEntityIDs; +class HEntityIDsDefaultTypeInternal; +extern HEntityIDsDefaultTypeInternal _HEntityIDs_default_instance_; +class HEntityIdentity; +class HEntityIdentityDefaultTypeInternal; +extern HEntityIdentityDefaultTypeInternal _HEntityIdentity_default_instance_; +class HGetEntityIDsParam; +class HGetEntityIDsParamDefaultTypeInternal; +extern HGetEntityIDsParamDefaultTypeInternal _HGetEntityIDsParam_default_instance_; +class HIndexParam; +class HIndexParamDefaultTypeInternal; +extern HIndexParamDefaultTypeInternal _HIndexParam_default_instance_; +class HInsertParam; +class HInsertParamDefaultTypeInternal; +extern HInsertParamDefaultTypeInternal _HInsertParam_default_instance_; +class HQueryResult; +class HQueryResultDefaultTypeInternal; +extern HQueryResultDefaultTypeInternal _HQueryResult_default_instance_; +class HSearchInSegmentsParam; +class HSearchInSegmentsParamDefaultTypeInternal; +extern HSearchInSegmentsParamDefaultTypeInternal _HSearchInSegmentsParam_default_instance_; +class HSearchParam; +class HSearchParamDefaultTypeInternal; +extern HSearchParamDefaultTypeInternal _HSearchParam_default_instance_; class IndexParam; class IndexParamDefaultTypeInternal; extern IndexParamDefaultTypeInternal _IndexParam_default_instance_; @@ -96,6 +148,12 @@ extern InsertParamDefaultTypeInternal _InsertParam_default_instance_; class KeyValuePair; class KeyValuePairDefaultTypeInternal; extern KeyValuePairDefaultTypeInternal _KeyValuePair_default_instance_; +class Mapping; +class MappingDefaultTypeInternal; +extern MappingDefaultTypeInternal _Mapping_default_instance_; +class MappingList; +class MappingListDefaultTypeInternal; +extern MappingListDefaultTypeInternal _MappingList_default_instance_; class PartitionList; class PartitionListDefaultTypeInternal; extern PartitionListDefaultTypeInternal _PartitionList_default_instance_; @@ -105,6 +163,9 @@ extern PartitionParamDefaultTypeInternal _PartitionParam_default_instance_; class PartitionStat; class PartitionStatDefaultTypeInternal; extern PartitionStatDefaultTypeInternal _PartitionStat_default_instance_; +class RangeQuery; +class RangeQueryDefaultTypeInternal; +extern RangeQueryDefaultTypeInternal _RangeQuery_default_instance_; class RowRecord; class RowRecordDefaultTypeInternal; extern RowRecordDefaultTypeInternal _RowRecord_default_instance_; @@ -123,51 +184,177 @@ extern SegmentStatDefaultTypeInternal _SegmentStat_default_instance_; class StringReply; class StringReplyDefaultTypeInternal; extern StringReplyDefaultTypeInternal _StringReply_default_instance_; +class TermQuery; +class TermQueryDefaultTypeInternal; +extern TermQueryDefaultTypeInternal _TermQuery_default_instance_; class TopKQueryResult; class TopKQueryResultDefaultTypeInternal; extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; class VectorData; class VectorDataDefaultTypeInternal; extern VectorDataDefaultTypeInternal _VectorData_default_instance_; +class VectorFieldParam; +class VectorFieldParamDefaultTypeInternal; +extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_; +class VectorFieldValue; +class VectorFieldValueDefaultTypeInternal; +extern VectorFieldValueDefaultTypeInternal _VectorFieldValue_default_instance_; class VectorIdentity; class VectorIdentityDefaultTypeInternal; extern VectorIdentityDefaultTypeInternal _VectorIdentity_default_instance_; class VectorIds; class VectorIdsDefaultTypeInternal; extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; +class VectorQuery; +class VectorQueryDefaultTypeInternal; +extern VectorQueryDefaultTypeInternal _VectorQuery_default_instance_; } // namespace grpc } // namespace milvus PROTOBUF_NAMESPACE_OPEN +template<> ::milvus::grpc::AttrRecord* Arena::CreateMaybeMessage<::milvus::grpc::AttrRecord>(Arena*); template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*); +template<> ::milvus::grpc::BooleanQuery* Arena::CreateMaybeMessage<::milvus::grpc::BooleanQuery>(Arena*); template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*); template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*); template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*); template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*); template<> ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage<::milvus::grpc::CollectionSchema>(Arena*); template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*); +template<> ::milvus::grpc::CompareExpr* Arena::CreateMaybeMessage<::milvus::grpc::CompareExpr>(Arena*); template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*); +template<> ::milvus::grpc::FieldParam* Arena::CreateMaybeMessage<::milvus::grpc::FieldParam>(Arena*); +template<> ::milvus::grpc::FieldType* Arena::CreateMaybeMessage<::milvus::grpc::FieldType>(Arena*); +template<> ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage<::milvus::grpc::FieldValue>(Arena*); template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*); +template<> ::milvus::grpc::GeneralQuery* Arena::CreateMaybeMessage<::milvus::grpc::GeneralQuery>(Arena*); template<> ::milvus::grpc::GetVectorIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::GetVectorIDsParam>(Arena*); +template<> ::milvus::grpc::HDeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::HDeleteByIDParam>(Arena*); +template<> ::milvus::grpc::HEntity* Arena::CreateMaybeMessage<::milvus::grpc::HEntity>(Arena*); +template<> ::milvus::grpc::HEntityIDs* Arena::CreateMaybeMessage<::milvus::grpc::HEntityIDs>(Arena*); +template<> ::milvus::grpc::HEntityIdentity* Arena::CreateMaybeMessage<::milvus::grpc::HEntityIdentity>(Arena*); +template<> ::milvus::grpc::HGetEntityIDsParam* Arena::CreateMaybeMessage<::milvus::grpc::HGetEntityIDsParam>(Arena*); +template<> ::milvus::grpc::HIndexParam* Arena::CreateMaybeMessage<::milvus::grpc::HIndexParam>(Arena*); +template<> ::milvus::grpc::HInsertParam* Arena::CreateMaybeMessage<::milvus::grpc::HInsertParam>(Arena*); +template<> ::milvus::grpc::HQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::HQueryResult>(Arena*); +template<> ::milvus::grpc::HSearchInSegmentsParam* Arena::CreateMaybeMessage<::milvus::grpc::HSearchInSegmentsParam>(Arena*); +template<> ::milvus::grpc::HSearchParam* Arena::CreateMaybeMessage<::milvus::grpc::HSearchParam>(Arena*); template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*); template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*); template<> ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage<::milvus::grpc::KeyValuePair>(Arena*); +template<> ::milvus::grpc::Mapping* Arena::CreateMaybeMessage<::milvus::grpc::Mapping>(Arena*); +template<> ::milvus::grpc::MappingList* Arena::CreateMaybeMessage<::milvus::grpc::MappingList>(Arena*); template<> ::milvus::grpc::PartitionList* Arena::CreateMaybeMessage<::milvus::grpc::PartitionList>(Arena*); template<> ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage<::milvus::grpc::PartitionParam>(Arena*); template<> ::milvus::grpc::PartitionStat* Arena::CreateMaybeMessage<::milvus::grpc::PartitionStat>(Arena*); +template<> ::milvus::grpc::RangeQuery* Arena::CreateMaybeMessage<::milvus::grpc::RangeQuery>(Arena*); template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*); template<> ::milvus::grpc::SearchByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchByIDParam>(Arena*); template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*); template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*); template<> ::milvus::grpc::SegmentStat* Arena::CreateMaybeMessage<::milvus::grpc::SegmentStat>(Arena*); template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*); +template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorData* Arena::CreateMaybeMessage<::milvus::grpc::VectorData>(Arena*); +template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*); +template<> ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldValue>(Arena*); template<> ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage<::milvus::grpc::VectorIdentity>(Arena*); template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*); +template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace milvus { namespace grpc { +enum DataType : int { + NULL_ = 0, + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + STRING = 20, + BOOL = 30, + FLOAT = 40, + DOUBLE = 41, + VECTOR = 100, + UNKNOWN = 9999, + DataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DataType_IsValid(int value); +constexpr DataType DataType_MIN = NULL_; +constexpr DataType DataType_MAX = UNKNOWN; +constexpr int DataType_ARRAYSIZE = DataType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DataType_descriptor(); +template +inline const std::string& DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DataType_descriptor(), enum_t_value); +} +inline bool DataType_Parse( + const std::string& name, DataType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DataType_descriptor(), name, value); +} +enum CompareOperator : int { + LT = 0, + LTE = 1, + EQ = 2, + GT = 3, + GTE = 4, + NE = 5, + CompareOperator_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + CompareOperator_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool CompareOperator_IsValid(int value); +constexpr CompareOperator CompareOperator_MIN = LT; +constexpr CompareOperator CompareOperator_MAX = NE; +constexpr int CompareOperator_ARRAYSIZE = CompareOperator_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompareOperator_descriptor(); +template +inline const std::string& CompareOperator_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CompareOperator_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + CompareOperator_descriptor(), enum_t_value); +} +inline bool CompareOperator_Parse( + const std::string& name, CompareOperator* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + CompareOperator_descriptor(), name, value); +} +enum Occur : int { + INVALID = 0, + MUST = 1, + SHOULD = 2, + MUST_NOT = 3, + Occur_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Occur_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Occur_IsValid(int value); +constexpr Occur Occur_MIN = INVALID; +constexpr Occur Occur_MAX = MUST_NOT; +constexpr int Occur_ARRAYSIZE = Occur_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Occur_descriptor(); +template +inline const std::string& Occur_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Occur_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Occur_descriptor(), enum_t_value); +} +inline bool Occur_Parse( + const std::string& name, Occur* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Occur_descriptor(), name, value); +} // =================================================================== class KeyValuePair : @@ -4215,6 +4402,3932 @@ class GetVectorIDsParam : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; +// ------------------------------------------------------------------- + +class VectorFieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldParam) */ { + public: + VectorFieldParam(); + virtual ~VectorFieldParam(); + + VectorFieldParam(const VectorFieldParam& from); + VectorFieldParam(VectorFieldParam&& from) noexcept + : VectorFieldParam() { + *this = ::std::move(from); + } + + inline VectorFieldParam& operator=(const VectorFieldParam& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldParam& operator=(VectorFieldParam&& 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 VectorFieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldParam* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(VectorFieldParam& a, VectorFieldParam& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldParam& from); + void MergeFrom(const VectorFieldParam& 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(VectorFieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldParam"; + } + 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 { + kDimensionFieldNumber = 1, + }; + // int64 dimension = 1; + void clear_dimension(); + ::PROTOBUF_NAMESPACE_ID::int64 dimension() const; + void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 dimension_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldType : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldType) */ { + public: + FieldType(); + virtual ~FieldType(); + + FieldType(const FieldType& from); + FieldType(FieldType&& from) noexcept + : FieldType() { + *this = ::std::move(from); + } + + inline FieldType& operator=(const FieldType& from) { + CopyFrom(from); + return *this; + } + inline FieldType& operator=(FieldType&& 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 FieldType& default_instance(); + + enum ValueCase { + kDataType = 1, + kVectorParam = 2, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldType* internal_default_instance() { + return reinterpret_cast( + &_FieldType_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(FieldType& a, FieldType& b) { + a.Swap(&b); + } + inline void Swap(FieldType* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldType* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldType& from); + void MergeFrom(const FieldType& 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(FieldType* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldType"; + } + 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 { + kDataTypeFieldNumber = 1, + kVectorParamFieldNumber = 2, + }; + // .milvus.grpc.DataType data_type = 1; + private: + bool has_data_type() const; + public: + void clear_data_type(); + ::milvus::grpc::DataType data_type() const; + void set_data_type(::milvus::grpc::DataType value); + + // .milvus.grpc.VectorFieldParam vector_param = 2; + bool has_vector_param() const; + void clear_vector_param(); + const ::milvus::grpc::VectorFieldParam& vector_param() const; + ::milvus::grpc::VectorFieldParam* release_vector_param(); + ::milvus::grpc::VectorFieldParam* mutable_vector_param(); + void set_allocated_vector_param(::milvus::grpc::VectorFieldParam* vector_param); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldType) + private: + class _Internal; + void set_has_data_type(); + void set_has_vector_param(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + int data_type_; + ::milvus::grpc::VectorFieldParam* vector_param_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldParam) */ { + public: + FieldParam(); + virtual ~FieldParam(); + + FieldParam(const FieldParam& from); + FieldParam(FieldParam&& from) noexcept + : FieldParam() { + *this = ::std::move(from); + } + + inline FieldParam& operator=(const FieldParam& from) { + CopyFrom(from); + return *this; + } + inline FieldParam& operator=(FieldParam&& 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 FieldParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldParam* internal_default_instance() { + return reinterpret_cast( + &_FieldParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(FieldParam& a, FieldParam& b) { + a.Swap(&b); + } + inline void Swap(FieldParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldParam& from); + void MergeFrom(const FieldParam& 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(FieldParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldParam"; + } + 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 { + kExtraParamsFieldNumber = 4, + kNameFieldNumber = 2, + kTypeFieldNumber = 3, + kIdFieldNumber = 1, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string name = 2; + void clear_name(); + const std::string& name() const; + void set_name(const std::string& value); + void set_name(std::string&& value); + void set_name(const char* value); + void set_name(const char* value, size_t size); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + + // .milvus.grpc.FieldType type = 3; + bool has_type() const; + void clear_type(); + const ::milvus::grpc::FieldType& type() const; + ::milvus::grpc::FieldType* release_type(); + ::milvus::grpc::FieldType* mutable_type(); + void set_allocated_type(::milvus::grpc::FieldType* type); + + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::milvus::grpc::FieldType* type_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorFieldValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldValue) */ { + public: + VectorFieldValue(); + virtual ~VectorFieldValue(); + + VectorFieldValue(const VectorFieldValue& from); + VectorFieldValue(VectorFieldValue&& from) noexcept + : VectorFieldValue() { + *this = ::std::move(from); + } + + inline VectorFieldValue& operator=(const VectorFieldValue& from) { + CopyFrom(from); + return *this; + } + inline VectorFieldValue& operator=(VectorFieldValue&& 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 VectorFieldValue& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorFieldValue* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(VectorFieldValue& a, VectorFieldValue& b) { + a.Swap(&b); + } + inline void Swap(VectorFieldValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorFieldValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorFieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorFieldValue& from); + void MergeFrom(const VectorFieldValue& 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(VectorFieldValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorFieldValue"; + } + 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 { + kValueFieldNumber = 1, + }; + // repeated .milvus.grpc.RowRecord value = 1; + int value_size() const; + void clear_value(); + ::milvus::grpc::RowRecord* mutable_value(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* + mutable_value(); + const ::milvus::grpc::RowRecord& value(int index) const; + ::milvus::grpc::RowRecord* add_value(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& + value() const; + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldValue) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldValue : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.FieldValue) */ { + public: + FieldValue(); + virtual ~FieldValue(); + + FieldValue(const FieldValue& from); + FieldValue(FieldValue&& from) noexcept + : FieldValue() { + *this = ::std::move(from); + } + + inline FieldValue& operator=(const FieldValue& from) { + CopyFrom(from); + return *this; + } + inline FieldValue& operator=(FieldValue&& 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 FieldValue& default_instance(); + + enum ValueCase { + kInt32Value = 1, + kInt64Value = 2, + kFloatValue = 3, + kDoubleValue = 4, + kStringValue = 5, + kBoolValue = 6, + kVectorValue = 7, + VALUE_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const FieldValue* internal_default_instance() { + return reinterpret_cast( + &_FieldValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(FieldValue& a, FieldValue& b) { + a.Swap(&b); + } + inline void Swap(FieldValue* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldValue& from); + void MergeFrom(const FieldValue& 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(FieldValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.FieldValue"; + } + 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 { + kInt32ValueFieldNumber = 1, + kInt64ValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kDoubleValueFieldNumber = 4, + kStringValueFieldNumber = 5, + kBoolValueFieldNumber = 6, + kVectorValueFieldNumber = 7, + }; + // int32 int32_value = 1; + private: + bool has_int32_value() const; + public: + void clear_int32_value(); + ::PROTOBUF_NAMESPACE_ID::int32 int32_value() const; + void set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value); + + // int64 int64_value = 2; + private: + bool has_int64_value() const; + public: + void clear_int64_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int64_value() const; + void set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float float_value = 3; + private: + bool has_float_value() const; + public: + void clear_float_value(); + float float_value() const; + void set_float_value(float value); + + // double double_value = 4; + private: + bool has_double_value() const; + public: + void clear_double_value(); + double double_value() const; + void set_double_value(double value); + + // string string_value = 5; + private: + bool has_string_value() const; + public: + void clear_string_value(); + const std::string& string_value() const; + void set_string_value(const std::string& value); + void set_string_value(std::string&& value); + void set_string_value(const char* value); + void set_string_value(const char* value, size_t size); + std::string* mutable_string_value(); + std::string* release_string_value(); + void set_allocated_string_value(std::string* string_value); + + // bool bool_value = 6; + private: + bool has_bool_value() const; + public: + void clear_bool_value(); + bool bool_value() const; + void set_bool_value(bool value); + + // .milvus.grpc.VectorFieldValue vector_value = 7; + bool has_vector_value() const; + void clear_vector_value(); + const ::milvus::grpc::VectorFieldValue& vector_value() const; + ::milvus::grpc::VectorFieldValue* release_vector_value(); + ::milvus::grpc::VectorFieldValue* mutable_vector_value(); + void set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.FieldValue) + private: + class _Internal; + void set_has_int32_value(); + void set_has_int64_value(); + void set_has_float_value(); + void set_has_double_value(); + void set_has_string_value(); + void set_has_bool_value(); + void set_has_vector_value(); + + inline bool has_value() const; + inline void clear_has_value(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union ValueUnion { + ValueUnion() {} + ::PROTOBUF_NAMESPACE_ID::int32 int32_value_; + ::PROTOBUF_NAMESPACE_ID::int64 int64_value_; + float float_value_; + double double_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_; + bool bool_value_; + ::milvus::grpc::VectorFieldValue* vector_value_; + } value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class Mapping : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Mapping) */ { + public: + Mapping(); + virtual ~Mapping(); + + Mapping(const Mapping& from); + Mapping(Mapping&& from) noexcept + : Mapping() { + *this = ::std::move(from); + } + + inline Mapping& operator=(const Mapping& from) { + CopyFrom(from); + return *this; + } + inline Mapping& operator=(Mapping&& 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 Mapping& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const Mapping* internal_default_instance() { + return reinterpret_cast( + &_Mapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(Mapping& a, Mapping& b) { + a.Swap(&b); + } + inline void Swap(Mapping* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Mapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Mapping& from); + void MergeFrom(const Mapping& 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(Mapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.Mapping"; + } + 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 { + kFieldsFieldNumber = 4, + kCollectionNameFieldNumber = 3, + kStatusFieldNumber = 1, + kCollectionIdFieldNumber = 2, + }; + // repeated .milvus.grpc.FieldParam fields = 4; + int fields_size() const; + void clear_fields(); + ::milvus::grpc::FieldParam* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >* + mutable_fields(); + const ::milvus::grpc::FieldParam& fields(int index) const; + ::milvus::grpc::FieldParam* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >& + fields() const; + + // string collection_name = 3; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .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); + + // uint64 collection_id = 2; + void clear_collection_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id() const; + void set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.Mapping) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam > fields_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::uint64 collection_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class MappingList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.MappingList) */ { + public: + MappingList(); + virtual ~MappingList(); + + MappingList(const MappingList& from); + MappingList(MappingList&& from) noexcept + : MappingList() { + *this = ::std::move(from); + } + + inline MappingList& operator=(const MappingList& from) { + CopyFrom(from); + return *this; + } + inline MappingList& operator=(MappingList&& 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 MappingList& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const MappingList* internal_default_instance() { + return reinterpret_cast( + &_MappingList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(MappingList& a, MappingList& b) { + a.Swap(&b); + } + inline void Swap(MappingList* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MappingList* New() const final { + return CreateMaybeMessage(nullptr); + } + + MappingList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MappingList& from); + void MergeFrom(const MappingList& 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(MappingList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.MappingList"; + } + 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 { + kMappingListFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated .milvus.grpc.Mapping mapping_list = 2; + int mapping_list_size() const; + void clear_mapping_list(); + ::milvus::grpc::Mapping* mutable_mapping_list(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* + mutable_mapping_list(); + const ::milvus::grpc::Mapping& mapping_list(int index) const; + ::milvus::grpc::Mapping* add_mapping_list(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& + mapping_list() const; + + // .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); + + // @@protoc_insertion_point(class_scope:milvus.grpc.MappingList) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping > mapping_list_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class TermQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TermQuery) */ { + public: + TermQuery(); + virtual ~TermQuery(); + + TermQuery(const TermQuery& from); + TermQuery(TermQuery&& from) noexcept + : TermQuery() { + *this = ::std::move(from); + } + + inline TermQuery& operator=(const TermQuery& from) { + CopyFrom(from); + return *this; + } + inline TermQuery& operator=(TermQuery&& 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 TermQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const TermQuery* internal_default_instance() { + return reinterpret_cast( + &_TermQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(TermQuery& a, TermQuery& b) { + a.Swap(&b); + } + inline void Swap(TermQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline TermQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + TermQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const TermQuery& from); + void MergeFrom(const TermQuery& 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(TermQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.TermQuery"; + } + 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 { + kValuesFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kFieldNameFieldNumber = 1, + kBoostFieldNumber = 3, + }; + // repeated string values = 2; + int values_size() const; + void clear_values(); + const std::string& values(int index) const; + std::string* mutable_values(int index); + void set_values(int index, const std::string& value); + void set_values(int index, std::string&& value); + void set_values(int index, const char* value); + void set_values(int index, const char* value, size_t size); + std::string* add_values(); + void add_values(const std::string& value); + void add_values(std::string&& value); + void add_values(const char* value); + void add_values(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_values(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // float boost = 3; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.TermQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField values_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class CompareExpr : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CompareExpr) */ { + public: + CompareExpr(); + virtual ~CompareExpr(); + + CompareExpr(const CompareExpr& from); + CompareExpr(CompareExpr&& from) noexcept + : CompareExpr() { + *this = ::std::move(from); + } + + inline CompareExpr& operator=(const CompareExpr& from) { + CopyFrom(from); + return *this; + } + inline CompareExpr& operator=(CompareExpr&& 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 CompareExpr& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const CompareExpr* internal_default_instance() { + return reinterpret_cast( + &_CompareExpr_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(CompareExpr& a, CompareExpr& b) { + a.Swap(&b); + } + inline void Swap(CompareExpr* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline CompareExpr* New() const final { + return CreateMaybeMessage(nullptr); + } + + CompareExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const CompareExpr& from); + void MergeFrom(const CompareExpr& 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(CompareExpr* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.CompareExpr"; + } + 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 { + kOperandFieldNumber = 2, + kOperatorFieldNumber = 1, + }; + // string operand = 2; + void clear_operand(); + const std::string& operand() const; + void set_operand(const std::string& value); + void set_operand(std::string&& value); + void set_operand(const char* value); + void set_operand(const char* value, size_t size); + std::string* mutable_operand(); + std::string* release_operand(); + void set_allocated_operand(std::string* operand); + + // .milvus.grpc.CompareOperator operator = 1; + void clear_operator_(); + ::milvus::grpc::CompareOperator operator_() const; + void set_operator_(::milvus::grpc::CompareOperator value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.CompareExpr) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operand_; + int operator__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class RangeQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RangeQuery) */ { + public: + RangeQuery(); + virtual ~RangeQuery(); + + RangeQuery(const RangeQuery& from); + RangeQuery(RangeQuery&& from) noexcept + : RangeQuery() { + *this = ::std::move(from); + } + + inline RangeQuery& operator=(const RangeQuery& from) { + CopyFrom(from); + return *this; + } + inline RangeQuery& operator=(RangeQuery&& 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 RangeQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const RangeQuery* internal_default_instance() { + return reinterpret_cast( + &_RangeQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(RangeQuery& a, RangeQuery& b) { + a.Swap(&b); + } + inline void Swap(RangeQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RangeQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + RangeQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RangeQuery& from); + void MergeFrom(const RangeQuery& 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(RangeQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.RangeQuery"; + } + 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 { + kOperandFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kFieldNameFieldNumber = 1, + kBoostFieldNumber = 3, + }; + // repeated .milvus.grpc.CompareExpr operand = 2; + int operand_size() const; + void clear_operand(); + ::milvus::grpc::CompareExpr* mutable_operand(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* + mutable_operand(); + const ::milvus::grpc::CompareExpr& operand(int index) const; + ::milvus::grpc::CompareExpr* add_operand(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& + operand() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // float boost = 3; + void clear_boost(); + float boost() const; + void set_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.RangeQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr > operand_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + float boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class VectorQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorQuery) */ { + public: + VectorQuery(); + virtual ~VectorQuery(); + + VectorQuery(const VectorQuery& from); + VectorQuery(VectorQuery&& from) noexcept + : VectorQuery() { + *this = ::std::move(from); + } + + inline VectorQuery& operator=(const VectorQuery& from) { + CopyFrom(from); + return *this; + } + inline VectorQuery& operator=(VectorQuery&& 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 VectorQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const VectorQuery* internal_default_instance() { + return reinterpret_cast( + &_VectorQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(VectorQuery& a, VectorQuery& b) { + a.Swap(&b); + } + inline void Swap(VectorQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline VectorQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + VectorQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const VectorQuery& from); + void MergeFrom(const VectorQuery& 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(VectorQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.VectorQuery"; + } + 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 { + kRecordsFieldNumber = 3, + kExtraParamsFieldNumber = 5, + kFieldNameFieldNumber = 1, + kTopkFieldNumber = 4, + kQueryBoostFieldNumber = 2, + }; + // repeated .milvus.grpc.RowRecord records = 3; + int records_size() const; + void clear_records(); + ::milvus::grpc::RowRecord* mutable_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* + mutable_records(); + const ::milvus::grpc::RowRecord& records(int index) const; + ::milvus::grpc::RowRecord* add_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& + records() const; + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string field_name = 1; + void clear_field_name(); + const std::string& field_name() const; + void set_field_name(const std::string& value); + void set_field_name(std::string&& value); + void set_field_name(const char* value); + void set_field_name(const char* value, size_t size); + std::string* mutable_field_name(); + std::string* release_field_name(); + void set_allocated_field_name(std::string* field_name); + + // int64 topk = 4; + void clear_topk(); + ::PROTOBUF_NAMESPACE_ID::int64 topk() const; + void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value); + + // float query_boost = 2; + void clear_query_boost(); + float query_boost() const; + void set_query_boost(float value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; + ::PROTOBUF_NAMESPACE_ID::int64 topk_; + float query_boost_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class BooleanQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BooleanQuery) */ { + public: + BooleanQuery(); + virtual ~BooleanQuery(); + + BooleanQuery(const BooleanQuery& from); + BooleanQuery(BooleanQuery&& from) noexcept + : BooleanQuery() { + *this = ::std::move(from); + } + + inline BooleanQuery& operator=(const BooleanQuery& from) { + CopyFrom(from); + return *this; + } + inline BooleanQuery& operator=(BooleanQuery&& 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 BooleanQuery& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const BooleanQuery* internal_default_instance() { + return reinterpret_cast( + &_BooleanQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(BooleanQuery& a, BooleanQuery& b) { + a.Swap(&b); + } + inline void Swap(BooleanQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline BooleanQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + BooleanQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const BooleanQuery& from); + void MergeFrom(const BooleanQuery& 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(BooleanQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.BooleanQuery"; + } + 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 { + kGeneralQueryFieldNumber = 2, + kOccurFieldNumber = 1, + }; + // repeated .milvus.grpc.GeneralQuery general_query = 2; + int general_query_size() const; + void clear_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* + mutable_general_query(); + const ::milvus::grpc::GeneralQuery& general_query(int index) const; + ::milvus::grpc::GeneralQuery* add_general_query(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& + general_query() const; + + // .milvus.grpc.Occur occur = 1; + void clear_occur(); + ::milvus::grpc::Occur occur() const; + void set_occur(::milvus::grpc::Occur value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.BooleanQuery) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery > general_query_; + int occur_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class GeneralQuery : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.GeneralQuery) */ { + public: + GeneralQuery(); + virtual ~GeneralQuery(); + + GeneralQuery(const GeneralQuery& from); + GeneralQuery(GeneralQuery&& from) noexcept + : GeneralQuery() { + *this = ::std::move(from); + } + + inline GeneralQuery& operator=(const GeneralQuery& from) { + CopyFrom(from); + return *this; + } + inline GeneralQuery& operator=(GeneralQuery&& 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 GeneralQuery& default_instance(); + + enum QueryCase { + kBooleanQuery = 1, + kTermQuery = 2, + kRangeQuery = 3, + kVectorQuery = 4, + QUERY_NOT_SET = 0, + }; + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const GeneralQuery* internal_default_instance() { + return reinterpret_cast( + &_GeneralQuery_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(GeneralQuery& a, GeneralQuery& b) { + a.Swap(&b); + } + inline void Swap(GeneralQuery* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline GeneralQuery* New() const final { + return CreateMaybeMessage(nullptr); + } + + GeneralQuery* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const GeneralQuery& from); + void MergeFrom(const GeneralQuery& 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(GeneralQuery* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.GeneralQuery"; + } + 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 { + kBooleanQueryFieldNumber = 1, + kTermQueryFieldNumber = 2, + kRangeQueryFieldNumber = 3, + kVectorQueryFieldNumber = 4, + }; + // .milvus.grpc.BooleanQuery boolean_query = 1; + bool has_boolean_query() const; + void clear_boolean_query(); + const ::milvus::grpc::BooleanQuery& boolean_query() const; + ::milvus::grpc::BooleanQuery* release_boolean_query(); + ::milvus::grpc::BooleanQuery* mutable_boolean_query(); + void set_allocated_boolean_query(::milvus::grpc::BooleanQuery* boolean_query); + + // .milvus.grpc.TermQuery term_query = 2; + bool has_term_query() const; + void clear_term_query(); + const ::milvus::grpc::TermQuery& term_query() const; + ::milvus::grpc::TermQuery* release_term_query(); + ::milvus::grpc::TermQuery* mutable_term_query(); + void set_allocated_term_query(::milvus::grpc::TermQuery* term_query); + + // .milvus.grpc.RangeQuery range_query = 3; + bool has_range_query() const; + void clear_range_query(); + const ::milvus::grpc::RangeQuery& range_query() const; + ::milvus::grpc::RangeQuery* release_range_query(); + ::milvus::grpc::RangeQuery* mutable_range_query(); + void set_allocated_range_query(::milvus::grpc::RangeQuery* range_query); + + // .milvus.grpc.VectorQuery vector_query = 4; + bool has_vector_query() const; + void clear_vector_query(); + const ::milvus::grpc::VectorQuery& vector_query() const; + ::milvus::grpc::VectorQuery* release_vector_query(); + ::milvus::grpc::VectorQuery* mutable_vector_query(); + void set_allocated_vector_query(::milvus::grpc::VectorQuery* vector_query); + + void clear_query(); + QueryCase query_case() const; + // @@protoc_insertion_point(class_scope:milvus.grpc.GeneralQuery) + private: + class _Internal; + void set_has_boolean_query(); + void set_has_term_query(); + void set_has_range_query(); + void set_has_vector_query(); + + inline bool has_query() const; + inline void clear_has_query(); + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + union QueryUnion { + QueryUnion() {} + ::milvus::grpc::BooleanQuery* boolean_query_; + ::milvus::grpc::TermQuery* term_query_; + ::milvus::grpc::RangeQuery* range_query_; + ::milvus::grpc::VectorQuery* vector_query_; + } query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HSearchParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HSearchParam) */ { + public: + HSearchParam(); + virtual ~HSearchParam(); + + HSearchParam(const HSearchParam& from); + HSearchParam(HSearchParam&& from) noexcept + : HSearchParam() { + *this = ::std::move(from); + } + + inline HSearchParam& operator=(const HSearchParam& from) { + CopyFrom(from); + return *this; + } + inline HSearchParam& operator=(HSearchParam&& 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 HSearchParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HSearchParam* internal_default_instance() { + return reinterpret_cast( + &_HSearchParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(HSearchParam& a, HSearchParam& b) { + a.Swap(&b); + } + inline void Swap(HSearchParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HSearchParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HSearchParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HSearchParam& from); + void MergeFrom(const HSearchParam& 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(HSearchParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HSearchParam"; + } + 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 { + kPartitionTagArrayFieldNumber = 2, + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 1, + kGeneralQueryFieldNumber = 3, + }; + // repeated string partition_tag_array = 2; + int partition_tag_array_size() const; + void clear_partition_tag_array(); + const std::string& partition_tag_array(int index) const; + std::string* mutable_partition_tag_array(int index); + void set_partition_tag_array(int index, const std::string& value); + void set_partition_tag_array(int index, std::string&& value); + void set_partition_tag_array(int index, const char* value); + void set_partition_tag_array(int index, const char* value, size_t size); + std::string* add_partition_tag_array(); + void add_partition_tag_array(const std::string& value); + void add_partition_tag_array(std::string&& value); + void add_partition_tag_array(const char* value); + void add_partition_tag_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_tag_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_tag_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .milvus.grpc.GeneralQuery general_query = 3; + bool has_general_query() const; + void clear_general_query(); + const ::milvus::grpc::GeneralQuery& general_query() const; + ::milvus::grpc::GeneralQuery* release_general_query(); + ::milvus::grpc::GeneralQuery* mutable_general_query(); + void set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HSearchParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::GeneralQuery* general_query_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HSearchInSegmentsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HSearchInSegmentsParam) */ { + public: + HSearchInSegmentsParam(); + virtual ~HSearchInSegmentsParam(); + + HSearchInSegmentsParam(const HSearchInSegmentsParam& from); + HSearchInSegmentsParam(HSearchInSegmentsParam&& from) noexcept + : HSearchInSegmentsParam() { + *this = ::std::move(from); + } + + inline HSearchInSegmentsParam& operator=(const HSearchInSegmentsParam& from) { + CopyFrom(from); + return *this; + } + inline HSearchInSegmentsParam& operator=(HSearchInSegmentsParam&& 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 HSearchInSegmentsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HSearchInSegmentsParam* internal_default_instance() { + return reinterpret_cast( + &_HSearchInSegmentsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(HSearchInSegmentsParam& a, HSearchInSegmentsParam& b) { + a.Swap(&b); + } + inline void Swap(HSearchInSegmentsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HSearchInSegmentsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HSearchInSegmentsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HSearchInSegmentsParam& from); + void MergeFrom(const HSearchInSegmentsParam& 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(HSearchInSegmentsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HSearchInSegmentsParam"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSegmentIdArrayFieldNumber = 1, + kSearchParamFieldNumber = 2, + }; + // repeated string segment_id_array = 1; + int segment_id_array_size() const; + void clear_segment_id_array(); + const std::string& segment_id_array(int index) const; + std::string* mutable_segment_id_array(int index); + void set_segment_id_array(int index, const std::string& value); + void set_segment_id_array(int index, std::string&& value); + void set_segment_id_array(int index, const char* value); + void set_segment_id_array(int index, const char* value, size_t size); + std::string* add_segment_id_array(); + void add_segment_id_array(const std::string& value); + void add_segment_id_array(std::string&& value); + void add_segment_id_array(const char* value); + void add_segment_id_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& segment_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_segment_id_array(); + + // .milvus.grpc.HSearchParam search_param = 2; + bool has_search_param() const; + void clear_search_param(); + const ::milvus::grpc::HSearchParam& search_param() const; + ::milvus::grpc::HSearchParam* release_search_param(); + ::milvus::grpc::HSearchParam* mutable_search_param(); + void set_allocated_search_param(::milvus::grpc::HSearchParam* search_param); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HSearchInSegmentsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField segment_id_array_; + ::milvus::grpc::HSearchParam* search_param_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class AttrRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.AttrRecord) */ { + public: + AttrRecord(); + virtual ~AttrRecord(); + + AttrRecord(const AttrRecord& from); + AttrRecord(AttrRecord&& from) noexcept + : AttrRecord() { + *this = ::std::move(from); + } + + inline AttrRecord& operator=(const AttrRecord& from) { + CopyFrom(from); + return *this; + } + inline AttrRecord& operator=(AttrRecord&& 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 AttrRecord& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const AttrRecord* internal_default_instance() { + return reinterpret_cast( + &_AttrRecord_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(AttrRecord& a, AttrRecord& b) { + a.Swap(&b); + } + inline void Swap(AttrRecord* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AttrRecord* New() const final { + return CreateMaybeMessage(nullptr); + } + + AttrRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AttrRecord& from); + void MergeFrom(const AttrRecord& 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(AttrRecord* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.AttrRecord"; + } + 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 { + kValueFieldNumber = 1, + }; + // repeated string value = 1; + int value_size() const; + void clear_value(); + const std::string& value(int index) const; + std::string* mutable_value(int index); + void set_value(int index, const std::string& value); + void set_value(int index, std::string&& value); + void set_value(int index, const char* value); + void set_value(int index, const char* value, size_t size); + std::string* add_value(); + void add_value(const std::string& value); + void add_value(std::string&& value); + void add_value(const char* value); + void add_value(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_value(); + + // @@protoc_insertion_point(class_scope:milvus.grpc.AttrRecord) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntity : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntity) */ { + public: + HEntity(); + virtual ~HEntity(); + + HEntity(const HEntity& from); + HEntity(HEntity&& from) noexcept + : HEntity() { + *this = ::std::move(from); + } + + inline HEntity& operator=(const HEntity& from) { + CopyFrom(from); + return *this; + } + inline HEntity& operator=(HEntity&& 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 HEntity& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntity* internal_default_instance() { + return reinterpret_cast( + &_HEntity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(HEntity& a, HEntity& b) { + a.Swap(&b); + } + inline void Swap(HEntity* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntity* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntity& from); + void MergeFrom(const HEntity& 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(HEntity* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntity"; + } + 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 { + kFieldNamesFieldNumber = 3, + kAttrRecordsFieldNumber = 4, + kResultValuesFieldNumber = 5, + kStatusFieldNumber = 1, + kEntityIdFieldNumber = 2, + }; + // repeated string field_names = 3; + int field_names_size() const; + void clear_field_names(); + const std::string& field_names(int index) const; + std::string* mutable_field_names(int index); + void set_field_names(int index, const std::string& value); + void set_field_names(int index, std::string&& value); + void set_field_names(int index, const char* value); + void set_field_names(int index, const char* value, size_t size); + std::string* add_field_names(); + void add_field_names(const std::string& value); + void add_field_names(std::string&& value); + void add_field_names(const char* value); + void add_field_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& field_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_field_names(); + + // repeated .milvus.grpc.AttrRecord attr_records = 4; + int attr_records_size() const; + void clear_attr_records(); + ::milvus::grpc::AttrRecord* mutable_attr_records(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* + mutable_attr_records(); + const ::milvus::grpc::AttrRecord& attr_records(int index) const; + ::milvus::grpc::AttrRecord* add_attr_records(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& + attr_records() const; + + // repeated .milvus.grpc.FieldValue result_values = 5; + int result_values_size() const; + void clear_result_values(); + ::milvus::grpc::FieldValue* mutable_result_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >* + mutable_result_values(); + const ::milvus::grpc::FieldValue& result_values(int index) const; + ::milvus::grpc::FieldValue* add_result_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >& + result_values() const; + + // .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 entity_id = 2; + void clear_entity_id(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id() const; + void set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntity) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField field_names_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord > attr_records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue > result_values_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HQueryResult : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HQueryResult) */ { + public: + HQueryResult(); + virtual ~HQueryResult(); + + HQueryResult(const HQueryResult& from); + HQueryResult(HQueryResult&& from) noexcept + : HQueryResult() { + *this = ::std::move(from); + } + + inline HQueryResult& operator=(const HQueryResult& from) { + CopyFrom(from); + return *this; + } + inline HQueryResult& operator=(HQueryResult&& 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 HQueryResult& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HQueryResult* internal_default_instance() { + return reinterpret_cast( + &_HQueryResult_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(HQueryResult& a, HQueryResult& b) { + a.Swap(&b); + } + inline void Swap(HQueryResult* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HQueryResult* New() const final { + return CreateMaybeMessage(nullptr); + } + + HQueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HQueryResult& from); + void MergeFrom(const HQueryResult& 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(HQueryResult* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HQueryResult"; + } + 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 { + kEntitiesFieldNumber = 2, + kScoreFieldNumber = 4, + kDistanceFieldNumber = 5, + kStatusFieldNumber = 1, + kRowNumFieldNumber = 3, + }; + // repeated .milvus.grpc.HEntity entities = 2; + int entities_size() const; + void clear_entities(); + ::milvus::grpc::HEntity* mutable_entities(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >* + mutable_entities(); + const ::milvus::grpc::HEntity& entities(int index) const; + ::milvus::grpc::HEntity* add_entities(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& + entities() const; + + // repeated float score = 4; + int score_size() const; + void clear_score(); + float score(int index) const; + void set_score(int index, float value); + void add_score(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + score() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_score(); + + // repeated float distance = 5; + int distance_size() const; + void clear_distance(); + float distance(int index) const; + void set_distance(int index, float value); + void add_distance(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& + distance() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* + mutable_distance(); + + // .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 row_num = 3; + void clear_row_num(); + ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; + void set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HQueryResult) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity > entities_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > score_; + mutable std::atomic _score_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > distance_; + mutable std::atomic _distance_cached_byte_size_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int64 row_num_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HInsertParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HInsertParam) */ { + public: + HInsertParam(); + virtual ~HInsertParam(); + + HInsertParam(const HInsertParam& from); + HInsertParam(HInsertParam&& from) noexcept + : HInsertParam() { + *this = ::std::move(from); + } + + inline HInsertParam& operator=(const HInsertParam& from) { + CopyFrom(from); + return *this; + } + inline HInsertParam& operator=(HInsertParam&& 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 HInsertParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HInsertParam* internal_default_instance() { + return reinterpret_cast( + &_HInsertParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(HInsertParam& a, HInsertParam& b) { + a.Swap(&b); + } + inline void Swap(HInsertParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HInsertParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HInsertParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HInsertParam& from); + void MergeFrom(const HInsertParam& 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(HInsertParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HInsertParam"; + } + 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 { + kEntityIdArrayFieldNumber = 4, + kExtraParamsFieldNumber = 5, + kCollectionNameFieldNumber = 1, + kPartitionTagFieldNumber = 2, + kEntitiesFieldNumber = 3, + }; + // repeated int64 entity_id_array = 4; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 5; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string partition_tag = 2; + void clear_partition_tag(); + const std::string& partition_tag() const; + void set_partition_tag(const std::string& value); + void set_partition_tag(std::string&& value); + void set_partition_tag(const char* value); + void set_partition_tag(const char* value, size_t size); + std::string* mutable_partition_tag(); + std::string* release_partition_tag(); + void set_allocated_partition_tag(std::string* partition_tag); + + // .milvus.grpc.HEntity entities = 3; + bool has_entities() const; + void clear_entities(); + const ::milvus::grpc::HEntity& entities() const; + ::milvus::grpc::HEntity* release_entities(); + ::milvus::grpc::HEntity* mutable_entities(); + void set_allocated_entities(::milvus::grpc::HEntity* entities); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HInsertParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; + ::milvus::grpc::HEntity* entities_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntityIdentity : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntityIdentity) */ { + public: + HEntityIdentity(); + virtual ~HEntityIdentity(); + + HEntityIdentity(const HEntityIdentity& from); + HEntityIdentity(HEntityIdentity&& from) noexcept + : HEntityIdentity() { + *this = ::std::move(from); + } + + inline HEntityIdentity& operator=(const HEntityIdentity& from) { + CopyFrom(from); + return *this; + } + inline HEntityIdentity& operator=(HEntityIdentity&& 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 HEntityIdentity& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntityIdentity* internal_default_instance() { + return reinterpret_cast( + &_HEntityIdentity_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(HEntityIdentity& a, HEntityIdentity& b) { + a.Swap(&b); + } + inline void Swap(HEntityIdentity* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntityIdentity* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntityIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntityIdentity& from); + void MergeFrom(const HEntityIdentity& 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(HEntityIdentity* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntityIdentity"; + } + 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 { + kCollectionNameFieldNumber = 1, + kIdFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // int64 id = 2; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::int64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::int64 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntityIdentity) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::int64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HEntityIDs : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HEntityIDs) */ { + public: + HEntityIDs(); + virtual ~HEntityIDs(); + + HEntityIDs(const HEntityIDs& from); + HEntityIDs(HEntityIDs&& from) noexcept + : HEntityIDs() { + *this = ::std::move(from); + } + + inline HEntityIDs& operator=(const HEntityIDs& from) { + CopyFrom(from); + return *this; + } + inline HEntityIDs& operator=(HEntityIDs&& 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 HEntityIDs& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HEntityIDs* internal_default_instance() { + return reinterpret_cast( + &_HEntityIDs_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(HEntityIDs& a, HEntityIDs& b) { + a.Swap(&b); + } + inline void Swap(HEntityIDs* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HEntityIDs* New() const final { + return CreateMaybeMessage(nullptr); + } + + HEntityIDs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HEntityIDs& from); + void MergeFrom(const HEntityIDs& 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(HEntityIDs* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HEntityIDs"; + } + 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 { + kEntityIdArrayFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated int64 entity_id_array = 2; + int entity_id_array_size() const; + void clear_entity_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id_array(int index) const; + void set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id_array(); + + // .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); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HEntityIDs) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_array_; + mutable std::atomic _entity_id_array_cached_byte_size_; + ::milvus::grpc::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HGetEntityIDsParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HGetEntityIDsParam) */ { + public: + HGetEntityIDsParam(); + virtual ~HGetEntityIDsParam(); + + HGetEntityIDsParam(const HGetEntityIDsParam& from); + HGetEntityIDsParam(HGetEntityIDsParam&& from) noexcept + : HGetEntityIDsParam() { + *this = ::std::move(from); + } + + inline HGetEntityIDsParam& operator=(const HGetEntityIDsParam& from) { + CopyFrom(from); + return *this; + } + inline HGetEntityIDsParam& operator=(HGetEntityIDsParam&& 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 HGetEntityIDsParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HGetEntityIDsParam* internal_default_instance() { + return reinterpret_cast( + &_HGetEntityIDsParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 47; + + friend void swap(HGetEntityIDsParam& a, HGetEntityIDsParam& b) { + a.Swap(&b); + } + inline void Swap(HGetEntityIDsParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HGetEntityIDsParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HGetEntityIDsParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HGetEntityIDsParam& from); + void MergeFrom(const HGetEntityIDsParam& 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(HGetEntityIDsParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HGetEntityIDsParam"; + } + 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 { + kCollectionNameFieldNumber = 1, + kSegmentNameFieldNumber = 2, + }; + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string segment_name = 2; + void clear_segment_name(); + const std::string& segment_name() const; + void set_segment_name(const std::string& value); + void set_segment_name(std::string&& value); + void set_segment_name(const char* value); + void set_segment_name(const char* value, size_t size); + std::string* mutable_segment_name(); + std::string* release_segment_name(); + void set_allocated_segment_name(std::string* segment_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HGetEntityIDsParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr segment_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HDeleteByIDParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HDeleteByIDParam) */ { + public: + HDeleteByIDParam(); + virtual ~HDeleteByIDParam(); + + HDeleteByIDParam(const HDeleteByIDParam& from); + HDeleteByIDParam(HDeleteByIDParam&& from) noexcept + : HDeleteByIDParam() { + *this = ::std::move(from); + } + + inline HDeleteByIDParam& operator=(const HDeleteByIDParam& from) { + CopyFrom(from); + return *this; + } + inline HDeleteByIDParam& operator=(HDeleteByIDParam&& 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 HDeleteByIDParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HDeleteByIDParam* internal_default_instance() { + return reinterpret_cast( + &_HDeleteByIDParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 48; + + friend void swap(HDeleteByIDParam& a, HDeleteByIDParam& b) { + a.Swap(&b); + } + inline void Swap(HDeleteByIDParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HDeleteByIDParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HDeleteByIDParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HDeleteByIDParam& from); + void MergeFrom(const HDeleteByIDParam& 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(HDeleteByIDParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HDeleteByIDParam"; + } + 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 { + kIdArrayFieldNumber = 2, + kCollectionNameFieldNumber = 1, + }; + // repeated int64 id_array = 2; + int id_array_size() const; + void clear_id_array(); + ::PROTOBUF_NAMESPACE_ID::int64 id_array(int index) const; + void set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id_array(); + + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HDeleteByIDParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; + mutable std::atomic _id_array_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class HIndexParam : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.HIndexParam) */ { + public: + HIndexParam(); + virtual ~HIndexParam(); + + HIndexParam(const HIndexParam& from); + HIndexParam(HIndexParam&& from) noexcept + : HIndexParam() { + *this = ::std::move(from); + } + + inline HIndexParam& operator=(const HIndexParam& from) { + CopyFrom(from); + return *this; + } + inline HIndexParam& operator=(HIndexParam&& 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 HIndexParam& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const HIndexParam* internal_default_instance() { + return reinterpret_cast( + &_HIndexParam_default_instance_); + } + static constexpr int kIndexInFileMessages = + 49; + + friend void swap(HIndexParam& a, HIndexParam& b) { + a.Swap(&b); + } + inline void Swap(HIndexParam* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline HIndexParam* New() const final { + return CreateMaybeMessage(nullptr); + } + + HIndexParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const HIndexParam& from); + void MergeFrom(const HIndexParam& 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(HIndexParam* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.grpc.HIndexParam"; + } + 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 { + kExtraParamsFieldNumber = 4, + kCollectionNameFieldNumber = 2, + kStatusFieldNumber = 1, + kIndexTypeFieldNumber = 3, + }; + // repeated .milvus.grpc.KeyValuePair extra_params = 4; + int extra_params_size() const; + void clear_extra_params(); + ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* + mutable_extra_params(); + const ::milvus::grpc::KeyValuePair& extra_params(int index) const; + ::milvus::grpc::KeyValuePair* add_extra_params(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& + extra_params() const; + + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // .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); + + // int32 index_type = 3; + void clear_index_type(); + ::PROTOBUF_NAMESPACE_ID::int32 index_type() const; + void set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value); + + // @@protoc_insertion_point(class_scope:milvus.grpc.HIndexParam) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::milvus::grpc::Status* status_; + ::PROTOBUF_NAMESPACE_ID::int32 index_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; // =================================================================== @@ -7044,6 +11157,2964 @@ inline void GetVectorIDsParam::set_allocated_segment_name(std::string* segment_n // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.segment_name) } +// ------------------------------------------------------------------- + +// VectorFieldParam + +// int64 dimension = 1; +inline void VectorFieldParam::clear_dimension() { + dimension_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorFieldParam::dimension() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldParam.dimension) + return dimension_; +} +inline void VectorFieldParam::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { + + dimension_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorFieldParam.dimension) +} + +// ------------------------------------------------------------------- + +// FieldType + +// .milvus.grpc.DataType data_type = 1; +inline bool FieldType::has_data_type() const { + return value_case() == kDataType; +} +inline void FieldType::set_has_data_type() { + _oneof_case_[0] = kDataType; +} +inline void FieldType::clear_data_type() { + if (has_data_type()) { + value_.data_type_ = 0; + clear_has_value(); + } +} +inline ::milvus::grpc::DataType FieldType::data_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.data_type) + if (has_data_type()) { + return static_cast< ::milvus::grpc::DataType >(value_.data_type_); + } + return static_cast< ::milvus::grpc::DataType >(0); +} +inline void FieldType::set_data_type(::milvus::grpc::DataType value) { + if (!has_data_type()) { + clear_value(); + set_has_data_type(); + } + value_.data_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldType.data_type) +} + +// .milvus.grpc.VectorFieldParam vector_param = 2; +inline bool FieldType::has_vector_param() const { + return value_case() == kVectorParam; +} +inline void FieldType::set_has_vector_param() { + _oneof_case_[0] = kVectorParam; +} +inline void FieldType::clear_vector_param() { + if (has_vector_param()) { + delete value_.vector_param_; + clear_has_value(); + } +} +inline ::milvus::grpc::VectorFieldParam* FieldType::release_vector_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldType.vector_param) + if (has_vector_param()) { + clear_has_value(); + ::milvus::grpc::VectorFieldParam* temp = value_.vector_param_; + value_.vector_param_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorFieldParam& FieldType::vector_param() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldType.vector_param) + return has_vector_param() + ? *value_.vector_param_ + : *reinterpret_cast< ::milvus::grpc::VectorFieldParam*>(&::milvus::grpc::_VectorFieldParam_default_instance_); +} +inline ::milvus::grpc::VectorFieldParam* FieldType::mutable_vector_param() { + if (!has_vector_param()) { + clear_value(); + set_has_vector_param(); + value_.vector_param_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldParam >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldType.vector_param) + return value_.vector_param_; +} + +inline bool FieldType::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void FieldType::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline FieldType::ValueCase FieldType::value_case() const { + return FieldType::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FieldParam + +// uint64 id = 1; +inline void FieldParam::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FieldParam::id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.id) + return id_; +} +inline void FieldParam::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.id) +} + +// string name = 2; +inline void FieldParam::clear_name() { + name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& FieldParam::name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.name) + return name_.GetNoArena(); +} +inline void FieldParam::set_name(const std::string& value) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(std::string&& value) { + + name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldParam.name) +} +inline void FieldParam::set_name(const char* value, size_t size) { + + name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldParam.name) +} +inline std::string* FieldParam::mutable_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.name) + return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldParam::release_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.name) + + return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void FieldParam::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.name) +} + +// .milvus.grpc.FieldType type = 3; +inline bool FieldParam::has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline void FieldParam::clear_type() { + if (GetArenaNoVirtual() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +inline const ::milvus::grpc::FieldType& FieldParam::type() const { + const ::milvus::grpc::FieldType* p = type_; + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.type) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_FieldType_default_instance_); +} +inline ::milvus::grpc::FieldType* FieldParam::release_type() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldParam.type) + + ::milvus::grpc::FieldType* temp = type_; + type_ = nullptr; + return temp; +} +inline ::milvus::grpc::FieldType* FieldParam::mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::FieldType>(GetArenaNoVirtual()); + type_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.type) + return type_; +} +inline void FieldParam::set_allocated_type(::milvus::grpc::FieldType* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldParam.type) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int FieldParam::extra_params_size() const { + return extra_params_.size(); +} +inline void FieldParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +FieldParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FieldParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& FieldParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* FieldParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.FieldParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +FieldParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FieldParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorFieldValue + +// repeated .milvus.grpc.RowRecord value = 1; +inline int VectorFieldValue::value_size() const { + return value_.size(); +} +inline void VectorFieldValue::clear_value() { + value_.Clear(); +} +inline ::milvus::grpc::RowRecord* VectorFieldValue::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldValue.value) + return value_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* +VectorFieldValue::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldValue.value) + return &value_; +} +inline const ::milvus::grpc::RowRecord& VectorFieldValue::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldValue.value) + return value_.Get(index); +} +inline ::milvus::grpc::RowRecord* VectorFieldValue::add_value() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldValue.value) + return value_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& +VectorFieldValue::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldValue.value) + return value_; +} + +// ------------------------------------------------------------------- + +// FieldValue + +// int32 int32_value = 1; +inline bool FieldValue::has_int32_value() const { + return value_case() == kInt32Value; +} +inline void FieldValue::set_has_int32_value() { + _oneof_case_[0] = kInt32Value; +} +inline void FieldValue::clear_int32_value() { + if (has_int32_value()) { + value_.int32_value_ = 0; + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 FieldValue::int32_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.int32_value) + if (has_int32_value()) { + return value_.int32_value_; + } + return 0; +} +inline void FieldValue::set_int32_value(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!has_int32_value()) { + clear_value(); + set_has_int32_value(); + } + value_.int32_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.int32_value) +} + +// int64 int64_value = 2; +inline bool FieldValue::has_int64_value() const { + return value_case() == kInt64Value; +} +inline void FieldValue::set_has_int64_value() { + _oneof_case_[0] = kInt64Value; +} +inline void FieldValue::clear_int64_value() { + if (has_int64_value()) { + value_.int64_value_ = PROTOBUF_LONGLONG(0); + clear_has_value(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FieldValue::int64_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.int64_value) + if (has_int64_value()) { + return value_.int64_value_; + } + return PROTOBUF_LONGLONG(0); +} +inline void FieldValue::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!has_int64_value()) { + clear_value(); + set_has_int64_value(); + } + value_.int64_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.int64_value) +} + +// float float_value = 3; +inline bool FieldValue::has_float_value() const { + return value_case() == kFloatValue; +} +inline void FieldValue::set_has_float_value() { + _oneof_case_[0] = kFloatValue; +} +inline void FieldValue::clear_float_value() { + if (has_float_value()) { + value_.float_value_ = 0; + clear_has_value(); + } +} +inline float FieldValue::float_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.float_value) + if (has_float_value()) { + return value_.float_value_; + } + return 0; +} +inline void FieldValue::set_float_value(float value) { + if (!has_float_value()) { + clear_value(); + set_has_float_value(); + } + value_.float_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.float_value) +} + +// double double_value = 4; +inline bool FieldValue::has_double_value() const { + return value_case() == kDoubleValue; +} +inline void FieldValue::set_has_double_value() { + _oneof_case_[0] = kDoubleValue; +} +inline void FieldValue::clear_double_value() { + if (has_double_value()) { + value_.double_value_ = 0; + clear_has_value(); + } +} +inline double FieldValue::double_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.double_value) + if (has_double_value()) { + return value_.double_value_; + } + return 0; +} +inline void FieldValue::set_double_value(double value) { + if (!has_double_value()) { + clear_value(); + set_has_double_value(); + } + value_.double_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.double_value) +} + +// string string_value = 5; +inline bool FieldValue::has_string_value() const { + return value_case() == kStringValue; +} +inline void FieldValue::set_has_string_value() { + _oneof_case_[0] = kStringValue; +} +inline void FieldValue::clear_string_value() { + if (has_string_value()) { + value_.string_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + clear_has_value(); + } +} +inline const std::string& FieldValue::string_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.string_value) + if (has_string_value()) { + return value_.string_value_.GetNoArena(); + } + return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void FieldValue::set_string_value(const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.string_value) + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FieldValue.string_value) +} +inline void FieldValue::set_string_value(const char* value, size_t size) { + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + value_.string_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string( + reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FieldValue.string_value) +} +inline std::string* FieldValue::mutable_string_value() { + if (!has_string_value()) { + clear_value(); + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.string_value) + return value_.string_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* FieldValue::release_string_value() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldValue.string_value) + if (has_string_value()) { + clear_has_value(); + return value_.string_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } else { + return nullptr; + } +} +inline void FieldValue::set_allocated_string_value(std::string* string_value) { + if (has_value()) { + clear_value(); + } + if (string_value != nullptr) { + set_has_string_value(); + value_.string_value_.UnsafeSetDefault(string_value); + } + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.string_value) +} + +// bool bool_value = 6; +inline bool FieldValue::has_bool_value() const { + return value_case() == kBoolValue; +} +inline void FieldValue::set_has_bool_value() { + _oneof_case_[0] = kBoolValue; +} +inline void FieldValue::clear_bool_value() { + if (has_bool_value()) { + value_.bool_value_ = false; + clear_has_value(); + } +} +inline bool FieldValue::bool_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.bool_value) + if (has_bool_value()) { + return value_.bool_value_; + } + return false; +} +inline void FieldValue::set_bool_value(bool value) { + if (!has_bool_value()) { + clear_value(); + set_has_bool_value(); + } + value_.bool_value_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.bool_value) +} + +// .milvus.grpc.VectorFieldValue vector_value = 7; +inline bool FieldValue::has_vector_value() const { + return value_case() == kVectorValue; +} +inline void FieldValue::set_has_vector_value() { + _oneof_case_[0] = kVectorValue; +} +inline void FieldValue::clear_vector_value() { + if (has_vector_value()) { + delete value_.vector_value_; + clear_has_value(); + } +} +inline ::milvus::grpc::VectorFieldValue* FieldValue::release_vector_value() { + // @@protoc_insertion_point(field_release:milvus.grpc.FieldValue.vector_value) + if (has_vector_value()) { + clear_has_value(); + ::milvus::grpc::VectorFieldValue* temp = value_.vector_value_; + value_.vector_value_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorFieldValue& FieldValue::vector_value() const { + // @@protoc_insertion_point(field_get:milvus.grpc.FieldValue.vector_value) + return has_vector_value() + ? *value_.vector_value_ + : *reinterpret_cast< ::milvus::grpc::VectorFieldValue*>(&::milvus::grpc::_VectorFieldValue_default_instance_); +} +inline ::milvus::grpc::VectorFieldValue* FieldValue::mutable_vector_value() { + if (!has_vector_value()) { + clear_value(); + set_has_vector_value(); + value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.vector_value) + return value_.vector_value_; +} + +inline bool FieldValue::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void FieldValue::clear_has_value() { + _oneof_case_[0] = VALUE_NOT_SET; +} +inline FieldValue::ValueCase FieldValue::value_case() const { + return FieldValue::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Mapping + +// .milvus.grpc.Status status = 1; +inline bool Mapping::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& Mapping::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* Mapping::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* Mapping::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.status) + return status_; +} +inline void Mapping::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.Mapping.status) +} + +// uint64 collection_id = 2; +inline void Mapping::clear_collection_id() { + collection_id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Mapping::collection_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_id) + return collection_id_; +} +inline void Mapping::set_collection_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + collection_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_id) +} + +// string collection_name = 3; +inline void Mapping::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& Mapping::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.collection_name) + return collection_name_.GetNoArena(); +} +inline void Mapping::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.Mapping.collection_name) +} +inline void Mapping::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Mapping.collection_name) +} +inline std::string* Mapping::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* Mapping::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.Mapping.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void Mapping::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Mapping.collection_name) +} + +// repeated .milvus.grpc.FieldParam fields = 4; +inline int Mapping::fields_size() const { + return fields_.size(); +} +inline void Mapping::clear_fields() { + fields_.Clear(); +} +inline ::milvus::grpc::FieldParam* Mapping::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.Mapping.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >* +Mapping::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.Mapping.fields) + return &fields_; +} +inline const ::milvus::grpc::FieldParam& Mapping::fields(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.Mapping.fields) + return fields_.Get(index); +} +inline ::milvus::grpc::FieldParam* Mapping::add_fields() { + // @@protoc_insertion_point(field_add:milvus.grpc.Mapping.fields) + return fields_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldParam >& +Mapping::fields() const { + // @@protoc_insertion_point(field_list:milvus.grpc.Mapping.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// MappingList + +// .milvus.grpc.Status status = 1; +inline bool MappingList::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& MappingList::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* MappingList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.MappingList.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* MappingList::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.status) + return status_; +} +inline void MappingList::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.MappingList.status) +} + +// repeated .milvus.grpc.Mapping mapping_list = 2; +inline int MappingList::mapping_list_size() const { + return mapping_list_.size(); +} +inline void MappingList::clear_mapping_list() { + mapping_list_.Clear(); +} +inline ::milvus::grpc::Mapping* MappingList::mutable_mapping_list(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >* +MappingList::mutable_mapping_list() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.MappingList.mapping_list) + return &mapping_list_; +} +inline const ::milvus::grpc::Mapping& MappingList::mapping_list(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Get(index); +} +inline ::milvus::grpc::Mapping* MappingList::add_mapping_list() { + // @@protoc_insertion_point(field_add:milvus.grpc.MappingList.mapping_list) + return mapping_list_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Mapping >& +MappingList::mapping_list() const { + // @@protoc_insertion_point(field_list:milvus.grpc.MappingList.mapping_list) + return mapping_list_; +} + +// ------------------------------------------------------------------- + +// TermQuery + +// string field_name = 1; +inline void TermQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& TermQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.field_name) + return field_name_.GetNoArena(); +} +inline void TermQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.field_name) +} +inline void TermQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.field_name) +} +inline std::string* TermQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* TermQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void TermQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name) +} + +// repeated string values = 2; +inline int TermQuery::values_size() const { + return values_.size(); +} +inline void TermQuery::clear_values() { + values_.Clear(); +} +inline const std::string& TermQuery::values(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.values) + return values_.Get(index); +} +inline std::string* TermQuery::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.values) + return values_.Mutable(index); +} +inline void TermQuery::set_values(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) + values_.Mutable(index)->assign(value); +} +inline void TermQuery::set_values(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) + values_.Mutable(index)->assign(std::move(value)); +} +inline void TermQuery::set_values(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + values_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.values) +} +inline void TermQuery::set_values(int index, const char* value, size_t size) { + values_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.values) +} +inline std::string* TermQuery::add_values() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TermQuery.values) + return values_.Add(); +} +inline void TermQuery::add_values(const std::string& value) { + values_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(std::string&& value) { + values_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(const char* value) { + GOOGLE_DCHECK(value != nullptr); + values_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.TermQuery.values) +} +inline void TermQuery::add_values(const char* value, size_t size) { + values_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TermQuery.values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +TermQuery::values() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.values) + return values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +TermQuery::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.values) + return &values_; +} + +// float boost = 3; +inline void TermQuery::clear_boost() { + boost_ = 0; +} +inline float TermQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.boost) + return boost_; +} +inline void TermQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int TermQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void TermQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +TermQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& TermQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* TermQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +TermQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// CompareExpr + +// .milvus.grpc.CompareOperator operator = 1; +inline void CompareExpr::clear_operator_() { + operator__ = 0; +} +inline ::milvus::grpc::CompareOperator CompareExpr::operator_() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operator) + return static_cast< ::milvus::grpc::CompareOperator >(operator__); +} +inline void CompareExpr::set_operator_(::milvus::grpc::CompareOperator value) { + + operator__ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operator) +} + +// string operand = 2; +inline void CompareExpr::clear_operand() { + operand_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& CompareExpr::operand() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CompareExpr.operand) + return operand_.GetNoArena(); +} +inline void CompareExpr::set_operand(const std::string& value) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(std::string&& value) { + + operand_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CompareExpr.operand) +} +inline void CompareExpr::set_operand(const char* value, size_t size) { + + operand_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CompareExpr.operand) +} +inline std::string* CompareExpr::mutable_operand() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.CompareExpr.operand) + return operand_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* CompareExpr::release_operand() { + // @@protoc_insertion_point(field_release:milvus.grpc.CompareExpr.operand) + + return operand_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void CompareExpr::set_allocated_operand(std::string* operand) { + if (operand != nullptr) { + + } else { + + } + operand_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), operand); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CompareExpr.operand) +} + +// ------------------------------------------------------------------- + +// RangeQuery + +// string field_name = 1; +inline void RangeQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& RangeQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.field_name) + return field_name_.GetNoArena(); +} +inline void RangeQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.RangeQuery.field_name) +} +inline void RangeQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.RangeQuery.field_name) +} +inline std::string* RangeQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* RangeQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.RangeQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void RangeQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.RangeQuery.field_name) +} + +// repeated .milvus.grpc.CompareExpr operand = 2; +inline int RangeQuery::operand_size() const { + return operand_.size(); +} +inline void RangeQuery::clear_operand() { + operand_.Clear(); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::mutable_operand(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.operand) + return operand_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >* +RangeQuery::mutable_operand() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.operand) + return &operand_; +} +inline const ::milvus::grpc::CompareExpr& RangeQuery::operand(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.operand) + return operand_.Get(index); +} +inline ::milvus::grpc::CompareExpr* RangeQuery::add_operand() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.operand) + return operand_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::CompareExpr >& +RangeQuery::operand() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.operand) + return operand_; +} + +// float boost = 3; +inline void RangeQuery::clear_boost() { + boost_ = 0; +} +inline float RangeQuery::boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.boost) + return boost_; +} +inline void RangeQuery::set_boost(float value) { + + boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.RangeQuery.boost) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int RangeQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void RangeQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +RangeQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RangeQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& RangeQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* RangeQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.RangeQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +RangeQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.RangeQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// VectorQuery + +// string field_name = 1; +inline void VectorQuery::clear_field_name() { + field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& VectorQuery::field_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.field_name) + return field_name_.GetNoArena(); +} +inline void VectorQuery::set_field_name(const std::string& value) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(std::string&& value) { + + field_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorQuery.field_name) +} +inline void VectorQuery::set_field_name(const char* value, size_t size) { + + field_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorQuery.field_name) +} +inline std::string* VectorQuery::mutable_field_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.field_name) + return field_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* VectorQuery::release_field_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorQuery.field_name) + + return field_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void VectorQuery::set_allocated_field_name(std::string* field_name) { + if (field_name != nullptr) { + + } else { + + } + field_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), field_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorQuery.field_name) +} + +// float query_boost = 2; +inline void VectorQuery::clear_query_boost() { + query_boost_ = 0; +} +inline float VectorQuery::query_boost() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.query_boost) + return query_boost_; +} +inline void VectorQuery::set_query_boost(float value) { + + query_boost_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.query_boost) +} + +// repeated .milvus.grpc.RowRecord records = 3; +inline int VectorQuery::records_size() const { + return records_.size(); +} +inline void VectorQuery::clear_records() { + records_.Clear(); +} +inline ::milvus::grpc::RowRecord* VectorQuery::mutable_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.records) + return records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >* +VectorQuery::mutable_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.records) + return &records_; +} +inline const ::milvus::grpc::RowRecord& VectorQuery::records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.records) + return records_.Get(index); +} +inline ::milvus::grpc::RowRecord* VectorQuery::add_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.records) + return records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& +VectorQuery::records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.records) + return records_; +} + +// int64 topk = 4; +inline void VectorQuery::clear_topk() { + topk_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 VectorQuery::topk() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.topk) + return topk_; +} +inline void VectorQuery::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) { + + topk_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.VectorQuery.topk) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int VectorQuery::extra_params_size() const { + return extra_params_.size(); +} +inline void VectorQuery::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +VectorQuery::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorQuery.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& VectorQuery::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* VectorQuery::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorQuery.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +VectorQuery::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorQuery.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// BooleanQuery + +// .milvus.grpc.Occur occur = 1; +inline void BooleanQuery::clear_occur() { + occur_ = 0; +} +inline ::milvus::grpc::Occur BooleanQuery::occur() const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.occur) + return static_cast< ::milvus::grpc::Occur >(occur_); +} +inline void BooleanQuery::set_occur(::milvus::grpc::Occur value) { + + occur_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.BooleanQuery.occur) +} + +// repeated .milvus.grpc.GeneralQuery general_query = 2; +inline int BooleanQuery::general_query_size() const { + return general_query_.size(); +} +inline void BooleanQuery::clear_general_query() { + general_query_.Clear(); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::mutable_general_query(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.BooleanQuery.general_query) + return general_query_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >* +BooleanQuery::mutable_general_query() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.BooleanQuery.general_query) + return &general_query_; +} +inline const ::milvus::grpc::GeneralQuery& BooleanQuery::general_query(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.BooleanQuery.general_query) + return general_query_.Get(index); +} +inline ::milvus::grpc::GeneralQuery* BooleanQuery::add_general_query() { + // @@protoc_insertion_point(field_add:milvus.grpc.BooleanQuery.general_query) + return general_query_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::GeneralQuery >& +BooleanQuery::general_query() const { + // @@protoc_insertion_point(field_list:milvus.grpc.BooleanQuery.general_query) + return general_query_; +} + +// ------------------------------------------------------------------- + +// GeneralQuery + +// .milvus.grpc.BooleanQuery boolean_query = 1; +inline bool GeneralQuery::has_boolean_query() const { + return query_case() == kBooleanQuery; +} +inline void GeneralQuery::set_has_boolean_query() { + _oneof_case_[0] = kBooleanQuery; +} +inline void GeneralQuery::clear_boolean_query() { + if (has_boolean_query()) { + delete query_.boolean_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::release_boolean_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.boolean_query) + if (has_boolean_query()) { + clear_has_query(); + ::milvus::grpc::BooleanQuery* temp = query_.boolean_query_; + query_.boolean_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::BooleanQuery& GeneralQuery::boolean_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.boolean_query) + return has_boolean_query() + ? *query_.boolean_query_ + : *reinterpret_cast< ::milvus::grpc::BooleanQuery*>(&::milvus::grpc::_BooleanQuery_default_instance_); +} +inline ::milvus::grpc::BooleanQuery* GeneralQuery::mutable_boolean_query() { + if (!has_boolean_query()) { + clear_query(); + set_has_boolean_query(); + query_.boolean_query_ = CreateMaybeMessage< ::milvus::grpc::BooleanQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.boolean_query) + return query_.boolean_query_; +} + +// .milvus.grpc.TermQuery term_query = 2; +inline bool GeneralQuery::has_term_query() const { + return query_case() == kTermQuery; +} +inline void GeneralQuery::set_has_term_query() { + _oneof_case_[0] = kTermQuery; +} +inline void GeneralQuery::clear_term_query() { + if (has_term_query()) { + delete query_.term_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::TermQuery* GeneralQuery::release_term_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.term_query) + if (has_term_query()) { + clear_has_query(); + ::milvus::grpc::TermQuery* temp = query_.term_query_; + query_.term_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::TermQuery& GeneralQuery::term_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.term_query) + return has_term_query() + ? *query_.term_query_ + : *reinterpret_cast< ::milvus::grpc::TermQuery*>(&::milvus::grpc::_TermQuery_default_instance_); +} +inline ::milvus::grpc::TermQuery* GeneralQuery::mutable_term_query() { + if (!has_term_query()) { + clear_query(); + set_has_term_query(); + query_.term_query_ = CreateMaybeMessage< ::milvus::grpc::TermQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.term_query) + return query_.term_query_; +} + +// .milvus.grpc.RangeQuery range_query = 3; +inline bool GeneralQuery::has_range_query() const { + return query_case() == kRangeQuery; +} +inline void GeneralQuery::set_has_range_query() { + _oneof_case_[0] = kRangeQuery; +} +inline void GeneralQuery::clear_range_query() { + if (has_range_query()) { + delete query_.range_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::release_range_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.range_query) + if (has_range_query()) { + clear_has_query(); + ::milvus::grpc::RangeQuery* temp = query_.range_query_; + query_.range_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::RangeQuery& GeneralQuery::range_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.range_query) + return has_range_query() + ? *query_.range_query_ + : *reinterpret_cast< ::milvus::grpc::RangeQuery*>(&::milvus::grpc::_RangeQuery_default_instance_); +} +inline ::milvus::grpc::RangeQuery* GeneralQuery::mutable_range_query() { + if (!has_range_query()) { + clear_query(); + set_has_range_query(); + query_.range_query_ = CreateMaybeMessage< ::milvus::grpc::RangeQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.range_query) + return query_.range_query_; +} + +// .milvus.grpc.VectorQuery vector_query = 4; +inline bool GeneralQuery::has_vector_query() const { + return query_case() == kVectorQuery; +} +inline void GeneralQuery::set_has_vector_query() { + _oneof_case_[0] = kVectorQuery; +} +inline void GeneralQuery::clear_vector_query() { + if (has_vector_query()) { + delete query_.vector_query_; + clear_has_query(); + } +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::release_vector_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.GeneralQuery.vector_query) + if (has_vector_query()) { + clear_has_query(); + ::milvus::grpc::VectorQuery* temp = query_.vector_query_; + query_.vector_query_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::milvus::grpc::VectorQuery& GeneralQuery::vector_query() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GeneralQuery.vector_query) + return has_vector_query() + ? *query_.vector_query_ + : *reinterpret_cast< ::milvus::grpc::VectorQuery*>(&::milvus::grpc::_VectorQuery_default_instance_); +} +inline ::milvus::grpc::VectorQuery* GeneralQuery::mutable_vector_query() { + if (!has_vector_query()) { + clear_query(); + set_has_vector_query(); + query_.vector_query_ = CreateMaybeMessage< ::milvus::grpc::VectorQuery >( + GetArenaNoVirtual()); + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.GeneralQuery.vector_query) + return query_.vector_query_; +} + +inline bool GeneralQuery::has_query() const { + return query_case() != QUERY_NOT_SET; +} +inline void GeneralQuery::clear_has_query() { + _oneof_case_[0] = QUERY_NOT_SET; +} +inline GeneralQuery::QueryCase GeneralQuery::query_case() const { + return GeneralQuery::QueryCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// HSearchParam + +// string collection_name = 1; +inline void HSearchParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HSearchParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HSearchParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchParam.collection_name) +} +inline void HSearchParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchParam.collection_name) +} +inline std::string* HSearchParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HSearchParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HSearchParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchParam.collection_name) +} + +// repeated string partition_tag_array = 2; +inline int HSearchParam::partition_tag_array_size() const { + return partition_tag_array_.size(); +} +inline void HSearchParam::clear_partition_tag_array() { + partition_tag_array_.Clear(); +} +inline const std::string& HSearchParam::partition_tag_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Get(index); +} +inline std::string* HSearchParam::mutable_partition_tag_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Mutable(index); +} +inline void HSearchParam::set_partition_tag_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(value); +} +inline void HSearchParam::set_partition_tag_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchParam.partition_tag_array) + partition_tag_array_.Mutable(index)->assign(std::move(value)); +} +inline void HSearchParam::set_partition_tag_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::set_partition_tag_array(int index, const char* value, size_t size) { + partition_tag_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchParam.partition_tag_array) +} +inline std::string* HSearchParam::add_partition_tag_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_.Add(); +} +inline void HSearchParam::add_partition_tag_array(const std::string& value) { + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(std::string&& value) { + partition_tag_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_tag_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HSearchParam.partition_tag_array) +} +inline void HSearchParam::add_partition_tag_array(const char* value, size_t size) { + partition_tag_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HSearchParam.partition_tag_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HSearchParam::partition_tag_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchParam.partition_tag_array) + return partition_tag_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HSearchParam::mutable_partition_tag_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchParam.partition_tag_array) + return &partition_tag_array_; +} + +// .milvus.grpc.GeneralQuery general_query = 3; +inline bool HSearchParam::has_general_query() const { + return this != internal_default_instance() && general_query_ != nullptr; +} +inline void HSearchParam::clear_general_query() { + if (GetArenaNoVirtual() == nullptr && general_query_ != nullptr) { + delete general_query_; + } + general_query_ = nullptr; +} +inline const ::milvus::grpc::GeneralQuery& HSearchParam::general_query() const { + const ::milvus::grpc::GeneralQuery* p = general_query_; + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.general_query) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_GeneralQuery_default_instance_); +} +inline ::milvus::grpc::GeneralQuery* HSearchParam::release_general_query() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchParam.general_query) + + ::milvus::grpc::GeneralQuery* temp = general_query_; + general_query_ = nullptr; + return temp; +} +inline ::milvus::grpc::GeneralQuery* HSearchParam::mutable_general_query() { + + if (general_query_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::GeneralQuery>(GetArenaNoVirtual()); + general_query_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.general_query) + return general_query_; +} +inline void HSearchParam::set_allocated_general_query(::milvus::grpc::GeneralQuery* general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete general_query_; + } + if (general_query) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + general_query = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, general_query, submessage_arena); + } + + } else { + + } + general_query_ = general_query; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchParam.general_query) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int HSearchParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HSearchParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HSearchParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HSearchParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HSearchParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HSearchParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HSearchParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// HSearchInSegmentsParam + +// repeated string segment_id_array = 1; +inline int HSearchInSegmentsParam::segment_id_array_size() const { + return segment_id_array_.size(); +} +inline void HSearchInSegmentsParam::clear_segment_id_array() { + segment_id_array_.Clear(); +} +inline const std::string& HSearchInSegmentsParam::segment_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Get(index); +} +inline std::string* HSearchInSegmentsParam::mutable_segment_id_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Mutable(index); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(value); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + segment_id_array_.Mutable(index)->assign(std::move(value)); +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::set_segment_id_array(int index, const char* value, size_t size) { + segment_id_array_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline std::string* HSearchInSegmentsParam::add_segment_id_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_.Add(); +} +inline void HSearchInSegmentsParam::add_segment_id_array(const std::string& value) { + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(std::string&& value) { + segment_id_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(const char* value) { + GOOGLE_DCHECK(value != nullptr); + segment_id_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline void HSearchInSegmentsParam::add_segment_id_array(const char* value, size_t size) { + segment_id_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HSearchInSegmentsParam.segment_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HSearchInSegmentsParam::segment_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return segment_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HSearchInSegmentsParam::mutable_segment_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HSearchInSegmentsParam.segment_id_array) + return &segment_id_array_; +} + +// .milvus.grpc.HSearchParam search_param = 2; +inline bool HSearchInSegmentsParam::has_search_param() const { + return this != internal_default_instance() && search_param_ != nullptr; +} +inline void HSearchInSegmentsParam::clear_search_param() { + if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) { + delete search_param_; + } + search_param_ = nullptr; +} +inline const ::milvus::grpc::HSearchParam& HSearchInSegmentsParam::search_param() const { + const ::milvus::grpc::HSearchParam* p = search_param_; + // @@protoc_insertion_point(field_get:milvus.grpc.HSearchInSegmentsParam.search_param) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HSearchParam_default_instance_); +} +inline ::milvus::grpc::HSearchParam* HSearchInSegmentsParam::release_search_param() { + // @@protoc_insertion_point(field_release:milvus.grpc.HSearchInSegmentsParam.search_param) + + ::milvus::grpc::HSearchParam* temp = search_param_; + search_param_ = nullptr; + return temp; +} +inline ::milvus::grpc::HSearchParam* HSearchInSegmentsParam::mutable_search_param() { + + if (search_param_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HSearchParam>(GetArenaNoVirtual()); + search_param_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HSearchInSegmentsParam.search_param) + return search_param_; +} +inline void HSearchInSegmentsParam::set_allocated_search_param(::milvus::grpc::HSearchParam* search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete search_param_; + } + if (search_param) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + search_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, search_param, submessage_arena); + } + + } else { + + } + search_param_ = search_param; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HSearchInSegmentsParam.search_param) +} + +// ------------------------------------------------------------------- + +// AttrRecord + +// repeated string value = 1; +inline int AttrRecord::value_size() const { + return value_.size(); +} +inline void AttrRecord::clear_value() { + value_.Clear(); +} +inline const std::string& AttrRecord::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.value) + return value_.Get(index); +} +inline std::string* AttrRecord::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.AttrRecord.value) + return value_.Mutable(index); +} +inline void AttrRecord::set_value(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.value) + value_.Mutable(index)->assign(value); +} +inline void AttrRecord::set_value(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.value) + value_.Mutable(index)->assign(std::move(value)); +} +inline void AttrRecord::set_value(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + value_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::set_value(int index, const char* value, size_t size) { + value_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.AttrRecord.value) +} +inline std::string* AttrRecord::add_value() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.AttrRecord.value) + return value_.Add(); +} +inline void AttrRecord::add_value(const std::string& value) { + value_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(std::string&& value) { + value_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(const char* value) { + GOOGLE_DCHECK(value != nullptr); + value_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.AttrRecord.value) +} +inline void AttrRecord::add_value(const char* value, size_t size) { + value_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.AttrRecord.value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +AttrRecord::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.value) + return value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +AttrRecord::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.value) + return &value_; +} + +// ------------------------------------------------------------------- + +// HEntity + +// .milvus.grpc.Status status = 1; +inline bool HEntity::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HEntity::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HEntity::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntity.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HEntity::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.status) + return status_; +} +inline void HEntity::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.HEntity.status) +} + +// int64 entity_id = 2; +inline void HEntity::clear_entity_id() { + entity_id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.entity_id) + return entity_id_; +} +inline void HEntity::set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + entity_id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.entity_id) +} + +// repeated string field_names = 3; +inline int HEntity::field_names_size() const { + return field_names_.size(); +} +inline void HEntity::clear_field_names() { + field_names_.Clear(); +} +inline const std::string& HEntity::field_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.field_names) + return field_names_.Get(index); +} +inline std::string* HEntity::mutable_field_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.field_names) + return field_names_.Mutable(index); +} +inline void HEntity::set_field_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.field_names) + field_names_.Mutable(index)->assign(value); +} +inline void HEntity::set_field_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.field_names) + field_names_.Mutable(index)->assign(std::move(value)); +} +inline void HEntity::set_field_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntity.field_names) +} +inline void HEntity::set_field_names(int index, const char* value, size_t size) { + field_names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntity.field_names) +} +inline std::string* HEntity::add_field_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.HEntity.field_names) + return field_names_.Add(); +} +inline void HEntity::add_field_names(const std::string& value) { + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(std::string&& value) { + field_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + field_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.HEntity.field_names) +} +inline void HEntity::add_field_names(const char* value, size_t size) { + field_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.HEntity.field_names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +HEntity::field_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.field_names) + return field_names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +HEntity::mutable_field_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.field_names) + return &field_names_; +} + +// repeated .milvus.grpc.AttrRecord attr_records = 4; +inline int HEntity::attr_records_size() const { + return attr_records_.size(); +} +inline void HEntity::clear_attr_records() { + attr_records_.Clear(); +} +inline ::milvus::grpc::AttrRecord* HEntity::mutable_attr_records(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_records) + return attr_records_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* +HEntity::mutable_attr_records() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.attr_records) + return &attr_records_; +} +inline const ::milvus::grpc::AttrRecord& HEntity::attr_records(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_records) + return attr_records_.Get(index); +} +inline ::milvus::grpc::AttrRecord* HEntity::add_attr_records() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.attr_records) + return attr_records_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& +HEntity::attr_records() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.attr_records) + return attr_records_; +} + +// repeated .milvus.grpc.FieldValue result_values = 5; +inline int HEntity::result_values_size() const { + return result_values_.size(); +} +inline void HEntity::clear_result_values() { + result_values_.Clear(); +} +inline ::milvus::grpc::FieldValue* HEntity::mutable_result_values(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.result_values) + return result_values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >* +HEntity::mutable_result_values() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.result_values) + return &result_values_; +} +inline const ::milvus::grpc::FieldValue& HEntity::result_values(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.result_values) + return result_values_.Get(index); +} +inline ::milvus::grpc::FieldValue* HEntity::add_result_values() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.result_values) + return result_values_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue >& +HEntity::result_values() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.result_values) + return result_values_; +} + +// ------------------------------------------------------------------- + +// HQueryResult + +// .milvus.grpc.Status status = 1; +inline bool HQueryResult::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HQueryResult::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HQueryResult::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HQueryResult.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HQueryResult::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.status) + return status_; +} +inline void HQueryResult::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.HQueryResult.status) +} + +// repeated .milvus.grpc.HEntity entities = 2; +inline int HQueryResult::entities_size() const { + return entities_.size(); +} +inline void HQueryResult::clear_entities() { + entities_.Clear(); +} +inline ::milvus::grpc::HEntity* HQueryResult::mutable_entities(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entities) + return entities_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >* +HQueryResult::mutable_entities() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.entities) + return &entities_; +} +inline const ::milvus::grpc::HEntity& HQueryResult::entities(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.entities) + return entities_.Get(index); +} +inline ::milvus::grpc::HEntity* HQueryResult::add_entities() { + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.entities) + return entities_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& +HQueryResult::entities() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.entities) + return entities_; +} + +// int64 row_num = 3; +inline void HQueryResult::clear_row_num() { + row_num_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HQueryResult::row_num() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.row_num) + return row_num_; +} +inline void HQueryResult::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) { + + row_num_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.row_num) +} + +// repeated float score = 4; +inline int HQueryResult::score_size() const { + return score_.size(); +} +inline void HQueryResult::clear_score() { + score_.Clear(); +} +inline float HQueryResult::score(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.score) + return score_.Get(index); +} +inline void HQueryResult::set_score(int index, float value) { + score_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.score) +} +inline void HQueryResult::add_score(float value) { + score_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.score) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +HQueryResult::score() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.score) + return score_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +HQueryResult::mutable_score() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.score) + return &score_; +} + +// repeated float distance = 5; +inline int HQueryResult::distance_size() const { + return distance_.size(); +} +inline void HQueryResult::clear_distance() { + distance_.Clear(); +} +inline float HQueryResult::distance(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.distance) + return distance_.Get(index); +} +inline void HQueryResult::set_distance(int index, float value) { + distance_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HQueryResult.distance) +} +inline void HQueryResult::add_distance(float value) { + distance_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.distance) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >& +HQueryResult::distance() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.distance) + return distance_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* +HQueryResult::mutable_distance() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.distance) + return &distance_; +} + +// ------------------------------------------------------------------- + +// HInsertParam + +// string collection_name = 1; +inline void HInsertParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HInsertParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HInsertParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HInsertParam.collection_name) +} +inline void HInsertParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HInsertParam.collection_name) +} +inline std::string* HInsertParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HInsertParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HInsertParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.collection_name) +} + +// string partition_tag = 2; +inline void HInsertParam::clear_partition_tag() { + partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HInsertParam::partition_tag() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.partition_tag) + return partition_tag_.GetNoArena(); +} +inline void HInsertParam::set_partition_tag(const std::string& value) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(std::string&& value) { + + partition_tag_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HInsertParam.partition_tag) +} +inline void HInsertParam::set_partition_tag(const char* value, size_t size) { + + partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HInsertParam.partition_tag) +} +inline std::string* HInsertParam::mutable_partition_tag() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.partition_tag) + return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HInsertParam::release_partition_tag() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.partition_tag) + + return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HInsertParam::set_allocated_partition_tag(std::string* partition_tag) { + if (partition_tag != nullptr) { + + } else { + + } + partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.partition_tag) +} + +// .milvus.grpc.HEntity entities = 3; +inline bool HInsertParam::has_entities() const { + return this != internal_default_instance() && entities_ != nullptr; +} +inline void HInsertParam::clear_entities() { + if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { + delete entities_; + } + entities_ = nullptr; +} +inline const ::milvus::grpc::HEntity& HInsertParam::entities() const { + const ::milvus::grpc::HEntity* p = entities_; + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entities) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HEntity_default_instance_); +} +inline ::milvus::grpc::HEntity* HInsertParam::release_entities() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.entities) + + ::milvus::grpc::HEntity* temp = entities_; + entities_ = nullptr; + return temp; +} +inline ::milvus::grpc::HEntity* HInsertParam::mutable_entities() { + + if (entities_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); + entities_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entities) + return entities_; +} +inline void HInsertParam::set_allocated_entities(::milvus::grpc::HEntity* entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete entities_; + } + if (entities) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entities, submessage_arena); + } + + } else { + + } + entities_ = entities; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entities) +} + +// repeated int64 entity_id_array = 4; +inline int HInsertParam::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void HInsertParam::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HInsertParam::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entity_id_array) + return entity_id_array_.Get(index); +} +inline void HInsertParam::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HInsertParam.entity_id_array) +} +inline void HInsertParam::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HInsertParam.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HInsertParam::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HInsertParam.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HInsertParam::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HInsertParam.entity_id_array) + return &entity_id_array_; +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 5; +inline int HInsertParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HInsertParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HInsertParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HInsertParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HInsertParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HInsertParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HInsertParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HInsertParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HInsertParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HInsertParam.extra_params) + return extra_params_; +} + +// ------------------------------------------------------------------- + +// HEntityIdentity + +// string collection_name = 1; +inline void HEntityIdentity::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HEntityIdentity::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.collection_name) + return collection_name_.GetNoArena(); +} +inline void HEntityIdentity::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntityIdentity.collection_name) +} +inline void HEntityIdentity::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntityIdentity.collection_name) +} +inline std::string* HEntityIdentity::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntityIdentity.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HEntityIdentity::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntityIdentity.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HEntityIdentity::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntityIdentity.collection_name) +} + +// int64 id = 2; +inline void HEntityIdentity::clear_id() { + id_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.id) + return id_; +} +inline void HEntityIdentity::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + + id_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.id) +} + +// ------------------------------------------------------------------- + +// HEntityIDs + +// .milvus.grpc.Status status = 1; +inline bool HEntityIDs::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HEntityIDs::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIDs.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HEntityIDs::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HEntityIDs.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HEntityIDs::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntityIDs.status) + return status_; +} +inline void HEntityIDs::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.HEntityIDs.status) +} + +// repeated int64 entity_id_array = 2; +inline int HEntityIDs::entity_id_array_size() const { + return entity_id_array_.size(); +} +inline void HEntityIDs::clear_entity_id_array() { + entity_id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIDs::entity_id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIDs.entity_id_array) + return entity_id_array_.Get(index); +} +inline void HEntityIDs::set_entity_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIDs.entity_id_array) +} +inline void HEntityIDs::add_entity_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntityIDs.entity_id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntityIDs::entity_id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntityIDs.entity_id_array) + return entity_id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntityIDs::mutable_entity_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntityIDs.entity_id_array) + return &entity_id_array_; +} + +// ------------------------------------------------------------------- + +// HGetEntityIDsParam + +// string collection_name = 1; +inline void HGetEntityIDsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HGetEntityIDsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HGetEntityIDsParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HGetEntityIDsParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline void HGetEntityIDsParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HGetEntityIDsParam.collection_name) +} +inline std::string* HGetEntityIDsParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HGetEntityIDsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HGetEntityIDsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HGetEntityIDsParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HGetEntityIDsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HGetEntityIDsParam.collection_name) +} + +// string segment_name = 2; +inline void HGetEntityIDsParam::clear_segment_name() { + segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HGetEntityIDsParam::segment_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HGetEntityIDsParam.segment_name) + return segment_name_.GetNoArena(); +} +inline void HGetEntityIDsParam::set_segment_name(const std::string& value) { + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(std::string&& value) { + + segment_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline void HGetEntityIDsParam::set_segment_name(const char* value, size_t size) { + + segment_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HGetEntityIDsParam.segment_name) +} +inline std::string* HGetEntityIDsParam::mutable_segment_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HGetEntityIDsParam.segment_name) + return segment_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HGetEntityIDsParam::release_segment_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HGetEntityIDsParam.segment_name) + + return segment_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HGetEntityIDsParam::set_allocated_segment_name(std::string* segment_name) { + if (segment_name != nullptr) { + + } else { + + } + segment_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), segment_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HGetEntityIDsParam.segment_name) +} + +// ------------------------------------------------------------------- + +// HDeleteByIDParam + +// string collection_name = 1; +inline void HDeleteByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HDeleteByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HDeleteByIDParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HDeleteByIDParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline void HDeleteByIDParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HDeleteByIDParam.collection_name) +} +inline std::string* HDeleteByIDParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HDeleteByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HDeleteByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HDeleteByIDParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HDeleteByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HDeleteByIDParam.collection_name) +} + +// repeated int64 id_array = 2; +inline int HDeleteByIDParam::id_array_size() const { + return id_array_.size(); +} +inline void HDeleteByIDParam::clear_id_array() { + id_array_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 HDeleteByIDParam::id_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HDeleteByIDParam.id_array) + return id_array_.Get(index); +} +inline void HDeleteByIDParam::set_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HDeleteByIDParam.id_array) +} +inline void HDeleteByIDParam::add_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_array_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HDeleteByIDParam.id_array) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HDeleteByIDParam::id_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HDeleteByIDParam.id_array) + return id_array_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HDeleteByIDParam::mutable_id_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HDeleteByIDParam.id_array) + return &id_array_; +} + +// ------------------------------------------------------------------- + +// HIndexParam + +// .milvus.grpc.Status status = 1; +inline bool HIndexParam::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::grpc::Status& HIndexParam::status() const { + const ::milvus::grpc::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_Status_default_instance_); +} +inline ::milvus::grpc::Status* HIndexParam::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.HIndexParam.status) + + ::milvus::grpc::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::grpc::Status* HIndexParam::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.status) + return status_; +} +inline void HIndexParam::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.HIndexParam.status) +} + +// string collection_name = 2; +inline void HIndexParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& HIndexParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.collection_name) + return collection_name_.GetNoArena(); +} +inline void HIndexParam::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.HIndexParam.collection_name) +} +inline void HIndexParam::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HIndexParam.collection_name) +} +inline std::string* HIndexParam::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* HIndexParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.HIndexParam.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void HIndexParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HIndexParam.collection_name) +} + +// int32 index_type = 3; +inline void HIndexParam::clear_index_type() { + index_type_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 HIndexParam::index_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.index_type) + return index_type_; +} +inline void HIndexParam::set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value) { + + index_type_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.HIndexParam.index_type) +} + +// repeated .milvus.grpc.KeyValuePair extra_params = 4; +inline int HIndexParam::extra_params_size() const { + return extra_params_.size(); +} +inline void HIndexParam::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HIndexParam::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HIndexParam::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HIndexParam.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HIndexParam::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HIndexParam::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HIndexParam.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HIndexParam::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HIndexParam.extra_params) + return extra_params_; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -7097,12 +14168,80 @@ inline void GetVectorIDsParam::set_allocated_segment_name(std::string* segment_n // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) } // namespace grpc } // namespace milvus +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::milvus::grpc::DataType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::DataType>() { + return ::milvus::grpc::DataType_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::CompareOperator> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::CompareOperator>() { + return ::milvus::grpc::CompareOperator_descriptor(); +} +template <> struct is_proto_enum< ::milvus::grpc::Occur> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::Occur>() { + return ::milvus::grpc::Occur_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + // @@protoc_insertion_point(global_scope) #include diff --git a/sdk/grpc/ClientProxy.cpp b/sdk/grpc/ClientProxy.cpp index b0dc36aa42..d78c16088f 100644 --- a/sdk/grpc/ClientProxy.cpp +++ b/sdk/grpc/ClientProxy.cpp @@ -574,4 +574,191 @@ ClientProxy::CompactCollection(const std::string& collection_name) { } } +/*******************************New Interface**********************************/ + +Status +ClientProxy::CreateHybridCollection(const HMapping& mapping) { + try { + ::milvus::grpc::Mapping grpc_mapping; + grpc_mapping.set_collection_name(mapping.collection_name); + for (auto field : mapping.numerica_fields) { + ::milvus::grpc::FieldParam* field_param = grpc_mapping.add_fields(); + field_param->set_name(field->field_name); + field_param->mutable_type()->set_data_type((::milvus::grpc::DataType)field->field_type); + ::milvus::grpc::KeyValuePair* kv_pair = field_param->add_extra_params(); + kv_pair->set_key("params"); + kv_pair->set_value(field->extram_params); + } + for (auto field : mapping.vector_fields) { + ::milvus::grpc::FieldParam* field_param = grpc_mapping.add_fields(); + field_param->set_name(field->field_name); + field_param->mutable_type()->set_data_type((::milvus::grpc::DataType)field->field_type); + field_param->mutable_type()->mutable_vector_param()->set_dimension(field->dimension); + ::milvus::grpc::KeyValuePair* kv_pair = field_param->add_extra_params(); + kv_pair->set_key("params"); + kv_pair->set_value(field->extram_params); + } + return client_ptr_->CreateHybridCollection(grpc_mapping); + } catch (std::exception& exception) { + return Status(StatusCode::UnknownError, "Failed to create collection: " + std::string(exception.what())); + } + +} + +void +CopyVectorField(::milvus::grpc::RowRecord* target, const Entity& src) { + if (!src.float_data.empty()) { + auto vector_data = target->mutable_float_data(); + vector_data->Resize(static_cast(src.float_data.size()), 0.0); + memcpy(vector_data->mutable_data(), src.float_data.data(), src.float_data.size() * sizeof(float)); + } + + if (!src.binary_data.empty()) { + target->set_binary_data(src.binary_data.data(), src.binary_data.size()); + } +} + +Status +ClientProxy::InsertEntity(const std::string& collection_name, + const std::string& partition_tag, + HEntity& entities, + std::vector& id_array) { + Status status; + try { + ::milvus::grpc::HInsertParam grpc_param; + grpc_param.set_collection_name(collection_name); + grpc_param.set_partition_tag(partition_tag); + + auto numerica_it = entities.numerica_value.begin(); + for (; numerica_it != entities.numerica_value.end(); numerica_it++) { + auto name = grpc_param.mutable_entities()->add_field_names(); + *name = numerica_it->first; + auto records = grpc_param.mutable_entities()->add_attr_records(); + for (auto value : numerica_it->second) { + auto attr = records->add_value(); + *attr = value; + } + } + + auto vector_it = entities.vector_value.begin(); + for (; vector_it != entities.vector_value.end(); vector_it++) { + auto name = grpc_param.mutable_entities()->add_field_names(); + *name = vector_it->first; + ::milvus::grpc::FieldValue* vector_field = grpc_param.mutable_entities()->add_result_values(); + for (auto entity : vector_it->second) { + ::milvus::grpc::RowRecord* record = vector_field->mutable_vector_value()->add_value(); + CopyVectorField(record, entity); + } + } + + ::milvus::grpc::HEntityIDs entity_ids; + if (!id_array.empty()) { + auto row_ids = grpc_param.mutable_entity_id_array(); + row_ids->Resize(static_cast(id_array.size()), -1); + memcpy(row_ids->mutable_data(), id_array.data(), id_array.size() * sizeof(int64_t)); + status = client_ptr_->InsertEntities(grpc_param, entity_ids); + } else { + status = client_ptr_->InsertEntities(grpc_param, entity_ids); + id_array.insert(id_array.end(), entity_ids.entity_id_array().begin(), entity_ids.entity_id_array().end()); + } + } catch (std::exception& exception) { + return Status(StatusCode::UnknownError, "Failed to create collection: " + std::string(exception.what())); + } + + return status; +} + +void +WriteQueryToProto(::milvus::grpc::GeneralQuery* general_query, BooleanQueryPtr boolean_query) { + if (!boolean_query->GetBooleanQueries().empty()) { + for (auto query : boolean_query->GetBooleanQueries()) { + auto grpc_boolean_query = general_query->mutable_boolean_query(); + grpc_boolean_query->set_occur((::milvus::grpc::Occur)query->GetOccur()); + ::milvus::grpc::GeneralQuery* next_query = grpc_boolean_query->add_general_query(); + WriteQueryToProto(next_query, query); + } + } else { + for (auto leaf_query : boolean_query->GetLeafQueries()) { + ::milvus::grpc::GeneralQuery* grpc_query = general_query->mutable_boolean_query()->add_general_query(); + if (leaf_query->term_query_ptr != nullptr) { + auto term_query = grpc_query->mutable_term_query(); + term_query->set_field_name(leaf_query->term_query_ptr->field_name); + term_query->set_boost(leaf_query->query_boost); + for (auto field_value : leaf_query->term_query_ptr->field_value) { + auto value = term_query->add_values(); + *value = field_value; + } + } + if (leaf_query->range_query_ptr != nullptr) { + auto range_query = grpc_query->mutable_range_query(); + range_query->set_boost(leaf_query->query_boost); + range_query->set_field_name(leaf_query->range_query_ptr->field_name); + for (auto com_expr : leaf_query->range_query_ptr->compare_expr) { + auto grpc_com_expr = range_query->add_operand(); + grpc_com_expr->set_operand(com_expr.operand); + grpc_com_expr->set_operator_((milvus::grpc::CompareOperator)com_expr.compare_operator); + } + } + if (leaf_query->vector_query_ptr != nullptr) { + auto vector_query = grpc_query->mutable_vector_query(); + vector_query->set_field_name(leaf_query->vector_query_ptr->field_name); + vector_query->set_query_boost(leaf_query->query_boost); + vector_query->set_topk(leaf_query->vector_query_ptr->topk); + for (auto record : leaf_query->vector_query_ptr->query_vector) { + ::milvus::grpc::RowRecord* row_record = vector_query->add_records(); + CopyRowRecord(row_record, record); + } + auto extra_param = vector_query->add_extra_params(); + extra_param->set_key(EXTRA_PARAM_KEY); + extra_param->set_value(leaf_query->vector_query_ptr->extra_params); + } + } + } +} + +Status +ClientProxy::HybridSearch(const std::string& collection_name, + const std::vector& partition_list, + BooleanQueryPtr& boolean_query, + const std::string& extra_params, + TopKQueryResult& topk_query_result) { + try { + // convert boolean_query to proto + ::milvus::grpc::HSearchParam search_param; + search_param.set_collection_name(collection_name); + for (auto partition : partition_list) { + auto value = search_param.add_partition_tag_array(); + *value = partition; + } + auto extra_param = search_param.add_extra_params(); + extra_param->set_key("params"); + extra_param->set_value(extra_params); + WriteQueryToProto(search_param.mutable_general_query(), boolean_query); + + // step 2: search vectors + ::milvus::grpc::TopKQueryResult result; + Status status = client_ptr_->HybridSearch(search_param, result); + + // step 3: convert result array + topk_query_result.reserve(result.row_num()); + int64_t nq = result.row_num(); + if (nq == 0) { + return status; + } + int64_t topk = result.ids().size() / nq; + for (int64_t i = 0; i < result.row_num(); i++) { + milvus::QueryResult one_result; + one_result.ids.resize(topk); + one_result.distances.resize(topk); + memcpy(one_result.ids.data(), result.ids().data() + topk * i, topk * sizeof(int64_t)); + memcpy(one_result.distances.data(), result.distances().data() + topk * i, topk * sizeof(float)); + topk_query_result.emplace_back(one_result); + } + + return status; + } catch (std::exception& ex) { + return Status(StatusCode::UnknownError, "Failed to search entities: " + std::string(ex.what())); + } +} + } // namespace milvus diff --git a/sdk/grpc/ClientProxy.h b/sdk/grpc/ClientProxy.h index f395ce32ca..285e1c8ded 100644 --- a/sdk/grpc/ClientProxy.h +++ b/sdk/grpc/ClientProxy.h @@ -122,6 +122,24 @@ class ClientProxy : public Connection { Status CompactCollection(const std::string& collection_name) override; + /*******************************New Interface**********************************/ + + Status + CreateHybridCollection(const HMapping& mapping) override; + + Status + InsertEntity(const std::string& collection_name, + const std::string& partition_tag, + HEntity& entities, + std::vector& id_array) override; + + Status + HybridSearch(const std::string& collection_name, + const std::vector& partition_list, + BooleanQueryPtr& boolean_query, + const std::string& extra_params, + TopKQueryResult& topk_query_result) override; + private: std::shared_ptr<::grpc::Channel> channel_; std::shared_ptr client_ptr_; diff --git a/sdk/grpc/GrpcClient.cpp b/sdk/grpc/GrpcClient.cpp index 18216604bf..df4faa2d17 100644 --- a/sdk/grpc/GrpcClient.cpp +++ b/sdk/grpc/GrpcClient.cpp @@ -455,4 +455,56 @@ GrpcClient::Disconnect() { return Status::OK(); } +Status +GrpcClient::CreateHybridCollection(milvus::grpc::Mapping& mapping) { + ClientContext context; + ::milvus::grpc::Status response; + ::grpc::Status grpc_status = stub_->CreateHybridCollection(&context, mapping, &response); + + if (!grpc_status.ok()) { + std::cerr << "CreateHybridCollection gRPC failed!" << std::endl; + return Status(StatusCode::RPCFailed, grpc_status.error_message()); + } + + if (response.error_code() != grpc::SUCCESS) { + std::cerr << response.reason() << std::endl; + return Status(StatusCode::ServerFailed, response.reason()); + } + return Status::OK(); +} + +Status +GrpcClient::InsertEntities(milvus::grpc::HInsertParam& entities, milvus::grpc::HEntityIDs& ids) { + ClientContext context; + ::grpc::Status grpc_status = stub_->InsertEntity(&context, entities, &ids); + + if (!grpc_status.ok()) { + std::cerr << "InsertEntities gRPC failed!" << std::endl; + return Status(StatusCode::RPCFailed, grpc_status.error_message()); + } + + if (ids.status().error_code() != grpc::SUCCESS) { + std::cerr << ids.status().reason() << std::endl; + return Status(StatusCode::ServerFailed, ids.status().reason()); + } + return Status::OK(); +} + +Status +GrpcClient::HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::TopKQueryResult& result) { + ClientContext context; + ::grpc::Status grpc_status = stub_->HybridSearch(&context, search_param, &result); + + if (!grpc_status.ok()) { + std::cerr << "HybridSearch gRPC failed!" << std::endl; + return Status(StatusCode::RPCFailed, grpc_status.error_message()); + } + + if (result.status().error_code() != grpc::SUCCESS) { + std::cerr << result.status().reason() << std::endl; + return Status(StatusCode::ServerFailed, result.status().reason()); + } + return Status::OK(); +} + } // namespace milvus diff --git a/sdk/grpc/GrpcClient.h b/sdk/grpc/GrpcClient.h index 7873144dae..3e68e32a24 100644 --- a/sdk/grpc/GrpcClient.h +++ b/sdk/grpc/GrpcClient.h @@ -104,6 +104,16 @@ class GrpcClient { Status Disconnect(); + /*******************************New Interface**********************************/ + Status + CreateHybridCollection(milvus::grpc::Mapping& mapping); + + Status + InsertEntities(milvus::grpc::HInsertParam& entities, milvus::grpc::HEntityIDs& ids); + + Status + HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::TopKQueryResult& result); + private: std::unique_ptr stub_; }; diff --git a/sdk/include/BooleanQuery.h b/sdk/include/BooleanQuery.h new file mode 100644 index 0000000000..a834a3ef56 --- /dev/null +++ b/sdk/include/BooleanQuery.h @@ -0,0 +1,68 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include + +# include "GeneralQuery.h" + +namespace milvus { + +enum class Occur { + INVALID = 0, + MUST, + MUST_NOT, + SHOULD, +}; + +class BooleanQuery { + public: + BooleanQuery() {} + + BooleanQuery(Occur occur) : occur_(occur) {} + + void + AddLeafQuery(LeafQueryPtr leaf_query) { + leaf_queries_.emplace_back(leaf_query); + } + + void + AddBooleanQuery(std::shared_ptr boolean_query) { + boolean_queries_.emplace_back(boolean_query); + } + + std::vector>& + GetBooleanQueries() { + return boolean_queries_; + } + + std::vector& + GetLeafQueries() { + return leaf_queries_; + } + + Occur + GetOccur() { + return occur_; + } + + private: + Occur occur_; + std::vector> boolean_queries_; + std::vector leaf_queries_; +}; +using BooleanQueryPtr = std::shared_ptr; + +} \ No newline at end of file diff --git a/sdk/include/Field.h b/sdk/include/Field.h new file mode 100644 index 0000000000..c218161127 --- /dev/null +++ b/sdk/include/Field.h @@ -0,0 +1,64 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include "Status.h" + + +namespace milvus { + +enum class DataType { + INT8 = 1, + INT16 = 2, + INT32 = 3, + INT64 = 4, + + STRING = 20, + + BOOL = 30, + + FLOAT = 40, + DOUBLE = 41, + + VECTOR = 100, + UNKNOWN = 9999, +}; + +// Base struct of all fields +struct Field { + uint64_t field_id; ///< read-only + std::string field_name; + DataType field_type; + float boost; + std::string extram_params; +}; +using FieldPtr = std::shared_ptr; + +// DistanceMetric +enum class DistanceMetric { + L2 = 1, // Euclidean Distance + IP = 2, // Cosine Similarity + HAMMING = 3, // Hamming Distance + JACCARD = 4, // Jaccard Distance + TANIMOTO = 5, // Tanimoto Distance +}; + +// vector field +struct VectorField : Field { + uint64_t dimension; +}; +using VectorFieldPtr = std::shared_ptr; + +} \ No newline at end of file diff --git a/sdk/include/GeneralQuery.h b/sdk/include/GeneralQuery.h new file mode 100644 index 0000000000..645fc70cc5 --- /dev/null +++ b/sdk/include/GeneralQuery.h @@ -0,0 +1,96 @@ +// Copyright (C) 2019-2020 Zilliz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License. + +#pragma once + +#include +#include +#include +#include + +namespace milvus { + +/** + * @brief Entity inserted, currently each entity represent a vector + */ +struct Entity { + std::vector float_data; ///< Vector raw float data + std::vector binary_data; ///< Vector raw binary data +}; + + +// base class of all queries +struct Sort { + std::string field_name; + int64_t rules; // 0 is inc, 1 is dec +}; + +struct Query { + std::string field_name; + int64_t from; + int64_t size; + Sort sort; + float min_score; + float boost; +}; + +enum class CompareOperator { + LT = 0, + LTE, + EQ, + GT, + GTE, + NE, +}; + +struct QueryColumn { + std::string name; + std::string column_value; +}; + +struct TermQuery : Query { + std::vector field_value; +}; +using TermQueryPtr = std::shared_ptr; + +struct CompareExpr { + CompareOperator compare_operator; + std::string operand; +}; + +struct RangeQuery : Query { + std::vector compare_expr; +}; +using RangeQueryPtr = std::shared_ptr; + +struct RowRecord { + std::vector float_data; + std::vector binary_data; +}; + +struct VectorQuery : Query { + uint64_t topk; + float distance_limitation; + float query_boost; + std::vector query_vector; + std::string extra_params; +}; +using VectorQueryPtr = std::shared_ptr; + +struct LeafQuery { + TermQueryPtr term_query_ptr; + RangeQueryPtr range_query_ptr; + VectorQueryPtr vector_query_ptr; + float query_boost; +}; +using LeafQueryPtr = std::shared_ptr; + +} \ No newline at end of file diff --git a/sdk/include/MilvusApi.h b/sdk/include/MilvusApi.h index 9bc585c54e..9fa688998e 100644 --- a/sdk/include/MilvusApi.h +++ b/sdk/include/MilvusApi.h @@ -14,7 +14,10 @@ #include #include #include +#include +#include "BooleanQuery.h" +#include "Field.h" #include "Status.h" /** \brief Milvus SDK namespace @@ -66,14 +69,6 @@ struct CollectionParam { MetricType metric_type = MetricType::L2; ///< Index metric type }; -/** - * @brief Entity inserted, currently each entity represent a vector - */ -struct Entity { - std::vector float_data; ///< Vector raw float data - std::vector binary_data; ///< Vector raw binary data -}; - /** * @brief TopK query result */ @@ -144,6 +139,22 @@ struct CollectionInfo { std::vector partitions_stat; ///< Collection's partitions statistics }; + + +struct HMapping { + std::string collection_name; + std::vector numerica_fields; + std::vector vector_fields; +}; + +struct HEntity { + std::unordered_map> numerica_value; + std::unordered_map> vector_value; +}; + + + + /** * @brief SDK main class */ @@ -575,6 +586,24 @@ class Connection { */ virtual Status CompactCollection(const std::string& collection_name) = 0; + + /*******************************New Interface**********************************/ + + virtual Status + CreateHybridCollection(const HMapping& mapping) = 0; + + virtual Status + InsertEntity(const std::string& collection_name, + const std::string& partition_tag, + HEntity& entities, + std::vector& id_array) = 0; + + virtual Status + HybridSearch(const std::string& collection_name, + const std::vector& partition_list, + BooleanQueryPtr& boolean_query, + const std::string& extra_params, + TopKQueryResult& topk_query_result) = 0; }; } // namespace milvus diff --git a/sdk/interface/ConnectionImpl.cpp b/sdk/interface/ConnectionImpl.cpp index 2a51a11d50..a471022531 100644 --- a/sdk/interface/ConnectionImpl.cpp +++ b/sdk/interface/ConnectionImpl.cpp @@ -190,4 +190,28 @@ ConnectionImpl::CompactCollection(const std::string& collection_name) { return client_proxy_->CompactCollection(collection_name); } +/*******************************New Interface**********************************/ + +Status +ConnectionImpl::CreateHybridCollection(const HMapping& mapping) { + return client_proxy_->CreateHybridCollection(mapping); +} + +Status +ConnectionImpl::InsertEntity(const std::string& collection_name, + const std::string& partition_tag, + HEntity& entities, + std::vector& id_array) { + return client_proxy_->InsertEntity(collection_name, partition_tag, entities, id_array); +} + +Status +ConnectionImpl::HybridSearch(const std::string& collection_name, + const std::vector& partition_list, + BooleanQueryPtr& boolean_query, + const std::string& extra_params, + TopKQueryResult& topk_query_result) { + return client_proxy_->HybridSearch(collection_name, partition_list, boolean_query, extra_params, topk_query_result); +} + } // namespace milvus diff --git a/sdk/interface/ConnectionImpl.h b/sdk/interface/ConnectionImpl.h index 15533b9de6..f843664091 100644 --- a/sdk/interface/ConnectionImpl.h +++ b/sdk/interface/ConnectionImpl.h @@ -124,6 +124,24 @@ class ConnectionImpl : public Connection { Status CompactCollection(const std::string& collection_name) override; + /*******************************New Interface**********************************/ + + Status + CreateHybridCollection(const HMapping& mapping) override ; + + Status + InsertEntity(const std::string& collection_name, + const std::string& partition_tag, + HEntity& entities, + std::vector& id_array) override ; + + Status + HybridSearch(const std::string& collection_name, + const std::vector& partition_list, + BooleanQueryPtr& boolean_query, + const std::string& extra_params, + TopKQueryResult& topk_query_result) override; + private: std::shared_ptr client_proxy_; };