From 110d4d066aa0a7f9e3186f83c7fbad765ab2c46b Mon Sep 17 00:00:00 2001 From: yukun Date: Sat, 23 May 2020 14:25:24 +0800 Subject: [PATCH] TargetEntry implementation (#2391) * Add GetEntitiesByID in DBImpl Signed-off-by: fishpenguin * Add operator overload functions in ConcurrentBitset Signed-off-by: fishpenguin * Add GetEntityByID interface Signed-off-by: fishpenguin * Change format of Attributes Signed-off-by: fishpenguin * Change hybrid search for new rules Signed-off-by: fishpenguin * Fix C++ sdk for new format of hybrid interfaces Signed-off-by: fishpenguin * Fix compile bugs Signed-off-by: fishpenguin * Fix GetEntityByID Signed-off-by: fishpenguin * Fix unittest bugs Signed-off-by: fishpenguin * Fix WebControllerTest:test_hybrid bugs Signed-off-by: fishpenguin * Fix field names bug in HybridSearch Signed-off-by: fishpenguin * Fix HYBRID_SEARCH_TEST caused by const auto& Signed-off-by: fishpenguin * Add ConvertRowToColumnJson in WebRequestHandler Signed-off-by: fishpenguin * Return target entry in WebServer Signed-off-by: fishpenguin * Change ValidateBinaryQuery Signed-off-by: fishpenguin * Add GetEntityByID in WebServer Signed-off-by: fishpenguin * [skip ci]Removed unused code in C++ sdk Signed-off-by: fishpenguin --- core/src/codecs/AttrsFormat.h | 5 + .../src/codecs/default/DefaultAttrsFormat.cpp | 28 + core/src/codecs/default/DefaultAttrsFormat.h | 4 + core/src/db/DB.h | 10 +- core/src/db/DBImpl.cpp | 282 ++- core/src/db/DBImpl.h | 24 +- core/src/db/Types.h | 17 +- core/src/db/engine/ExecutionEngine.h | 10 +- core/src/db/engine/ExecutionEngineImpl.cpp | 179 +- core/src/db/engine/ExecutionEngineImpl.h | 18 +- core/src/grpc/gen-milvus/milvus.grpc.pb.cc | 36 +- core/src/grpc/gen-milvus/milvus.grpc.pb.h | 135 +- core/src/grpc/gen-milvus/milvus.pb.cc | 1634 ++++++++++------- core/src/grpc/gen-milvus/milvus.pb.h | 1022 ++++++----- core/src/grpc/milvus.proto | 45 +- .../faiss/utils/ConcurrentBitset.cpp | 150 ++ .../thirdparty/faiss/utils/ConcurrentBitset.h | 19 +- core/src/query/BinaryQuery.cpp | 5 +- core/src/scheduler/task/SearchTask.cpp | 3 +- core/src/segment/SegmentReader.cpp | 15 + core/src/segment/SegmentReader.h | 3 + core/src/server/delivery/RequestHandler.cpp | 20 +- core/src/server/delivery/RequestHandler.h | 8 +- .../hybrid_request/GetEntityByIDRequest.cpp | 97 + .../hybrid_request/GetEntityByIDRequest.h | 52 + .../hybrid_request/HybridSearchRequest.cpp | 43 +- .../hybrid_request/HybridSearchRequest.h | 14 +- .../server/delivery/request/BaseRequest.cpp | 1 + .../src/server/delivery/request/BaseRequest.h | 5 +- .../server/grpc_impl/GrpcRequestHandler.cpp | 240 ++- .../src/server/grpc_impl/GrpcRequestHandler.h | 11 +- .../web_impl/controller/WebController.hpp | 34 +- .../web_impl/handler/WebRequestHandler.cpp | 206 ++- .../web_impl/handler/WebRequestHandler.h | 6 + core/unittest/db/test_hybrid_db.cpp | 138 +- core/unittest/server/test_rpc.cpp | 22 +- sdk/examples/hybrid/src/ClientTest.cpp | 62 +- sdk/examples/hybrid/src/ClientTest.h | 3 + sdk/examples/utils/Utils.cpp | 17 +- sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc | 36 +- sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h | 135 +- sdk/grpc-gen/gen-milvus/milvus.pb.cc | 1634 ++++++++++------- sdk/grpc-gen/gen-milvus/milvus.pb.h | 1022 ++++++----- sdk/grpc/ClientProxy.cpp | 215 ++- sdk/grpc/ClientProxy.h | 26 +- sdk/grpc/GrpcClient.cpp | 19 +- sdk/grpc/GrpcClient.h | 5 +- sdk/include/GeneralQuery.h | 10 +- sdk/include/MilvusApi.h | 69 +- sdk/interface/ConnectionImpl.cpp | 24 +- sdk/interface/ConnectionImpl.h | 26 +- 51 files changed, 4935 insertions(+), 2909 deletions(-) create mode 100644 core/src/server/delivery/hybrid_request/GetEntityByIDRequest.cpp create mode 100644 core/src/server/delivery/hybrid_request/GetEntityByIDRequest.h diff --git a/core/src/codecs/AttrsFormat.h b/core/src/codecs/AttrsFormat.h index 012493f1..4b0baff3 100644 --- a/core/src/codecs/AttrsFormat.h +++ b/core/src/codecs/AttrsFormat.h @@ -18,6 +18,7 @@ #pragma once #include +#include #include #include "segment/Attrs.h" @@ -36,6 +37,10 @@ class AttrsFormat { virtual void read_uids(const storage::FSHandlerPtr& fs_ptr, std::vector& uids) = 0; + + virtual void + read_attrs(const storage::FSHandlerPtr& fs_ptr, const std::string& field_name, off_t offset, size_t num_bytes, + std::vector& raw_attrs) = 0; }; using AttrsFormatPtr = std::shared_ptr; diff --git a/core/src/codecs/default/DefaultAttrsFormat.cpp b/core/src/codecs/default/DefaultAttrsFormat.cpp index 27c6cbe2..6e3abbfd 100644 --- a/core/src/codecs/default/DefaultAttrsFormat.cpp +++ b/core/src/codecs/default/DefaultAttrsFormat.cpp @@ -185,6 +185,34 @@ DefaultAttrsFormat::write(const milvus::storage::FSHandlerPtr& fs_ptr, const mil } } +void +DefaultAttrsFormat::read_attrs(const milvus::storage::FSHandlerPtr& fs_ptr, const std::string& field_name, off_t offset, + size_t num_bytes, std::vector& raw_attrs) { + 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 (; it != it_end; ++it) { + const auto& path = it->path(); + std::string file_name = path.filename().string(); + if (path.extension().string() == raw_attr_extension_ && + file_name.substr(0, file_name.size() - 3) == field_name) { + size_t nbytes; + read_attrs_internal(fs_ptr, path.string(), offset, num_bytes, raw_attrs, nbytes); + } + } +} + void DefaultAttrsFormat::read_uids(const milvus::storage::FSHandlerPtr& fs_ptr, std::vector& uids) { const std::lock_guard lock(mutex_); diff --git a/core/src/codecs/default/DefaultAttrsFormat.h b/core/src/codecs/default/DefaultAttrsFormat.h index 9d59e53e..ed00531b 100644 --- a/core/src/codecs/default/DefaultAttrsFormat.h +++ b/core/src/codecs/default/DefaultAttrsFormat.h @@ -37,6 +37,10 @@ class DefaultAttrsFormat : public AttrsFormat { void write(const storage::FSHandlerPtr& fs_ptr, const segment::AttrsPtr& attr) override; + void + read_attrs(const storage::FSHandlerPtr& fs_ptr, const std::string& field_name, off_t offset, size_t num_bytes, + std::vector& raw_attrs) override; + void read_uids(const storage::FSHandlerPtr& fs_ptr, std::vector& uids) override; diff --git a/core/src/db/DB.h b/core/src/db/DB.h index c25ab8e6..f7151e93 100644 --- a/core/src/db/DB.h +++ b/core/src/db/DB.h @@ -114,6 +114,10 @@ class DB { GetVectorsByID(const std::string& collection_id, const IDNumbers& id_array, std::vector& vectors) = 0; + virtual Status + GetEntitiesByID(const std::string& collection_id, const IDNumbers& id_array, + std::vector& vectors, std::vector& attrs) = 0; + virtual Status GetVectorIDs(const std::string& collection_id, const std::string& segment_id, IDNumbers& vector_ids) = 0; @@ -165,9 +169,9 @@ class DB { 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; + query::GeneralQueryPtr general_query, std::vector& field_name, + std::unordered_map& attr_type, + engine::QueryResult& result) = 0; }; // DB using DBPtr = std::shared_ptr; diff --git a/core/src/db/DBImpl.cpp b/core/src/db/DBImpl.cpp index 03276c2c..bb7a8d56 100644 --- a/core/src/db/DBImpl.cpp +++ b/core/src/db/DBImpl.cpp @@ -1178,6 +1178,77 @@ DBImpl::GetVectorsByID(const std::string& collection_id, const IDNumbers& id_arr return status; } +Status +DBImpl::GetEntitiesByID(const std::string& collection_id, const milvus::engine::IDNumbers& id_array, + std::vector& vectors, std::vector& attrs) { + if (!initialized_.load(std::memory_order_acquire)) { + return SHUTDOWN_ERROR; + } + + bool has_collection; + auto status = HasCollection(collection_id, has_collection); + if (!has_collection) { + LOG_ENGINE_ERROR_ << "Collection " << collection_id << " does not exist: "; + return Status(DB_NOT_FOUND, "Collection does not exist"); + } + if (!status.ok()) { + return status; + } + + engine::meta::CollectionSchema collection_schema; + engine::meta::hybrid::FieldsSchema fields_schema; + collection_schema.collection_id_ = collection_id; + status = meta_ptr_->DescribeHybridCollection(collection_schema, fields_schema); + if (!status.ok()) { + return status; + } + std::unordered_map attr_type; + for (auto schema : fields_schema.fields_schema_) { + if (schema.field_type_ == (int32_t)engine::meta::hybrid::DataType::VECTOR) { + continue; + } + attr_type.insert(std::make_pair(schema.field_name_, (engine::meta::hybrid::DataType)schema.field_type_)); + } + + meta::FilesHolder files_holder; + std::vector file_types{meta::SegmentSchema::FILE_TYPE::RAW, meta::SegmentSchema::FILE_TYPE::TO_INDEX, + meta::SegmentSchema::FILE_TYPE::BACKUP}; + + status = meta_ptr_->FilesByType(collection_id, file_types, files_holder); + if (!status.ok()) { + std::string err_msg = "Failed to get files for GetEntitiesByID: " + status.message(); + LOG_ENGINE_ERROR_ << err_msg; + return status; + } + + std::vector partition_array; + status = meta_ptr_->ShowPartitions(collection_id, partition_array); + if (!status.ok()) { + std::string err_msg = "Failed to get partitions for GetEntitiesByID: " + status.message(); + LOG_ENGINE_ERROR_ << err_msg; + return status; + } + for (auto& schema : partition_array) { + status = meta_ptr_->FilesByType(schema.collection_id_, file_types, files_holder); + if (!status.ok()) { + std::string err_msg = "Failed to get files for GetEntitiesByID: " + status.message(); + LOG_ENGINE_ERROR_ << err_msg; + return status; + } + } + + if (files_holder.HoldFiles().empty()) { + LOG_ENGINE_DEBUG_ << "No files to get vector by id from"; + return Status(DB_NOT_FOUND, "Collection is empty"); + } + + cache::CpuCacheMgr::GetInstance()->PrintInfo(); + status = GetEntitiesByIdHelper(collection_id, id_array, attr_type, vectors, attrs, files_holder); + cache::CpuCacheMgr::GetInstance()->PrintInfo(); + + return status; +} + Status DBImpl::GetVectorIDs(const std::string& collection_id, const std::string& segment_id, IDNumbers& vector_ids) { if (!initialized_.load(std::memory_order_acquire)) { @@ -1359,6 +1430,166 @@ DBImpl::GetVectorsByIdHelper(const std::string& collection_id, const IDNumbers& return Status::OK(); } +Status +DBImpl::GetEntitiesByIdHelper(const std::string& collection_id, const milvus::engine::IDNumbers& id_array, + std::unordered_map& attr_type, + std::vector& vectors, std::vector& attrs, + milvus::engine::meta::FilesHolder& files_holder) { + // attention: this is a copy, not a reference, since the files_holder.UnMarkFile will change the array internal + milvus::engine::meta::SegmentsSchema files = files_holder.HoldFiles(); + LOG_ENGINE_DEBUG_ << "Getting vector by id in " << files.size() << " files, id count = " << id_array.size(); + + // sometimes not all of id_array can be found, we need to return empty vector for id not found + // for example: + // id_array = [1, -1, 2, -1, 3] + // vectors should return [valid_vector, empty_vector, valid_vector, empty_vector, valid_vector] + // the ID2RAW is to ensure returned vector sequence is consist with id_array + using ID2ATTR = std::map; + using ID2VECTOR = std::map; + ID2ATTR map_id2attr; + ID2VECTOR map_id2vector; + + IDNumbers temp_ids = id_array; + for (auto& file : files) { + // Load bloom filter + std::string segment_dir; + engine::utils::GetParentPath(file.location_, segment_dir); + segment::SegmentReader segment_reader(segment_dir); + segment::IdBloomFilterPtr id_bloom_filter_ptr; + segment_reader.LoadBloomFilter(id_bloom_filter_ptr); + + for (IDNumbers::iterator it = temp_ids.begin(); it != temp_ids.end();) { + int64_t vector_id = *it; + // each id must has a VectorsData + // if vector not found for an id, its VectorsData's vector_count = 0, else 1 + AttrsData& attr_ref = map_id2attr[vector_id]; + VectorsData& vector_ref = map_id2vector[vector_id]; + + // Check if the id is present in bloom filter. + if (id_bloom_filter_ptr->Check(vector_id)) { + // Load uids and check if the id is indeed present. If yes, find its offset. + std::vector uids; + auto status = segment_reader.LoadUids(uids); + if (!status.ok()) { + return status; + } + + auto found = std::find(uids.begin(), uids.end(), vector_id); + if (found != uids.end()) { + auto offset = std::distance(uids.begin(), found); + + // Check whether the id has been deleted + segment::DeletedDocsPtr deleted_docs_ptr; + status = segment_reader.LoadDeletedDocs(deleted_docs_ptr); + if (!status.ok()) { + LOG_ENGINE_ERROR_ << status.message(); + return status; + } + auto& deleted_docs = deleted_docs_ptr->GetDeletedDocs(); + + auto deleted = std::find(deleted_docs.begin(), deleted_docs.end(), offset); + if (deleted == deleted_docs.end()) { + // Load raw vector + bool is_binary = utils::IsBinaryMetricType(file.metric_type_); + size_t single_vector_bytes = is_binary ? file.dimension_ / 8 : file.dimension_ * sizeof(float); + std::vector raw_vector; + status = + segment_reader.LoadVectors(offset * single_vector_bytes, single_vector_bytes, raw_vector); + if (!status.ok()) { + LOG_ENGINE_ERROR_ << status.message(); + return status; + } + + std::unordered_map> raw_attrs; + auto attr_it = attr_type.begin(); + for (; attr_it != attr_type.end(); attr_it++) { + size_t num_bytes; + switch (attr_it->second) { + case engine::meta::hybrid::DataType::INT8: { + num_bytes = 1; + break; + } + case engine::meta::hybrid::DataType::INT16: { + num_bytes = 2; + break; + } + case engine::meta::hybrid::DataType::INT32: { + num_bytes = 4; + break; + } + case engine::meta::hybrid::DataType::INT64: { + num_bytes = 8; + break; + } + case engine::meta::hybrid::DataType::FLOAT: { + num_bytes = 4; + break; + } + case engine::meta::hybrid::DataType::DOUBLE: { + num_bytes = 8; + break; + } + default: { + std::string msg = "Field type of " + attr_it->first + " is wrong"; + return Status{DB_ERROR, msg}; + } + } + std::vector raw_attr; + status = segment_reader.LoadAttrs(attr_it->first, offset * num_bytes, num_bytes, raw_attr); + if (!status.ok()) { + LOG_ENGINE_ERROR_ << status.message(); + return status; + } + raw_attrs.insert(std::make_pair(attr_it->first, raw_attr)); + } + + vector_ref.vector_count_ = 1; + if (is_binary) { + vector_ref.binary_data_.swap(raw_vector); + } else { + std::vector float_vector; + float_vector.resize(file.dimension_); + memcpy(float_vector.data(), raw_vector.data(), single_vector_bytes); + vector_ref.float_data_.swap(float_vector); + } + + attr_ref.attr_count_ = 1; + attr_ref.attr_data_ = raw_attrs; + attr_ref.attr_type_ = attr_type; + temp_ids.erase(it); + continue; + } + } + } + it++; + } + + // unmark file, allow the file to be deleted + files_holder.UnmarkFile(file); + } + + for (auto id : id_array) { + VectorsData& vector_ref = map_id2vector[id]; + + VectorsData data; + data.vector_count_ = vector_ref.vector_count_; + if (data.vector_count_ > 0) { + data.float_data_ = vector_ref.float_data_; // copy data since there could be duplicated id + data.binary_data_ = vector_ref.binary_data_; // copy data since there could be duplicated id + } + vectors.emplace_back(data); + + attrs.emplace_back(map_id2attr[id]); + } + + if (vectors.empty()) { + std::string msg = "Vectors not found in collection " + collection_id; + LOG_ENGINE_DEBUG_ << msg; + } + + return Status::OK(); +} + Status DBImpl::CreateIndex(const std::shared_ptr& context, const std::string& collection_id, const CollectionIndex& index) { @@ -1554,8 +1785,9 @@ 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) { + std::vector& field_names, + std::unordered_map& attr_type, + engine::QueryResult& result) { auto query_ctx = context->Child("Query"); if (!initialized_.load(std::memory_order_acquire)) { @@ -1605,8 +1837,8 @@ DBImpl::HybridQuery(const std::shared_ptr& context, const std:: } cache::CpuCacheMgr::GetInstance()->PrintInfo(); // print cache info before query - status = HybridQueryAsync(query_ctx, collection_id, files_holder, hybrid_search_context, general_query, attr_type, - nq, result_ids, result_distances); + status = HybridQueryAsync(query_ctx, collection_id, files_holder, hybrid_search_context, general_query, field_names, + attr_type, result); if (!status.ok()) { return status; } @@ -1766,11 +1998,11 @@ DBImpl::QueryAsync(const std::shared_ptr& context, meta::FilesH } Status -DBImpl::HybridQueryAsync(const std::shared_ptr& context, const std::string& table_id, +DBImpl::HybridQueryAsync(const std::shared_ptr& context, const std::string& collection_id, meta::FilesHolder& files_holder, context::HybridSearchContextPtr hybrid_search_context, - query::GeneralQueryPtr general_query, - std::unordered_map& attr_type, uint64_t& nq, - ResultIds& result_ids, ResultDistances& result_distances) { + query::GeneralQueryPtr general_query, std::vector& field_names, + std::unordered_map& attr_type, + engine::QueryResult& result) { auto query_async_ctx = context->Child("Query Async"); #if 0 @@ -1789,10 +2021,8 @@ DBImpl::HybridQueryAsync(const std::shared_ptr& context, const search::TaskInst::GetInstance().load_cv().notify_one(); hybrid_search_context->tasks_.emplace_back(task); } - #endif - //#if 0 TimeRecorder rc(""); // step 1: construct search job @@ -1816,13 +2046,37 @@ DBImpl::HybridQueryAsync(const std::shared_ptr& context, const } // step 3: construct results - nq = job->vector_count(); - result_ids = job->GetResultIds(); - result_distances = job->GetResultDistances(); + result.row_num_ = job->vector_count(); + result.result_ids_ = job->GetResultIds(); + result.result_distances_ = job->GetResultDistances(); + + // step 4: get entities by result ids + auto status = GetEntitiesByID(collection_id, result.result_ids_, result.vectors_, result.attrs_); + if (!status.ok()) { + query_async_ctx->GetTraceContext()->GetSpan()->Finish(); + return status; + } + + // step 5: filter entities by field names + std::vector filter_attrs; + for (auto attr : result.attrs_) { + AttrsData attrs_data; + attrs_data.attr_type_ = attr.attr_type_; + attrs_data.attr_count_ = attr.attr_count_; + attrs_data.id_array_ = attr.id_array_; + for (auto& name : field_names) { + if (attr.attr_data_.find(name) != attr.attr_data_.end()) { + attrs_data.attr_data_.insert(std::make_pair(name, attr.attr_data_.at(name))); + } + } + filter_attrs.emplace_back(attrs_data); + } + + result.attrs_ = filter_attrs; + rc.ElapseFromBegin("Engine query totally cost"); query_async_ctx->GetTraceContext()->GetSpan()->Finish(); - //#endif return Status::OK(); } diff --git a/core/src/db/DBImpl.h b/core/src/db/DBImpl.h index 7a3a2032..fda11aed 100644 --- a/core/src/db/DBImpl.h +++ b/core/src/db/DBImpl.h @@ -125,6 +125,10 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi GetVectorsByID(const std::string& collection_id, const IDNumbers& id_array, std::vector& vectors) override; + Status + GetEntitiesByID(const std::string& collection_id, const IDNumbers& id_array, + std::vector& vectors, std::vector& attrs) override; + Status GetVectorIDs(const std::string& collection_id, const std::string& segment_id, IDNumbers& vector_ids) override; @@ -157,9 +161,9 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi 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; + query::GeneralQueryPtr general_query, std::vector& field_names, + std::unordered_map& attr_type, + engine::QueryResult& result) override; Status QueryByIDs(const std::shared_ptr& context, const std::string& collection_id, @@ -193,16 +197,22 @@ class DBImpl : public DB, public server::CacheConfigHandler, public server::Engi ResultDistances& result_distances); Status - HybridQueryAsync(const std::shared_ptr& context, const std::string& table_id, + HybridQueryAsync(const std::shared_ptr& context, const std::string& collection_id, meta::FilesHolder& files_holder, context::HybridSearchContextPtr hybrid_search_context, - query::GeneralQueryPtr general_query, - std::unordered_map& attr_type, uint64_t& nq, - ResultIds& result_ids, ResultDistances& result_distances); + query::GeneralQueryPtr general_query, std::vector& field_names, + std::unordered_map& attr_type, + engine::QueryResult& result); Status GetVectorsByIdHelper(const std::string& collection_id, const IDNumbers& id_array, std::vector& vectors, meta::FilesHolder& files_holder); + Status + GetEntitiesByIdHelper(const std::string& collection_id, const IDNumbers& id_array, + std::unordered_map& attr_type, + std::vector& vectors, std::vector& attrs, + meta::FilesHolder& files_holder); + void InternalFlush(const std::string& collection_id = ""); diff --git a/core/src/db/Types.h b/core/src/db/Types.h index 6e212f6b..0f6336f3 100644 --- a/core/src/db/Types.h +++ b/core/src/db/Types.h @@ -22,6 +22,7 @@ #include #include "db/engine/ExecutionEngine.h" +#include "db/meta/MetaTypes.h" #include "segment/Types.h" #include "utils/Json.h" @@ -51,11 +52,25 @@ struct VectorsData { struct Entity { uint64_t entity_count_ = 0; std::vector attr_value_; - std::unordered_map> attr_data_; std::unordered_map vector_data_; IDNumbers id_array_; }; +struct AttrsData { + uint64_t attr_count_ = 0; + std::unordered_map attr_type_; + std::unordered_map> attr_data_; + IDNumbers id_array_; +}; + +struct QueryResult { + uint64_t row_num_; + engine::ResultIds result_ids_; + engine::ResultDistances result_distances_; + std::vector vectors_; + std::vector attrs_; +}; + using File2ErrArray = std::map>; using Table2FileErr = std::map; diff --git a/core/src/db/engine/ExecutionEngine.h b/core/src/db/engine/ExecutionEngine.h index d2c34c0a..219e6f2b 100644 --- a/core/src/db/engine/ExecutionEngine.h +++ b/core/src/db/engine/ExecutionEngine.h @@ -116,9 +116,13 @@ class ExecutionEngine { 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; + ExecBinaryQuery(query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr& bitset, + std::unordered_map& attr_type, + milvus::query::VectorQueryPtr& vector_query) = 0; + + virtual Status + HybridSearch(query::GeneralQueryPtr general_query, std::unordered_map& attr_type, + uint64_t& nq, uint64_t& topk, std::vector& distances, std::vector& search_ids) = 0; virtual Status Search(int64_t n, const float* data, int64_t k, const milvus::json& extra_params, float* distances, int64_t* labels, diff --git a/core/src/db/engine/ExecutionEngineImpl.cpp b/core/src/db/engine/ExecutionEngineImpl.cpp index 34d73533..ca4e1754 100644 --- a/core/src/db/engine/ExecutionEngineImpl.cpp +++ b/core/src/db/engine/ExecutionEngineImpl.cpp @@ -733,63 +733,52 @@ MapAndCopyResult(const knowhere::DatasetPtr& dataset, const std::vector void -ProcessRangeQuery(std::vector data, T value, query::CompareOperator type, faiss::ConcurrentBitsetPtr& bitset) { +ExecutionEngineImpl::ProcessRangeQuery(std::vector data, T value, query::CompareOperator type, + 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); - } + if (data[i] < value) { + 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); - } + if (data[i] <= value) { + 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); - } + if (data[i] > value) { + 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); - } + if (data[i] >= value) { + 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); - } + if (data[i] == value) { + 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); - } + if (data[i] != value) { + bitset->set(i); } } break; @@ -798,23 +787,90 @@ ProcessRangeQuery(std::vector data, T value, query::CompareOperator type, fai } 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_); +ExecutionEngineImpl::HybridSearch(milvus::query::GeneralQueryPtr general_query, + std::unordered_map& attr_type, uint64_t& nq, uint64_t& topk, + std::vector& distances, std::vector& search_ids) { + faiss::ConcurrentBitsetPtr bitset; + milvus::query::VectorQueryPtr vector_query; + auto status = ExecBinaryQuery(general_query, bitset, attr_type, vector_query); + + // Do search + faiss::ConcurrentBitsetPtr list; + list = index_->GetBlacklist(); + // Do AND + for (uint64_t i = 0; i < vector_count_; ++i) { + if (list->test(i) && !bitset->test(i)) { + list->clear(i); + } + } + index_->SetBlacklist(list); + topk = vector_query->topk; + nq = vector_query->query_vector.float_data.size() / dim_; + + distances.resize(nq * topk); + search_ids.resize(nq * topk); + + status = Search(nq, vector_query->query_vector.float_data.data(), topk, vector_query->extra_params, + distances.data(), search_ids.data()); + if (!status.ok()) { + return status; } + return Status::OK(); +} + +Status +ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr& bitset, + std::unordered_map& attr_type, + milvus::query::VectorQueryPtr& vector_query) { if (general_query->leaf == nullptr) { Status status; + faiss::ConcurrentBitsetPtr left_bitset, right_bitset; if (general_query->bin->left_query != nullptr) { - status = ExecBinaryQuery(general_query->bin->left_query, bitset, attr_type, nq, topk, distances, labels); + status = ExecBinaryQuery(general_query->bin->left_query, left_bitset, attr_type, vector_query); + if (!status.ok()) { + return status; + } } if (general_query->bin->right_query != nullptr) { - status = ExecBinaryQuery(general_query->bin->right_query, bitset, attr_type, nq, topk, distances, labels); + status = ExecBinaryQuery(general_query->bin->right_query, right_bitset, attr_type, vector_query); + if (!status.ok()) { + return status; + } + } + + if (left_bitset == nullptr || right_bitset == nullptr) { + bitset = left_bitset != nullptr ? left_bitset : right_bitset; + } else { + switch (general_query->bin->relation) { + case milvus::query::QueryRelation::AND: + case milvus::query::QueryRelation::R1: { + bitset = (*left_bitset) & right_bitset; + break; + } + case milvus::query::QueryRelation::OR: + case milvus::query::QueryRelation::R2: + case milvus::query::QueryRelation::R3: { + bitset = (*left_bitset) | right_bitset; + break; + } + case milvus::query::QueryRelation::R4: { + for (uint64_t i = 0; i < vector_count_; ++i) { + if (left_bitset->test(i) && !right_bitset->test(i)) { + bitset->set(i); + } + } + break; + } + default: { + std::string msg = "Invalid QueryRelation in RangeQuery"; + return Status{SERVER_INVALID_ARGUMENT, msg}; + } + } } return status; } else { + bitset = std::make_shared(vector_count_); if (general_query->leaf->term_query != nullptr) { // process attrs_data auto field_name = general_query->leaf->term_query->field_name; @@ -841,10 +897,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -868,10 +922,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -896,10 +948,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -924,10 +974,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -952,10 +1000,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -980,10 +1026,8 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer break; } } - if (!value_in_term) { - if (!bitset->test(i)) { - bitset->set(i); - } + if (value_in_term) { + bitset->set(i); } } break; @@ -1056,25 +1100,10 @@ ExecutionEngineImpl::ExecBinaryQuery(milvus::query::GeneralQueryPtr general_quer 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()); + // skip vector query + vector_query = general_query->leaf->vector_query; + bitset = nullptr; + return Status::OK(); } } } diff --git a/core/src/db/engine/ExecutionEngineImpl.h b/core/src/db/engine/ExecutionEngineImpl.h index 3add035a..a1f31607 100644 --- a/core/src/db/engine/ExecutionEngineImpl.h +++ b/core/src/db/engine/ExecutionEngineImpl.h @@ -70,9 +70,14 @@ class ExecutionEngineImpl : public ExecutionEngine { 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; + ExecBinaryQuery(query::GeneralQueryPtr general_query, faiss::ConcurrentBitsetPtr& bitset, + std::unordered_map& attr_type, + milvus::query::VectorQueryPtr& vector_query) override; + + Status + HybridSearch(query::GeneralQueryPtr general_query, std::unordered_map& attr_type, + uint64_t& nq, uint64_t& topk, std::vector& distances, + std::vector& search_ids) override; Status Search(int64_t n, const float* data, int64_t k, const milvus::json& extra_params, float* distances, int64_t* labels, @@ -113,6 +118,10 @@ class ExecutionEngineImpl : public ExecutionEngine { knowhere::VecIndexPtr Load(const std::string& location); + template + void + ProcessRangeQuery(std::vector data, T value, query::CompareOperator type, faiss::ConcurrentBitsetPtr& bitset); + void HybridLoad() const; @@ -124,10 +133,9 @@ 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_; + std::vector entity_ids_; int64_t vector_count_; int64_t dim_; diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc index 29756467..9dde7b29 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc @@ -1061,32 +1061,32 @@ void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext 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) { +::grpc::Status MilvusService::Stub::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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::HQueryResult>* MilvusService::Stub::AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HQueryResult>::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::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HQueryResult>::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) { @@ -1117,11 +1117,11 @@ void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::Cli 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) { +::grpc::Status MilvusService::Stub::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); } @@ -1129,7 +1129,7 @@ void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContex ::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) { +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); } @@ -1137,11 +1137,11 @@ void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContex ::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) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, false); } @@ -1375,7 +1375,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearch), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[35], @@ -1385,7 +1385,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>( std::mem_fn(&MilvusService::Service::GetEntityByID), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[37], @@ -1640,7 +1640,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response) { +::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response) { (void) context; (void) request; (void) response; @@ -1654,7 +1654,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response) { +::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response) { (void) context; (void) request; (void) response; diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.h b/core/src/grpc/gen-milvus/milvus.grpc.pb.h index 969758d7..c90fa1ba 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.h +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.h @@ -447,13 +447,12 @@ class MilvusService final { 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)); + virtual ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>>(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)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>>(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) { @@ -462,11 +461,11 @@ class MilvusService final { 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) { + virtual ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::milvus::grpc::HEntity* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -784,18 +783,17 @@ class MilvusService final { 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 HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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 ::milvus::grpc::VectorsIdentity* 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 ::milvus::grpc::VectorsIdentity* 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; @@ -876,12 +874,12 @@ class MilvusService final { 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::HQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>* 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::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1128,12 +1126,12 @@ class MilvusService final { 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)); + ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>>(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)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>>(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) { @@ -1142,11 +1140,11 @@ class MilvusService final { 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) { + ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::milvus::grpc::HEntity* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1302,17 +1300,17 @@ class MilvusService final { 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 HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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 ::milvus::grpc::VectorsIdentity* 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 ::milvus::grpc::VectorsIdentity* 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; @@ -1401,12 +1399,12 @@ class MilvusService final { ::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::HQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>* 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::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1653,10 +1651,9 @@ class MilvusService final { // ///////////////////////////////////////////////////////////////// // 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 HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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 GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* 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); }; @@ -2352,11 +2349,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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) { + void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HQueryResult>* 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); } }; @@ -2392,11 +2389,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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) { + void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::VectorsIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -3502,17 +3499,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_HybridSearch() { ::grpc::Service::experimental().MarkMethodCallback(34, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, - ::milvus::grpc::TopKQueryResult* response, + ::milvus::grpc::HQueryResult* 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::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>*>( ::grpc::Service::experimental().GetHandler(34)) ->SetMessageAllocator(allocator); } @@ -3520,11 +3517,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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, "")); } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_HybridSearchInSegments : public BaseClass { @@ -3564,17 +3561,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_GetEntityByID() { ::grpc::Service::experimental().MarkMethodCallback(36, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::HEntityIdentity* request, + const ::milvus::grpc::VectorsIdentity* 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::experimental::MessageAllocator< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>*>( ::grpc::Service::experimental().GetHandler(36)) ->SetMessageAllocator(allocator); } @@ -3582,11 +3579,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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, "")); } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_GetEntityIDs : public BaseClass { @@ -4241,7 +4238,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -4275,7 +4272,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5006,7 +5003,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5046,7 +5043,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5963,7 +5960,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -6013,7 +6010,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -6756,18 +6753,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_HybridSearch() { ::grpc::Service::MarkMethodStreamed(34, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>(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 { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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; + virtual ::grpc::Status StreamedHybridSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchParam,::milvus::grpc::HQueryResult>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HybridSearchInSegments : public BaseClass { @@ -6796,18 +6793,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_GetEntityByID() { ::grpc::Service::MarkMethodStreamed(36, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::VectorsIdentity, ::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 { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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; + virtual ::grpc::Status StreamedGetEntityByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::VectorsIdentity,::milvus::grpc::HEntity>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetEntityIDs : public BaseClass { diff --git a/core/src/grpc/gen-milvus/milvus.pb.cc b/core/src/grpc/gen-milvus/milvus.pb.cc index 289aea93..b5e05c1a 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.pb.cc @@ -15,12 +15,12 @@ #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<2> scc_info_HEntity_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; @@ -30,7 +30,7 @@ extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal 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<1> scc_info_VectorFieldRecord_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto; namespace milvus { namespace grpc { @@ -144,20 +144,18 @@ class FieldParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _FieldParam_default_instance_; -class VectorFieldValueDefaultTypeInternal { +class VectorFieldRecordDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _VectorFieldValue_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldRecord_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_; + const ::milvus::grpc::VectorFieldRecord* vector_value_; } _FieldValue_default_instance_; class MappingDefaultTypeInternal { public: @@ -454,7 +452,7 @@ static void InitDefaultsscc_info_FieldValue_milvus_2eproto() { ::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,}}; + &scc_info_VectorFieldRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_FlushParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -509,10 +507,11 @@ static void InitDefaultsscc_info_HEntity_milvus_2eproto() { ::milvus::grpc::HEntity::InitAsDefaultInstance(); } -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HEntity_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HEntity_milvus_2eproto}, { +::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_FieldValue_milvus_2eproto.base,}}; + &scc_info_AttrRecord_milvus_2eproto.base, + &scc_info_VectorFieldRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_HEntityIDs_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -600,10 +599,11 @@ static void InitDefaultsscc_info_HQueryResult_milvus_2eproto() { ::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}, { +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HQueryResult_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_HQueryResult_milvus_2eproto}, { &scc_info_Status_status_2eproto.base, - &scc_info_HEntity_milvus_2eproto.base,}}; + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; static void InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -878,19 +878,19 @@ static void InitDefaultsscc_info_VectorFieldParam_milvus_2eproto() { ::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() { +static void InitDefaultsscc_info_VectorFieldRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; { - void* ptr = &::milvus::grpc::_VectorFieldValue_default_instance_; - new (ptr) ::milvus::grpc::VectorFieldValue(); + void* ptr = &::milvus::grpc::_VectorFieldRecord_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldRecord(); ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); } - ::milvus::grpc::VectorFieldValue::InitAsDefaultInstance(); + ::milvus::grpc::VectorFieldRecord::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}, { +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldRecord_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorFieldRecord_milvus_2eproto}, { &scc_info_RowRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_VectorIds_milvus_2eproto() { @@ -1165,19 +1165,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT 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_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, 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_), @@ -1205,7 +1203,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~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, int_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, double_value_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, value_num_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, boost_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, extra_params_), @@ -1273,7 +1272,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, int_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, double_value_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, _internal_metadata_), ~0u, // no _extensions_ @@ -1282,19 +1282,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT 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, data_types_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, row_num_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, result_values_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, attr_data_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, vector_data_), ~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, entity_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, row_num_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, score_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, distance_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, extra_params_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, _internal_metadata_), ~0u, // no _extensions_ @@ -1302,7 +1304,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~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_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entity_id_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, extra_params_), ~0u, // no _has_bits_ @@ -1371,27 +1373,27 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 182, -1, sizeof(::milvus::grpc::VectorFieldParam)}, { 188, -1, sizeof(::milvus::grpc::FieldType)}, { 196, -1, sizeof(::milvus::grpc::FieldParam)}, - { 205, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 205, -1, sizeof(::milvus::grpc::VectorFieldRecord)}, { 211, -1, sizeof(::milvus::grpc::FieldValue)}, - { 224, -1, sizeof(::milvus::grpc::Mapping)}, - { 233, -1, sizeof(::milvus::grpc::MappingList)}, - { 240, -1, sizeof(::milvus::grpc::TermQuery)}, - { 250, -1, sizeof(::milvus::grpc::CompareExpr)}, - { 257, -1, sizeof(::milvus::grpc::RangeQuery)}, - { 266, -1, sizeof(::milvus::grpc::VectorQuery)}, - { 276, -1, sizeof(::milvus::grpc::BooleanQuery)}, - { 283, -1, sizeof(::milvus::grpc::GeneralQuery)}, - { 293, -1, sizeof(::milvus::grpc::HSearchParam)}, - { 302, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, - { 309, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 222, -1, sizeof(::milvus::grpc::Mapping)}, + { 231, -1, sizeof(::milvus::grpc::MappingList)}, + { 238, -1, sizeof(::milvus::grpc::TermQuery)}, + { 249, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 256, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 265, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 275, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 282, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 292, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 301, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 308, -1, sizeof(::milvus::grpc::AttrRecord)}, { 315, -1, sizeof(::milvus::grpc::HEntity)}, - { 326, -1, sizeof(::milvus::grpc::HQueryResult)}, - { 336, -1, sizeof(::milvus::grpc::HInsertParam)}, - { 346, -1, sizeof(::milvus::grpc::HEntityIdentity)}, - { 353, -1, sizeof(::milvus::grpc::HEntityIDs)}, - { 360, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, - { 367, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, - { 374, -1, sizeof(::milvus::grpc::HIndexParam)}, + { 327, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 338, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 348, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 355, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 362, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 369, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 376, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1422,7 +1424,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = 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::_VectorFieldRecord_default_instance_), reinterpret_cast(&::milvus::grpc::_FieldValue_default_instance_), reinterpret_cast(&::milvus::grpc::_Mapping_default_instance_), reinterpret_cast(&::milvus::grpc::_MappingList_default_instance_), @@ -1508,150 +1510,153 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "amH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022" "\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grp" "c.FieldType\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"9\n\020VectorFieldValue" - "\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord\"" - "\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n" - "\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(" - "\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014string_va" - "lue\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vec" - "tor_value\030\007 \001(\0132\035.milvus.grpc.VectorFiel" - "dValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030" - "\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollection" - "_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fi" - "elds\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013M" - "appingList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" - ".Status\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.g" - "rpc.Mapping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030" - "\001 \001(\t\022\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003" - "\022\r\n\005boost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031." - "milvus.grpc.KeyValuePair\"N\n\013CompareExpr\022" - ".\n\010operator\030\001 \001(\0162\034.milvus.grpc.CompareO" - "perator\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022" - "\022\n\nfield_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.m" - "ilvus.grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n" - "\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyVal" - "uePair\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001" - "(\t\022\023\n\013query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\013" - "2\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/" - "\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyVa" - "luePair\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022" - ".milvus.grpc.Occur\0220\n\rgeneral_query\030\002 \003(" - "\0132\031.milvus.grpc.GeneralQuery\"\333\001\n\014General" - "Query\0222\n\rboolean_query\030\001 \001(\0132\031.milvus.gr" - "pc.BooleanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026." - "milvus.grpc.TermQueryH\000\022.\n\013range_query\030\003" - " \001(\0132\027.milvus.grpc.RangeQueryH\000\0220\n\014vecto" - "r_query\030\004 \001(\0132\030.milvus.grpc.VectorQueryH" - "\000B\007\n\005query\"\247\001\n\014HSearchParam\022\027\n\017collectio" - "n_name\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(" - "\t\0220\n\rgeneral_query\030\003 \001(\0132\031.milvus.grpc.G" - "eneralQuery\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"c\n\026HSearchInSegment" - "sParam\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014sear" - "ch_param\030\002 \001(\0132\031.milvus.grpc.HSearchPara" - "m\"\033\n\nAttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEnti" - "ty\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\021\n\tentity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022" - "\024\n\014attr_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022." - "\n\rresult_values\030\006 \003(\0132\027.milvus.grpc.Fiel" - "dValue\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132" - "\023.milvus.grpc.Status\022&\n\010entities\030\002 \003(\0132\024" - ".milvus.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n" - "\005score\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInse" - "rtParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpart" - "ition_tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milv" - "us.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003(\003" - "\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Key" - "ValuePair\"6\n\017HEntityIdentity\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022" - "#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017" - "entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsPa" - "ram\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_" - "name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collec" - "tion_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HI" - "ndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex" - "_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004NUL" - "L\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005I" - "NT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022" - "\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n" - "\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020" - "\002\022\006\n\002GT\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007I" - "NVALID\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_N" - "OT\020\0032\324\026\n\rMilvusService\022H\n\020CreateCollecti" - "on\022\035.milvus.grpc.CollectionSchema\032\023.milv" - "us.grpc.Status\"\000\022F\n\rHasCollection\022\033.milv" - "us.grpc.CollectionName\032\026.milvus.grpc.Boo" - "lReply\"\000\022R\n\022DescribeCollection\022\033.milvus." - "grpc.CollectionName\032\035.milvus.grpc.Collec" - "tionSchema\"\000\022Q\n\017CountCollection\022\033.milvus" - ".grpc.CollectionName\032\037.milvus.grpc.Colle" - "ctionRowCount\"\000\022J\n\017ShowCollections\022\024.mil" - "vus.grpc.Command\032\037.milvus.grpc.Collectio" - "nNameList\"\000\022P\n\022ShowCollectionInfo\022\033.milv" - "us.grpc.CollectionName\032\033.milvus.grpc.Col" - "lectionInfo\"\000\022D\n\016DropCollection\022\033.milvus" - ".grpc.CollectionName\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexPa" - "ram\032\023.milvus.grpc.Status\"\000\022G\n\rDescribeIn" - "dex\022\033.milvus.grpc.CollectionName\032\027.milvu" - "s.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022E\n\017CreatePartition\022\033.milvus.grpc.Pa" - "rtitionParam\032\023.milvus.grpc.Status\"\000\022E\n\014H" - "asPartition\022\033.milvus.grpc.PartitionParam" - "\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPartit" - "ions\022\033.milvus.grpc.CollectionName\032\032.milv" - "us.grpc.PartitionList\"\000\022C\n\rDropPartition" - "\022\033.milvus.grpc.PartitionParam\032\023.milvus.g" - "rpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.Ins" - "ertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016Ge" - "tVectorsByID\022\034.milvus.grpc.VectorsIdenti" - "ty\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetVec" - "torIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026" - ".milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.mil" - "vus.grpc.SearchParam\032\034.milvus.grpc.TopKQ" - "ueryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc" - ".SearchByIDParam\032\034.milvus.grpc.TopKQuery" - "Result\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc." - "SearchInFilesParam\032\034.milvus.grpc.TopKQue" - "ryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032" - "\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteByI" - "D\022\034.milvus.grpc.DeleteByIDParam\032\023.milvus" - ".grpc.Status\"\000\022G\n\021PreloadCollection\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPara" - "m\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\022E\n\026CreateHybridCollection\022\024.milv" - "us.grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L" - "\n\023HasHybridCollection\022\033.milvus.grpc.Coll" - "ectionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024" - "DropHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\023.milvus.grpc.Status\"\000\022O\n\030Desc" - "ribeHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Cou" - "ntHybridCollection\022\033.milvus.grpc.Collect" - "ionName\032\037.milvus.grpc.CollectionRowCount" - "\"\000\022I\n\025ShowHybridCollections\022\024.milvus.grp" - "c.Command\032\030.milvus.grpc.MappingList\"\000\022V\n" - "\030ShowHybridCollectionInfo\022\033.milvus.grpc." - "CollectionName\032\033.milvus.grpc.CollectionI" - "nfo\"\000\022M\n\027PreloadHybridCollection\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInse" - "rtParam\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hy" - "bridSearch\022\031.milvus.grpc.HSearchParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\022]\n\026HybridS" - "earchInSegments\022#.milvus.grpc.HSearchInS" - "egmentsParam\032\034.milvus.grpc.TopKQueryResu" - "lt\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEnt" - "ityIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014G" - "etEntityIDs\022\037.milvus.grpc.HGetEntityIDsP" - "aram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delet" - "eEntitiesByID\022\035.milvus.grpc.HDeleteByIDP" - "aram\032\023.milvus.grpc.Status\"\000b\006proto3" + "us.grpc.KeyValuePair\":\n\021VectorFieldRecor" + "d\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord" + "\"\252\001\n\nFieldValue\022\025\n\013int64_value\030\001 \001(\003H\000\022\026" + "\n\014double_value\030\002 \001(\001H\000\022\026\n\014string_value\030\003" + " \001(\tH\000\022\024\n\nbool_value\030\004 \001(\010H\000\0226\n\014vector_v" + "alue\030\005 \001(\0132\036.milvus.grpc.VectorFieldReco" + "rdH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030\001 \001(" + "\0132\023.milvus.grpc.Status\022\025\n\rcollection_id\030" + "\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fields" + "\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013Mappi" + "ngList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Sta" + "tus\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.grpc." + "Mapping\"\233\001\n\tTermQuery\022\022\n\nfield_name\030\001 \001(" + "\t\022\021\n\tint_value\030\002 \003(\003\022\024\n\014double_value\030\003 \003" + "(\001\022\021\n\tvalue_num\030\004 \001(\003\022\r\n\005boost\030\005 \001(\002\022/\n\014" + "extra_params\030\006 \003(\0132\031.milvus.grpc.KeyValu" + "ePair\"N\n\013CompareExpr\022.\n\010operator\030\001 \001(\0162\034" + ".milvus.grpc.CompareOperator\022\017\n\007operand\030" + "\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfield_name\030\001 \001(\t" + "\022)\n\007operand\030\002 \003(\0132\030.milvus.grpc.CompareE" + "xpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra_params\030\004 \003(\013" + "2\031.milvus.grpc.KeyValuePair\"\236\001\n\013VectorQu" + "ery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013query_boost\030\002" + " \001(\002\022\'\n\007records\030\003 \003(\0132\026.milvus.grpc.RowR" + "ecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extra_params\030\005 \003(" + "\0132\031.milvus.grpc.KeyValuePair\"c\n\014BooleanQ" + "uery\022!\n\005occur\030\001 \001(\0162\022.milvus.grpc.Occur\022" + "0\n\rgeneral_query\030\002 \003(\0132\031.milvus.grpc.Gen" + "eralQuery\"\333\001\n\014GeneralQuery\0222\n\rboolean_qu" + "ery\030\001 \001(\0132\031.milvus.grpc.BooleanQueryH\000\022," + "\n\nterm_query\030\002 \001(\0132\026.milvus.grpc.TermQue" + "ryH\000\022.\n\013range_query\030\003 \001(\0132\027.milvus.grpc." + "RangeQueryH\000\0220\n\014vector_query\030\004 \001(\0132\030.mil" + "vus.grpc.VectorQueryH\000B\007\n\005query\"\247\001\n\014HSea" + "rchParam\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023par" + "tition_tag_array\030\002 \003(\t\0220\n\rgeneral_query\030" + "\003 \001(\0132\031.milvus.grpc.GeneralQuery\022/\n\014extr" + "a_params\030\004 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"c\n\026HSearchInSegmentsParam\022\030\n\020segment_i" + "d_array\030\001 \003(\t\022/\n\014search_param\030\002 \001(\0132\031.mi" + "lvus.grpc.HSearchParam\"5\n\nAttrRecord\022\021\n\t" + "int_value\030\001 \003(\003\022\024\n\014double_value\030\002 \003(\001\"\363\001" + "\n\007HEntity\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." + "Status\022\021\n\tentity_id\030\002 \003(\003\022\023\n\013field_names" + "\030\003 \003(\t\022)\n\ndata_types\030\004 \003(\0162\025.milvus.grpc" + ".DataType\022\017\n\007row_num\030\005 \001(\003\022*\n\tattr_data\030" + "\006 \003(\0132\027.milvus.grpc.AttrRecord\0223\n\013vector" + "_data\030\007 \003(\0132\036.milvus.grpc.VectorFieldRec" + "ord\"\274\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.m" + "ilvus.grpc.Status\022$\n\006entity\030\002 \001(\0132\024.milv" + "us.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005scor" + "e\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\022/\n\014extra_param" + "s\030\006 \003(\0132\031.milvus.grpc.KeyValuePair\"\256\001\n\014H" + "InsertParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\r" + "partition_tag\030\002 \001(\t\022$\n\006entity\030\003 \001(\0132\024.mi" + "lvus.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003" + "(\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.K" + "eyValuePair\"6\n\017HEntityIdentity\022\027\n\017collec" + "tion_name\030\001 \001(\t\022\n\n\002id\030\002 \003(\003\"J\n\nHEntityID" + "s\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" + "\n\017entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDs" + "Param\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segmen" + "t_name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017coll" + "ection_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013" + "HIndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grp" + "c.Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nind" + "ex_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.mi" + "lvus.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004N" + "ULL\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n" + "\005INT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020" + "(\022\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*" + "C\n\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002E" + "Q\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\321\026\n\rMilvusService\022H\n\020CreateCollec" + "tion\022\035.milvus.grpc.CollectionSchema\032\023.mi" + "lvus.grpc.Status\"\000\022F\n\rHasCollection\022\033.mi" + "lvus.grpc.CollectionName\032\026.milvus.grpc.B" + "oolReply\"\000\022R\n\022DescribeCollection\022\033.milvu" + "s.grpc.CollectionName\032\035.milvus.grpc.Coll" + "ectionSchema\"\000\022Q\n\017CountCollection\022\033.milv" + "us.grpc.CollectionName\032\037.milvus.grpc.Col" + "lectionRowCount\"\000\022J\n\017ShowCollections\022\024.m" + "ilvus.grpc.Command\032\037.milvus.grpc.Collect" + "ionNameList\"\000\022P\n\022ShowCollectionInfo\022\033.mi" + "lvus.grpc.CollectionName\032\033.milvus.grpc.C" + "ollectionInfo\"\000\022D\n\016DropCollection\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.Index" + "Param\032\023.milvus.grpc.Status\"\000\022G\n\rDescribe" + "Index\022\033.milvus.grpc.CollectionName\032\027.mil" + "vus.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.mil" + "vus.grpc.CollectionName\032\023.milvus.grpc.St" + "atus\"\000\022E\n\017CreatePartition\022\033.milvus.grpc." + "PartitionParam\032\023.milvus.grpc.Status\"\000\022E\n" + "\014HasPartition\022\033.milvus.grpc.PartitionPar" + "am\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPart" + "itions\022\033.milvus.grpc.CollectionName\032\032.mi" + "lvus.grpc.PartitionList\"\000\022C\n\rDropPartiti" + "on\022\033.milvus.grpc.PartitionParam\032\023.milvus" + ".grpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.I" + "nsertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016" + "GetVectorsByID\022\034.milvus.grpc.VectorsIden" + "tity\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetV" + "ectorIDs\022\036.milvus.grpc.GetVectorIDsParam" + "\032\026.milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.m" + "ilvus.grpc.SearchParam\032\034.milvus.grpc.Top" + "KQueryResult\"\000\022J\n\nSearchByID\022\034.milvus.gr" + "pc.SearchByIDParam\032\034.milvus.grpc.TopKQue" + "ryResult\"\000\022P\n\rSearchInFiles\022\037.milvus.grp" + "c.SearchInFilesParam\032\034.milvus.grpc.TopKQ" + "ueryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Comman" + "d\032\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteB" + "yID\022\034.milvus.grpc.DeleteByIDParam\032\023.milv" + "us.grpc.Status\"\000\022G\n\021PreloadCollection\022\033." + "milvus.grpc.CollectionName\032\023.milvus.grpc" + ".Status\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPa" + "ram\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033." + "milvus.grpc.CollectionName\032\023.milvus.grpc" + ".Status\"\000\022E\n\026CreateHybridCollection\022\024.mi" + "lvus.grpc.Mapping\032\023.milvus.grpc.Status\"\000" + "\022L\n\023HasHybridCollection\022\033.milvus.grpc.Co" + "llectionName\032\026.milvus.grpc.BoolReply\"\000\022J" + "\n\024DropHybridCollection\022\033.milvus.grpc.Col" + "lectionName\032\023.milvus.grpc.Status\"\000\022O\n\030De" + "scribeHybridCollection\022\033.milvus.grpc.Col" + "lectionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025C" + "ountHybridCollection\022\033.milvus.grpc.Colle" + "ctionName\032\037.milvus.grpc.CollectionRowCou" + "nt\"\000\022I\n\025ShowHybridCollections\022\024.milvus.g" + "rpc.Command\032\030.milvus.grpc.MappingList\"\000\022" + "V\n\030ShowHybridCollectionInfo\022\033.milvus.grp" + "c.CollectionName\032\033.milvus.grpc.Collectio" + "nInfo\"\000\022M\n\027PreloadHybridCollection\022\033.mil" + "vus.grpc.CollectionName\032\023.milvus.grpc.St" + "atus\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HIn" + "sertParam\032\027.milvus.grpc.HEntityIDs\"\000\022F\n\014" + "HybridSearch\022\031.milvus.grpc.HSearchParam\032" + "\031.milvus.grpc.HQueryResult\"\000\022]\n\026HybridSe" + "archInSegments\022#.milvus.grpc.HSearchInSe" + "gmentsParam\032\034.milvus.grpc.TopKQueryResul" + "t\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.Vecto" + "rsIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014Ge" + "tEntityIDs\022\037.milvus.grpc.HGetEntityIDsPa" + "ram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delete" + "EntitiesByID\022\035.milvus.grpc.HDeleteByIDPa" + "ram\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, @@ -1699,7 +1704,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_TermQuery_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorFieldParam_milvus_2eproto.base, - &scc_info_VectorFieldValue_milvus_2eproto.base, + &scc_info_VectorFieldRecord_milvus_2eproto.base, &scc_info_VectorIds_milvus_2eproto.base, &scc_info_VectorQuery_milvus_2eproto.base, &scc_info_VectorsData_milvus_2eproto.base, @@ -1708,7 +1713,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8235, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8354, &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 47, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, file_level_metadata_milvus_2eproto, 48, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, @@ -11480,48 +11485,48 @@ void FieldParam::InternalSwap(FieldParam* other) { // =================================================================== -void VectorFieldValue::InitAsDefaultInstance() { +void VectorFieldRecord::InitAsDefaultInstance() { } -class VectorFieldValue::_Internal { +class VectorFieldRecord::_Internal { public: }; -VectorFieldValue::VectorFieldValue() +VectorFieldRecord::VectorFieldRecord() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldRecord) } -VectorFieldValue::VectorFieldValue(const VectorFieldValue& from) +VectorFieldRecord::VectorFieldRecord(const VectorFieldRecord& 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) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldRecord) } -void VectorFieldValue::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldValue_milvus_2eproto.base); +void VectorFieldRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldRecord_milvus_2eproto.base); } -VectorFieldValue::~VectorFieldValue() { - // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldValue) +VectorFieldRecord::~VectorFieldRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldRecord) SharedDtor(); } -void VectorFieldValue::SharedDtor() { +void VectorFieldRecord::SharedDtor() { } -void VectorFieldValue::SetCachedSize(int size) const { +void VectorFieldRecord::SetCachedSize(int size) const { _cached_size_.Set(size); } -const VectorFieldValue& VectorFieldValue::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldValue_milvus_2eproto.base); +const VectorFieldRecord& VectorFieldRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldRecord_milvus_2eproto.base); return *internal_default_instance(); } -void VectorFieldValue::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11531,7 +11536,7 @@ void VectorFieldValue::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* VectorFieldValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* VectorFieldRecord::_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; @@ -11570,11 +11575,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool VectorFieldValue::MergePartialFromCodedStream( +bool VectorFieldRecord::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) + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorFieldRecord) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -11603,18 +11608,18 @@ bool VectorFieldValue::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldRecord) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldRecord) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void VectorFieldValue::SerializeWithCachedSizes( +void VectorFieldRecord::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11631,12 +11636,12 @@ void VectorFieldValue::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldRecord) } -::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldValue::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldRecord::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11652,12 +11657,12 @@ void VectorFieldValue::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldRecord) return target; } -size_t VectorFieldValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldValue) +size_t VectorFieldRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldRecord) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -11685,23 +11690,23 @@ size_t VectorFieldValue::ByteSizeLong() const { return total_size; } -void VectorFieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldRecord) GOOGLE_DCHECK_NE(&from, this); - const VectorFieldValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const VectorFieldRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldRecord) MergeFrom(*source); } } -void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::MergeFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldRecord) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11710,31 +11715,31 @@ void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { value_.MergeFrom(from.value_); } -void VectorFieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldRecord) if (&from == this) return; Clear(); MergeFrom(from); } -void VectorFieldValue::CopyFrom(const VectorFieldValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::CopyFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldRecord) if (&from == this) return; Clear(); MergeFrom(from); } -bool VectorFieldValue::IsInitialized() const { +bool VectorFieldRecord::IsInitialized() const { return true; } -void VectorFieldValue::InternalSwap(VectorFieldValue* other) { +void VectorFieldRecord::InternalSwap(VectorFieldRecord* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&value_)->InternalSwap(CastToBase(&other->value_)); } -::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldValue::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldRecord::GetMetadata() const { return GetMetadataStatic(); } @@ -11742,26 +11747,24 @@ void VectorFieldValue::InternalSwap(VectorFieldValue* other) { // =================================================================== 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()); + ::milvus::grpc::_FieldValue_default_instance_.vector_value_ = const_cast< ::milvus::grpc::VectorFieldRecord*>( + ::milvus::grpc::VectorFieldRecord::internal_default_instance()); } class FieldValue::_Internal { public: - static const ::milvus::grpc::VectorFieldValue& vector_value(const FieldValue* msg); + static const ::milvus::grpc::VectorFieldRecord& vector_value(const FieldValue* msg); }; -const ::milvus::grpc::VectorFieldValue& +const ::milvus::grpc::VectorFieldRecord& FieldValue::_Internal::vector_value(const FieldValue* msg) { return *msg->value_.vector_value_; } -void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value) { +void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldRecord* vector_value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); clear_value(); if (vector_value) { @@ -11786,18 +11789,10 @@ FieldValue::FieldValue(const FieldValue& from) _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; @@ -11811,7 +11806,7 @@ FieldValue::FieldValue(const FieldValue& from) break; } case kVectorValue: { - mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + mutable_vector_value()->::milvus::grpc::VectorFieldRecord::MergeFrom(from.vector_value()); break; } case VALUE_NOT_SET: { @@ -11849,18 +11844,10 @@ const FieldValue& FieldValue::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; @@ -11903,51 +11890,37 @@ const char* FieldValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // int32 int32_value = 1; + // int64 int64_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)) { + // double double_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { 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)) { + // string string_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { 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)) { + // bool bool_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { 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)) { + // .milvus.grpc.VectorFieldRecord vector_value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(mutable_vector_value(), ptr); CHK_(ptr); } else goto handle_unusual; @@ -11982,23 +11955,9 @@ bool FieldValue::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // int32 int32_value = 1; + // int64 int64_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>( @@ -12010,23 +11969,9 @@ bool FieldValue::MergePartialFromCodedStream( 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)) { + // double double_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) { clear_value(); DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( @@ -12038,9 +11983,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // string string_value = 5; - case 5: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + // string string_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( input, this->mutable_string_value())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( @@ -12053,9 +11998,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // bool bool_value = 6; - case 6: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + // bool bool_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { clear_value(); DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( @@ -12067,9 +12012,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // .milvus.grpc.VectorFieldValue vector_value = 7; - case 7: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + // .milvus.grpc.VectorFieldRecord vector_value = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( input, mutable_vector_value())); } else { @@ -12105,45 +12050,35 @@ void FieldValue::SerializeWithCachedSizes( ::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; + // int64 int64_value = 1; 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); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->int64_value(), output); } - // double double_value = 4; + // double double_value = 2; if (has_double_value()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(4, this->double_value(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(2, this->double_value(), output); } - // string string_value = 5; + // string string_value = 3; 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); + 3, this->string_value(), output); } - // bool bool_value = 6; + // bool bool_value = 4; if (has_bool_value()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->bool_value(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->bool_value(), output); } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; if (has_vector_value()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 7, _Internal::vector_value(this), output); + 5, _Internal::vector_value(this), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -12159,27 +12094,17 @@ void FieldValue::SerializeWithCachedSizes( ::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; + // int64 int64_value = 1; 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); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->int64_value(), target); } - // double double_value = 4; + // double double_value = 2; if (has_double_value()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->double_value(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->double_value(), target); } - // string string_value = 5; + // string string_value = 3; if (has_string_value()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->string_value().data(), static_cast(this->string_value().length()), @@ -12187,19 +12112,19 @@ void FieldValue::SerializeWithCachedSizes( "milvus.grpc.FieldValue.string_value"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 5, this->string_value(), target); + 3, this->string_value(), target); } - // bool bool_value = 6; + // bool bool_value = 4; if (has_bool_value()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->bool_value(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->bool_value(), target); } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; if (has_vector_value()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 7, _Internal::vector_value(this), target); + 5, _Internal::vector_value(this), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -12224,43 +12149,31 @@ size_t FieldValue::ByteSizeLong() const { (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; + // int64 int64_value = 1; 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; + // double double_value = 2; case kDoubleValue: { total_size += 1 + 8; break; } - // string string_value = 5; + // string string_value = 3; case kStringValue: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->string_value()); break; } - // bool bool_value = 6; + // bool bool_value = 4; case kBoolValue: { total_size += 1 + 1; break; } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; case kVectorValue: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -12299,18 +12212,10 @@ void FieldValue::MergeFrom(const FieldValue& from) { (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; @@ -12324,7 +12229,7 @@ void FieldValue::MergeFrom(const FieldValue& from) { break; } case kVectorValue: { - mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + mutable_vector_value()->::milvus::grpc::VectorFieldRecord::MergeFrom(from.vector_value()); break; } case VALUE_NOT_SET: { @@ -13141,16 +13046,14 @@ TermQuery::TermQuery() TermQuery::TermQuery(const TermQuery& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), + int_value_(from.int_value_), + double_value_(from.double_value_), 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_); } - values_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.values().empty()) { - values_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.values_); - } ::memcpy(&value_num_, &from.value_num_, static_cast(reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13160,7 +13063,6 @@ TermQuery::TermQuery(const TermQuery& from) void TermQuery::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermQuery_milvus_2eproto.base); field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&value_num_, 0, static_cast( reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13173,7 +13075,6 @@ TermQuery::~TermQuery() { void TermQuery::SharedDtor() { field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void TermQuery::SetCachedSize(int size) const { @@ -13191,9 +13092,10 @@ void TermQuery::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + int_value_.Clear(); + double_value_.Clear(); extra_params_.Clear(); field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&value_num_, 0, static_cast( reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13215,37 +13117,50 @@ const char* TermQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // bytes values = 2; + // repeated int64 int_value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_values(), ptr, ctx); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; - // int64 value_num = 3; + // repeated double double_value = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - value_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); } else goto handle_unusual; continue; - // float boost = 4; + // int64 value_num = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + value_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float boost = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } 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)) { + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { 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); + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); } else goto handle_unusual; continue; default: { @@ -13293,20 +13208,41 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // bytes values = 2; + // repeated int64 int_value = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { - DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( - input, this->mutable_values())); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int_value()))); + } 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_int_value()))); } else { goto handle_unusual; } break; } - // int64 value_num = 3; + // repeated double double_value = 3; case 3: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (25 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 26u, input, this->mutable_double_value()))); + } else { + goto handle_unusual; + } + break; + } + + // int64 value_num = 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>( @@ -13317,9 +13253,9 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // float boost = 4; - case 4: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) { + // float boost = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( @@ -13330,9 +13266,9 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; - case 5: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( input, add_extra_params())); } else { @@ -13378,27 +13314,41 @@ void TermQuery::SerializeWithCachedSizes( 1, this->field_name(), output); } - // bytes values = 2; - if (this->values().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( - 2, this->values(), output); + // repeated int64 int_value = 2; + if (this->int_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int_value(i), output); + } + + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); } - // int64 value_num = 3; + // int64 value_num = 4; if (this->value_num() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->value_num(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->value_num(), output); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->boost(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->boost(), output); } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; for (unsigned int i = 0, n = static_cast(this->extra_params_size()); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 5, + 6, this->extra_params(static_cast(i)), output); } @@ -13427,29 +13377,48 @@ void TermQuery::SerializeWithCachedSizes( 1, this->field_name(), target); } - // bytes values = 2; - if (this->values().size() > 0) { - target = - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( - 2, this->values(), target); + // repeated int64 int_value = 2; + if (this->int_value_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( + _int_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int_value_, target); } - // int64 value_num = 3; + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_value_, target); + } + + // int64 value_num = 4; if (this->value_num() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->value_num(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->value_num(), target); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->boost(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->boost(), target); } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; 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); + 6, this->extra_params(static_cast(i)), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -13473,7 +13442,37 @@ size_t TermQuery::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated int64 int_value = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int_value_); + 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); + _int_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 3; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * 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); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; { unsigned int count = static_cast(this->extra_params_size()); total_size += 1UL * count; @@ -13491,21 +13490,14 @@ size_t TermQuery::ByteSizeLong() const { this->field_name()); } - // bytes values = 2; - if (this->values().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->values()); - } - - // int64 value_num = 3; + // int64 value_num = 4; if (this->value_num() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( this->value_num()); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { total_size += 1 + 4; } @@ -13537,15 +13529,13 @@ void TermQuery::MergeFrom(const TermQuery& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + int_value_.MergeFrom(from.int_value_); + double_value_.MergeFrom(from.double_value_); 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.values().size() > 0) { - - values_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.values_); - } if (from.value_num() != 0) { set_value_num(from.value_num()); } @@ -13575,11 +13565,11 @@ bool TermQuery::IsInitialized() const { void TermQuery::InternalSwap(TermQuery* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + int_value_.InternalSwap(&other->int_value_); + double_value_.InternalSwap(&other->double_value_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - values_.Swap(&other->values_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - GetArenaNoVirtual()); swap(value_num_, other->value_num_); swap(boost_, other->boost_); } @@ -16412,13 +16402,13 @@ AttrRecord::AttrRecord() AttrRecord::AttrRecord(const AttrRecord& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - value_(from.value_) { + int_value_(from.int_value_), + double_value_(from.double_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() { @@ -16444,7 +16434,8 @@ void AttrRecord::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - value_.Clear(); + int_value_.Clear(); + double_value_.Clear(); _internal_metadata_.Clear(); } @@ -16456,16 +16447,24 @@ const char* AttrRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // repeated string value = 1; + // repeated int64 int_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); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { + add_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated double double_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); } else goto handle_unusual; continue; default: { @@ -16498,16 +16497,32 @@ bool AttrRecord::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // repeated string value = 1; + // repeated int64 int_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")); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 10u, input, this->mutable_int_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated double double_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 18u, input, this->mutable_double_value()))); } else { goto handle_unusual; } @@ -16541,14 +16556,24 @@ void AttrRecord::SerializeWithCachedSizes( ::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); + // repeated int64 int_value = 1; + if (this->int_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int_value(i), output); + } + + // repeated double double_value = 2; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -16564,16 +16589,32 @@ void AttrRecord::SerializeWithCachedSizes( ::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); - } - + // repeated int64 int_value = 1; + if (this->int_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 1, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _int_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int_value_, target); + } + + // repeated double double_value = 2; + if (this->double_value_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( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_value_, target); + } + if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); @@ -16595,12 +16636,34 @@ size_t AttrRecord::ByteSizeLong() const { // 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)); + // repeated int64 int_value = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int_value_); + 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); + _int_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 2; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * 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); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -16630,7 +16693,8 @@ void AttrRecord::MergeFrom(const AttrRecord& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - value_.MergeFrom(from.value_); + int_value_.MergeFrom(from.int_value_); + double_value_.MergeFrom(from.double_value_); } void AttrRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -16654,7 +16718,8 @@ bool AttrRecord::IsInitialized() const { void AttrRecord::InternalSwap(AttrRecord* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - value_.InternalSwap(CastToBase(&other->value_)); + int_value_.InternalSwap(&other->int_value_); + double_value_.InternalSwap(&other->double_value_); } ::PROTOBUF_NAMESPACE_ID::Metadata AttrRecord::GetMetadata() const { @@ -16691,27 +16756,23 @@ HEntity::HEntity() HEntity::HEntity(const HEntity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), + entity_id_(from.entity_id_), field_names_(from.field_names_), - result_values_(from.result_values_) { + data_types_(from.data_types_), + attr_data_(from.attr_data_), + vector_data_(from.vector_data_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - attr_records_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.attr_records().empty()) { - attr_records_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.attr_records_); - } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } - ::memcpy(&entity_id_, &from.entity_id_, - static_cast(reinterpret_cast(&row_num_) - - reinterpret_cast(&entity_id_)) + sizeof(row_num_)); + row_num_ = from.row_num_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntity) } void HEntity::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntity_milvus_2eproto.base); - attr_records_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&row_num_) - reinterpret_cast(&status_)) + sizeof(row_num_)); @@ -16723,7 +16784,6 @@ HEntity::~HEntity() { } void HEntity::SharedDtor() { - attr_records_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } @@ -16742,16 +16802,16 @@ void HEntity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + entity_id_.Clear(); field_names_.Clear(); - result_values_.Clear(); - attr_records_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + data_types_.Clear(); + attr_data_.Clear(); + vector_data_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; - ::memset(&entity_id_, 0, static_cast( - reinterpret_cast(&row_num_) - - reinterpret_cast(&entity_id_)) + sizeof(row_num_)); + row_num_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -16770,10 +16830,13 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // int64 entity_id = 2; + // repeated 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); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_entity_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -16789,11 +16852,15 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); } else goto handle_unusual; continue; - // bytes attr_records = 4; + // repeated .milvus.grpc.DataType data_types = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_attr_records(), ptr, ctx); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(mutable_data_types(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); CHK_(ptr); + add_data_types(static_cast<::milvus::grpc::DataType>(val)); } else goto handle_unusual; continue; // int64 row_num = 5; @@ -16803,18 +16870,30 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr -= 1; do { ptr += 1; - ptr = ctx->ParseMessage(add_result_values(), ptr); + ptr = ctx->ParseMessage(add_attr_data(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); } else goto handle_unusual; continue; + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_vector_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -16856,13 +16935,16 @@ bool HEntity::MergePartialFromCodedStream( break; } - // int64 entity_id = 2; + // repeated int64 entity_id = 2; case 2: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { - - DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + 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, &entity_id_))); + input, this->mutable_entity_id()))); + } 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()))); } else { goto handle_unusual; } @@ -16885,11 +16967,26 @@ bool HEntity::MergePartialFromCodedStream( break; } - // bytes attr_records = 4; + // repeated .milvus.grpc.DataType data_types = 4; case 4: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { - DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( - input, this->mutable_attr_records())); + ::PROTOBUF_NAMESPACE_ID::uint32 length; + DO_(input->ReadVarint32(&length)); + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream::Limit limit = input->PushLimit(static_cast(length)); + while (input->BytesUntilLimit() > 0) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_data_types(static_cast< ::milvus::grpc::DataType >(value)); + } + input->PopLimit(limit); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_data_types(static_cast< ::milvus::grpc::DataType >(value)); } else { goto handle_unusual; } @@ -16909,11 +17006,22 @@ bool HEntity::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; case 6: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, add_result_values())); + input, add_attr_data())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_vector_data())); } else { goto handle_unusual; } @@ -16953,9 +17061,15 @@ void HEntity::SerializeWithCachedSizes( 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 int64 entity_id = 2; + if (this->entity_id_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id(i), output); } // repeated string field_names = 3; @@ -16968,10 +17082,18 @@ void HEntity::SerializeWithCachedSizes( 3, this->field_names(i), output); } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( - 4, this->attr_records(), output); + // repeated .milvus.grpc.DataType data_types = 4; + if (this->data_types_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + output); + output->WriteVarint32(_data_types_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->data_types_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumNoTag( + this->data_types(i), output); } // int64 row_num = 5; @@ -16979,12 +17101,21 @@ void HEntity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(5, this->row_num(), output); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; for (unsigned int i = 0, - n = static_cast(this->result_values_size()); i < n; i++) { + n = static_cast(this->attr_data_size()); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( 6, - this->result_values(static_cast(i)), + this->attr_data(static_cast(i)), + output); + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + for (unsigned int i = 0, + n = static_cast(this->vector_data_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, + this->vector_data(static_cast(i)), output); } @@ -17008,9 +17139,17 @@ void HEntity::SerializeWithCachedSizes( 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 int64 entity_id = 2; + if (this->entity_id_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_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_, target); } // repeated string field_names = 3; @@ -17023,11 +17162,16 @@ void HEntity::SerializeWithCachedSizes( WriteStringToArray(3, this->field_names(i), target); } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - target = - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( - 4, this->attr_records(), target); + // repeated .milvus.grpc.DataType data_types = 4; + if (this->data_types_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( _data_types_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumNoTagToArray( + this->data_types_, target); } // int64 row_num = 5; @@ -17035,12 +17179,20 @@ void HEntity::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->row_num(), target); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; + for (unsigned int i = 0, + n = static_cast(this->attr_data_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->attr_data(static_cast(i)), target); + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; for (unsigned int i = 0, - n = static_cast(this->result_values_size()); i < n; i++) { + n = static_cast(this->vector_data_size()); i < n; i++) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 6, this->result_values(static_cast(i)), target); + 7, this->vector_data(static_cast(i)), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -17064,6 +17216,21 @@ size_t HEntity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // repeated int64 entity_id = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_); + 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_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + // repeated string field_names = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->field_names_size()); @@ -17072,22 +17239,44 @@ size_t HEntity::ByteSizeLong() const { this->field_names(i)); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.DataType data_types = 4; + { + size_t data_size = 0; + unsigned int count = static_cast(this->data_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->data_types(static_cast(i))); + } + 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); + _data_types_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.AttrRecord attr_data = 6; { - unsigned int count = static_cast(this->result_values_size()); + unsigned int count = static_cast(this->attr_data_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))); + this->attr_data(static_cast(i))); } } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->attr_records()); + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + { + unsigned int count = static_cast(this->vector_data_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->vector_data(static_cast(i))); + } } // .milvus.grpc.Status status = 1; @@ -17097,13 +17286,6 @@ size_t HEntity::ByteSizeLong() const { *status_); } - // int64 entity_id = 2; - if (this->entity_id() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->entity_id()); - } - // int64 row_num = 5; if (this->row_num() != 0) { total_size += 1 + @@ -17138,18 +17320,14 @@ void HEntity::MergeFrom(const HEntity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + entity_id_.MergeFrom(from.entity_id_); field_names_.MergeFrom(from.field_names_); - result_values_.MergeFrom(from.result_values_); - if (from.attr_records().size() > 0) { - - attr_records_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.attr_records_); - } + data_types_.MergeFrom(from.data_types_); + attr_data_.MergeFrom(from.attr_data_); + vector_data_.MergeFrom(from.vector_data_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } - if (from.entity_id() != 0) { - set_entity_id(from.entity_id()); - } if (from.row_num() != 0) { set_row_num(from.row_num()); } @@ -17176,12 +17354,12 @@ bool HEntity::IsInitialized() const { void HEntity::InternalSwap(HEntity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_.InternalSwap(&other->entity_id_); field_names_.InternalSwap(CastToBase(&other->field_names_)); - CastToBase(&result_values_)->InternalSwap(CastToBase(&other->result_values_)); - attr_records_.Swap(&other->attr_records_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - GetArenaNoVirtual()); + data_types_.InternalSwap(&other->data_types_); + CastToBase(&attr_data_)->InternalSwap(CastToBase(&other->attr_data_)); + CastToBase(&vector_data_)->InternalSwap(CastToBase(&other->vector_data_)); swap(status_, other->status_); - swap(entity_id_, other->entity_id_); swap(row_num_, other->row_num_); } @@ -17195,16 +17373,23 @@ void HEntity::InternalSwap(HEntity* other) { void HQueryResult::InitAsDefaultInstance() { ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); + ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->entity_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::HEntity::internal_default_instance()); } class HQueryResult::_Internal { public: static const ::milvus::grpc::Status& status(const HQueryResult* msg); + static const ::milvus::grpc::HEntity& entity(const HQueryResult* msg); }; const ::milvus::grpc::Status& HQueryResult::_Internal::status(const HQueryResult* msg) { return *msg->status_; } +const ::milvus::grpc::HEntity& +HQueryResult::_Internal::entity(const HQueryResult* msg) { + return *msg->entity_; +} void HQueryResult::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; @@ -17219,15 +17404,20 @@ HQueryResult::HQueryResult() HQueryResult::HQueryResult(const HQueryResult& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - entities_(from.entities_), score_(from.score_), - distance_(from.distance_) { + distance_(from.distance_), + extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } + if (from.has_entity()) { + entity_ = new ::milvus::grpc::HEntity(*from.entity_); + } else { + entity_ = nullptr; + } row_num_ = from.row_num_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.HQueryResult) } @@ -17246,6 +17436,7 @@ HQueryResult::~HQueryResult() { void HQueryResult::SharedDtor() { if (this != internal_default_instance()) delete status_; + if (this != internal_default_instance()) delete entity_; } void HQueryResult::SetCachedSize(int size) const { @@ -17263,13 +17454,17 @@ void HQueryResult::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - entities_.Clear(); score_.Clear(); distance_.Clear(); + extra_params_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; + } + entity_ = nullptr; row_num_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -17289,16 +17484,11 @@ const char* HQueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // repeated .milvus.grpc.HEntity entities = 2; + // .milvus.grpc.HEntity entity = 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); + ptr = ctx->ParseMessage(mutable_entity(), ptr); + CHK_(ptr); } else goto handle_unusual; continue; // int64 row_num = 3; @@ -17328,6 +17518,18 @@ const char* HQueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ptr += sizeof(float); } else goto handle_unusual; continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + 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) == 50); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -17369,11 +17571,11 @@ bool HQueryResult::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.HEntity entities = 2; + // .milvus.grpc.HEntity entity = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, add_entities())); + input, mutable_entity())); } else { goto handle_unusual; } @@ -17425,6 +17627,17 @@ bool HQueryResult::MergePartialFromCodedStream( break; } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + default: { handle_unusual: if (tag == 0) { @@ -17458,13 +17671,10 @@ void HQueryResult::SerializeWithCachedSizes( 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++) { + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 2, - this->entities(static_cast(i)), - output); + 2, _Internal::entity(this), output); } // int64 row_num = 3; @@ -17490,6 +17700,15 @@ void HQueryResult::SerializeWithCachedSizes( this->distance().data(), this->distance_size(), output); } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, + this->extra_params(static_cast(i)), + output); + } + if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); @@ -17510,12 +17729,11 @@ void HQueryResult::SerializeWithCachedSizes( 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++) { + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 2, this->entities(static_cast(i)), target); + 2, _Internal::entity(this), target); } // int64 row_num = 3; @@ -17549,6 +17767,14 @@ void HQueryResult::SerializeWithCachedSizes( WriteFloatNoTagToArray(this->distance_, target); } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, 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); @@ -17570,17 +17796,6 @@ size_t HQueryResult::ByteSizeLong() const { // 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()); @@ -17611,6 +17826,17 @@ size_t HQueryResult::ByteSizeLong() const { total_size += data_size; } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + { + 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))); + } + } + // .milvus.grpc.Status status = 1; if (this->has_status()) { total_size += 1 + @@ -17618,6 +17844,13 @@ size_t HQueryResult::ByteSizeLong() const { *status_); } + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *entity_); + } + // int64 row_num = 3; if (this->row_num() != 0) { total_size += 1 + @@ -17652,12 +17885,15 @@ void HQueryResult::MergeFrom(const HQueryResult& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - entities_.MergeFrom(from.entities_); score_.MergeFrom(from.score_); distance_.MergeFrom(from.distance_); + extra_params_.MergeFrom(from.extra_params_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } + if (from.has_entity()) { + mutable_entity()->::milvus::grpc::HEntity::MergeFrom(from.entity()); + } if (from.row_num() != 0) { set_row_num(from.row_num()); } @@ -17684,10 +17920,11 @@ bool HQueryResult::IsInitialized() const { 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_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); swap(status_, other->status_); + swap(entity_, other->entity_); swap(row_num_, other->row_num_); } @@ -17699,17 +17936,17 @@ void HQueryResult::InternalSwap(HQueryResult* other) { // =================================================================== void HInsertParam::InitAsDefaultInstance() { - ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entities_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entity_ = const_cast< ::milvus::grpc::HEntity*>( ::milvus::grpc::HEntity::internal_default_instance()); } class HInsertParam::_Internal { public: - static const ::milvus::grpc::HEntity& entities(const HInsertParam* msg); + static const ::milvus::grpc::HEntity& entity(const HInsertParam* msg); }; const ::milvus::grpc::HEntity& -HInsertParam::_Internal::entities(const HInsertParam* msg) { - return *msg->entities_; +HInsertParam::_Internal::entity(const HInsertParam* msg) { + return *msg->entity_; } HInsertParam::HInsertParam() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { @@ -17730,10 +17967,10 @@ HInsertParam::HInsertParam(const HInsertParam& from) 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_); + if (from.has_entity()) { + entity_ = new ::milvus::grpc::HEntity(*from.entity_); } else { - entities_ = nullptr; + entity_ = nullptr; } // @@protoc_insertion_point(copy_constructor:milvus.grpc.HInsertParam) } @@ -17742,7 +17979,7 @@ 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; + entity_ = nullptr; } HInsertParam::~HInsertParam() { @@ -17753,7 +17990,7 @@ HInsertParam::~HInsertParam() { 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_; + if (this != internal_default_instance()) delete entity_; } void HInsertParam::SetCachedSize(int size) const { @@ -17775,10 +18012,10 @@ void HInsertParam::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_; + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; } - entities_ = nullptr; + entity_ = nullptr; _internal_metadata_.Clear(); } @@ -17804,10 +18041,10 @@ const char* HInsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .milvus.grpc.HEntity entities = 3; + // .milvus.grpc.HEntity entity = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(mutable_entities(), ptr); + ptr = ctx->ParseMessage(mutable_entity(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -17893,11 +18130,11 @@ bool HInsertParam::MergePartialFromCodedStream( break; } - // .milvus.grpc.HEntity entities = 3; + // .milvus.grpc.HEntity entity = 3; case 3: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, mutable_entities())); + input, mutable_entity())); } else { goto handle_unusual; } @@ -17978,10 +18215,10 @@ void HInsertParam::SerializeWithCachedSizes( 2, this->partition_tag(), output); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 3, _Internal::entities(this), output); + 3, _Internal::entity(this), output); } // repeated int64 entity_id_array = 4; @@ -18039,11 +18276,11 @@ void HInsertParam::SerializeWithCachedSizes( 2, this->partition_tag(), target); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 3, _Internal::entities(this), target); + 3, _Internal::entity(this), target); } // repeated int64 entity_id_array = 4; @@ -18128,11 +18365,11 @@ size_t HInsertParam::ByteSizeLong() const { this->partition_tag()); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *entities_); + *entity_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -18172,8 +18409,8 @@ void HInsertParam::MergeFrom(const HInsertParam& from) { partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); } - if (from.has_entities()) { - mutable_entities()->::milvus::grpc::HEntity::MergeFrom(from.entities()); + if (from.has_entity()) { + mutable_entity()->::milvus::grpc::HEntity::MergeFrom(from.entity()); } } @@ -18204,7 +18441,7 @@ void HInsertParam::InternalSwap(HInsertParam* other) { GetArenaNoVirtual()); partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - swap(entities_, other->entities_); + swap(entity_, other->entity_); } ::PROTOBUF_NAMESPACE_ID::Metadata HInsertParam::GetMetadata() const { @@ -18227,20 +18464,19 @@ HEntityIdentity::HEntityIdentity() } HEntityIdentity::HEntityIdentity(const HEntityIdentity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), - _internal_metadata_(nullptr) { + _internal_metadata_(nullptr), + id_(from.id_) { _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() { @@ -18267,8 +18503,8 @@ void HEntityIdentity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + id_.Clear(); collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - id_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -18287,10 +18523,13 @@ const char* HEntityIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC CHK_(ptr); } else goto handle_unusual; continue; - // int64 id = 2; + // repeated int64 id = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -18339,13 +18578,16 @@ bool HEntityIdentity::MergePartialFromCodedStream( break; } - // int64 id = 2; + // repeated int64 id = 2; case 2: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { - - DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + 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, &id_))); + input, this->mutable_id()))); + } 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()))); } else { goto handle_unusual; } @@ -18389,9 +18631,15 @@ void HEntityIdentity::SerializeWithCachedSizes( 1, this->collection_name(), output); } - // int64 id = 2; - if (this->id() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->id(), output); + // repeated int64 id = 2; + if (this->id_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id(i), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -18418,9 +18666,17 @@ void HEntityIdentity::SerializeWithCachedSizes( 1, this->collection_name(), target); } - // int64 id = 2; - if (this->id() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->id(), target); + // repeated int64 id = 2; + if (this->id_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_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_, target); } if (_internal_metadata_.have_unknown_fields()) { @@ -18444,6 +18700,21 @@ size_t HEntityIdentity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // repeated int64 id = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_); + 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_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 + @@ -18451,13 +18722,6 @@ size_t HEntityIdentity::ByteSizeLong() const { 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; @@ -18485,13 +18749,11 @@ void HEntityIdentity::MergeFrom(const HEntityIdentity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + id_.MergeFrom(from.id_); 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) { @@ -18515,9 +18777,9 @@ bool HEntityIdentity::IsInitialized() const { void HEntityIdentity::InternalSwap(HEntityIdentity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + id_.InternalSwap(&other->id_); collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - swap(id_, other->id_); } ::PROTOBUF_NAMESPACE_ID::Metadata HEntityIdentity::GetMetadata() const { @@ -20056,8 +20318,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldType* Arena::CreateMaybeMessag 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::VectorFieldRecord* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldRecord >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::FieldValue >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::FieldValue >(arena); diff --git a/core/src/grpc/gen-milvus/milvus.pb.h b/core/src/grpc/gen-milvus/milvus.pb.h index f9c74151..4088920a 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.h +++ b/core/src/grpc/gen-milvus/milvus.pb.h @@ -187,9 +187,9 @@ extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; class VectorFieldParam; class VectorFieldParamDefaultTypeInternal; extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_; -class VectorFieldValue; -class VectorFieldValueDefaultTypeInternal; -extern VectorFieldValueDefaultTypeInternal _VectorFieldValue_default_instance_; +class VectorFieldRecord; +class VectorFieldRecordDefaultTypeInternal; +extern VectorFieldRecordDefaultTypeInternal _VectorFieldRecord_default_instance_; class VectorIds; class VectorIdsDefaultTypeInternal; extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; @@ -248,7 +248,7 @@ template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*); -template<> ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldValue>(Arena*); +template<> ::milvus::grpc::VectorFieldRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldRecord>(Arena*); template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*); template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*); template<> ::milvus::grpc::VectorsData* Arena::CreateMaybeMessage<::milvus::grpc::VectorsData>(Arena*); @@ -4545,23 +4545,23 @@ class FieldParam : }; // ------------------------------------------------------------------- -class VectorFieldValue : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldValue) */ { +class VectorFieldRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldRecord) */ { public: - VectorFieldValue(); - virtual ~VectorFieldValue(); + VectorFieldRecord(); + virtual ~VectorFieldRecord(); - VectorFieldValue(const VectorFieldValue& from); - VectorFieldValue(VectorFieldValue&& from) noexcept - : VectorFieldValue() { + VectorFieldRecord(const VectorFieldRecord& from); + VectorFieldRecord(VectorFieldRecord&& from) noexcept + : VectorFieldRecord() { *this = ::std::move(from); } - inline VectorFieldValue& operator=(const VectorFieldValue& from) { + inline VectorFieldRecord& operator=(const VectorFieldRecord& from) { CopyFrom(from); return *this; } - inline VectorFieldValue& operator=(VectorFieldValue&& from) noexcept { + inline VectorFieldRecord& operator=(VectorFieldRecord&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -4579,37 +4579,37 @@ class VectorFieldValue : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const VectorFieldValue& default_instance(); + static const VectorFieldRecord& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const VectorFieldValue* internal_default_instance() { - return reinterpret_cast( - &_VectorFieldValue_default_instance_); + static inline const VectorFieldRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldRecord_default_instance_); } static constexpr int kIndexInFileMessages = 27; - friend void swap(VectorFieldValue& a, VectorFieldValue& b) { + friend void swap(VectorFieldRecord& a, VectorFieldRecord& b) { a.Swap(&b); } - inline void Swap(VectorFieldValue* other) { + inline void Swap(VectorFieldRecord* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline VectorFieldValue* New() const final { - return CreateMaybeMessage(nullptr); + inline VectorFieldRecord* New() const final { + return CreateMaybeMessage(nullptr); } - VectorFieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + VectorFieldRecord* 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); + void CopyFrom(const VectorFieldRecord& from); + void MergeFrom(const VectorFieldRecord& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -4630,10 +4630,10 @@ class VectorFieldValue : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(VectorFieldValue* other); + void InternalSwap(VectorFieldRecord* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.VectorFieldValue"; + return "milvus.grpc.VectorFieldRecord"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -4671,7 +4671,7 @@ class VectorFieldValue : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& value() const; - // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldRecord) private: class _Internal; @@ -4719,13 +4719,11 @@ class FieldValue : static const FieldValue& default_instance(); enum ValueCase { - kInt32Value = 1, - kInt64Value = 2, - kFloatValue = 3, - kDoubleValue = 4, - kStringValue = 5, - kBoolValue = 6, - kVectorValue = 7, + kInt64Value = 1, + kDoubleValue = 2, + kStringValue = 3, + kBoolValue = 4, + kVectorValue = 5, VALUE_NOT_SET = 0, }; @@ -4806,23 +4804,13 @@ class FieldValue : // accessors ------------------------------------------------------- enum : int { - kInt32ValueFieldNumber = 1, - kInt64ValueFieldNumber = 2, - kFloatValueFieldNumber = 3, - kDoubleValueFieldNumber = 4, - kStringValueFieldNumber = 5, - kBoolValueFieldNumber = 6, - kVectorValueFieldNumber = 7, + kInt64ValueFieldNumber = 1, + kDoubleValueFieldNumber = 2, + kStringValueFieldNumber = 3, + kBoolValueFieldNumber = 4, + kVectorValueFieldNumber = 5, }; - // 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; + // int64 int64_value = 1; private: bool has_int64_value() const; public: @@ -4830,15 +4818,7 @@ class FieldValue : ::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; + // double double_value = 2; private: bool has_double_value() const; public: @@ -4846,7 +4826,7 @@ class FieldValue : double double_value() const; void set_double_value(double value); - // string string_value = 5; + // string string_value = 3; private: bool has_string_value() const; public: @@ -4860,7 +4840,7 @@ class FieldValue : std::string* release_string_value(); void set_allocated_string_value(std::string* string_value); - // bool bool_value = 6; + // bool bool_value = 4; private: bool has_bool_value() const; public: @@ -4868,22 +4848,20 @@ class FieldValue : bool bool_value() const; void set_bool_value(bool value); - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; 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); + const ::milvus::grpc::VectorFieldRecord& vector_value() const; + ::milvus::grpc::VectorFieldRecord* release_vector_value(); + ::milvus::grpc::VectorFieldRecord* mutable_vector_value(); + void set_allocated_vector_value(::milvus::grpc::VectorFieldRecord* 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(); @@ -4895,13 +4873,11 @@ class FieldValue : ::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_; + ::milvus::grpc::VectorFieldRecord* vector_value_; } value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -5337,13 +5313,36 @@ class TermQuery : // accessors ------------------------------------------------------- enum : int { - kExtraParamsFieldNumber = 5, + kIntValueFieldNumber = 2, + kDoubleValueFieldNumber = 3, + kExtraParamsFieldNumber = 6, kFieldNameFieldNumber = 1, - kValuesFieldNumber = 2, - kValueNumFieldNumber = 3, - kBoostFieldNumber = 4, + kValueNumFieldNumber = 4, + kBoostFieldNumber = 5, }; - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated int64 int_value = 2; + int int_value_size() const; + void clear_int_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const; + void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int_value(); + + // repeated double double_value = 3; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; int extra_params_size() const; void clear_extra_params(); ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); @@ -5365,23 +5364,12 @@ class TermQuery : std::string* release_field_name(); void set_allocated_field_name(std::string* field_name); - // bytes values = 2; - void clear_values(); - const std::string& values() const; - void set_values(const std::string& value); - void set_values(std::string&& value); - void set_values(const char* value); - void set_values(const void* value, size_t size); - std::string* mutable_values(); - std::string* release_values(); - void set_allocated_values(std::string* values); - - // int64 value_num = 3; + // int64 value_num = 4; void clear_value_num(); ::PROTOBUF_NAMESPACE_ID::int64 value_num() const; void set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value); - // float boost = 4; + // float boost = 5; void clear_boost(); float boost() const; void set_boost(float value); @@ -5391,9 +5379,12 @@ class TermQuery : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_; + mutable std::atomic _int_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr values_; ::PROTOBUF_NAMESPACE_ID::int64 value_num_; float boost_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -6667,31 +6658,40 @@ class AttrRecord : // accessors ------------------------------------------------------- enum : int { - kValueFieldNumber = 1, + kIntValueFieldNumber = 1, + kDoubleValueFieldNumber = 2, }; - // 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(); + // repeated int64 int_value = 1; + int int_value_size() const; + void clear_int_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const; + void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int_value(); + + // repeated double double_value = 2; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); // @@protoc_insertion_point(class_scope:milvus.grpc.AttrRecord) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField value_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_; + mutable std::atomic _int_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -6810,13 +6810,25 @@ class HEntity : // accessors ------------------------------------------------------- enum : int { + kEntityIdFieldNumber = 2, kFieldNamesFieldNumber = 3, - kResultValuesFieldNumber = 6, - kAttrRecordsFieldNumber = 4, + kDataTypesFieldNumber = 4, + kAttrDataFieldNumber = 6, + kVectorDataFieldNumber = 7, kStatusFieldNumber = 1, - kEntityIdFieldNumber = 2, kRowNumFieldNumber = 5, }; + // repeated int64 entity_id = 2; + int entity_id_size() const; + void clear_entity_id(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id(int index) const; + void set_entity_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id(); + // repeated string field_names = 3; int field_names_size() const; void clear_field_names(); @@ -6834,27 +6846,36 @@ class HEntity : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& field_names() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_field_names(); - // repeated .milvus.grpc.FieldValue result_values = 6; - 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; - - // bytes attr_records = 4; - void clear_attr_records(); - const std::string& attr_records() const; - void set_attr_records(const std::string& value); - void set_attr_records(std::string&& value); - void set_attr_records(const char* value); - void set_attr_records(const void* value, size_t size); - std::string* mutable_attr_records(); - std::string* release_attr_records(); - void set_allocated_attr_records(std::string* attr_records); + // repeated .milvus.grpc.DataType data_types = 4; + int data_types_size() const; + void clear_data_types(); + ::milvus::grpc::DataType data_types(int index) const; + void set_data_types(int index, ::milvus::grpc::DataType value); + void add_data_types(::milvus::grpc::DataType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& data_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_data_types(); + + // repeated .milvus.grpc.AttrRecord attr_data = 6; + int attr_data_size() const; + void clear_attr_data(); + ::milvus::grpc::AttrRecord* mutable_attr_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* + mutable_attr_data(); + const ::milvus::grpc::AttrRecord& attr_data(int index) const; + ::milvus::grpc::AttrRecord* add_attr_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& + attr_data() const; + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + int vector_data_size() const; + void clear_vector_data(); + ::milvus::grpc::VectorFieldRecord* mutable_vector_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >* + mutable_vector_data(); + const ::milvus::grpc::VectorFieldRecord& vector_data(int index) const; + ::milvus::grpc::VectorFieldRecord* add_vector_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >& + vector_data() const; // .milvus.grpc.Status status = 1; bool has_status() const; @@ -6864,11 +6885,6 @@ class HEntity : ::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); - // int64 row_num = 5; void clear_row_num(); ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; @@ -6879,11 +6895,14 @@ class HEntity : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_; + mutable std::atomic _entity_id_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField field_names_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue > result_values_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attr_records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField data_types_; + mutable std::atomic _data_types_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord > attr_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord > vector_data_; ::milvus::grpc::Status* status_; - ::PROTOBUF_NAMESPACE_ID::int64 entity_id_; ::PROTOBUF_NAMESPACE_ID::int64 row_num_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -7003,23 +7022,13 @@ class HQueryResult : // accessors ------------------------------------------------------- enum : int { - kEntitiesFieldNumber = 2, kScoreFieldNumber = 4, kDistanceFieldNumber = 5, + kExtraParamsFieldNumber = 6, kStatusFieldNumber = 1, + kEntityFieldNumber = 2, 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(); @@ -7042,6 +7051,17 @@ class HQueryResult : ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* mutable_distance(); + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + 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; + // .milvus.grpc.Status status = 1; bool has_status() const; void clear_status(); @@ -7050,6 +7070,14 @@ class HQueryResult : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); + // .milvus.grpc.HEntity entity = 2; + bool has_entity() const; + void clear_entity(); + const ::milvus::grpc::HEntity& entity() const; + ::milvus::grpc::HEntity* release_entity(); + ::milvus::grpc::HEntity* mutable_entity(); + void set_allocated_entity(::milvus::grpc::HEntity* entity); + // int64 row_num = 3; void clear_row_num(); ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; @@ -7060,12 +7088,13 @@ class HQueryResult : 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_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; ::milvus::grpc::Status* status_; + ::milvus::grpc::HEntity* entity_; ::PROTOBUF_NAMESPACE_ID::int64 row_num_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -7189,7 +7218,7 @@ class HInsertParam : kExtraParamsFieldNumber = 5, kCollectionNameFieldNumber = 1, kPartitionTagFieldNumber = 2, - kEntitiesFieldNumber = 3, + kEntityFieldNumber = 3, }; // repeated int64 entity_id_array = 4; int entity_id_array_size() const; @@ -7235,13 +7264,13 @@ class HInsertParam : 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); + // .milvus.grpc.HEntity entity = 3; + bool has_entity() const; + void clear_entity(); + const ::milvus::grpc::HEntity& entity() const; + ::milvus::grpc::HEntity* release_entity(); + ::milvus::grpc::HEntity* mutable_entity(); + void set_allocated_entity(::milvus::grpc::HEntity* entity); // @@protoc_insertion_point(class_scope:milvus.grpc.HInsertParam) private: @@ -7253,7 +7282,7 @@ class HInsertParam : ::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_; + ::milvus::grpc::HEntity* entity_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -7372,9 +7401,20 @@ class HEntityIdentity : // accessors ------------------------------------------------------- enum : int { - kCollectionNameFieldNumber = 1, kIdFieldNumber = 2, + kCollectionNameFieldNumber = 1, }; + // repeated int64 id = 2; + int id_size() const; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::int64 id(int index) const; + void set_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id(); + // string collection_name = 1; void clear_collection_name(); const std::string& collection_name() const; @@ -7386,18 +7426,14 @@ class HEntityIdentity : 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::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_; + mutable std::atomic _id_cached_byte_size_; ::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; }; @@ -10884,35 +10920,35 @@ FieldParam::extra_params() const { // ------------------------------------------------------------------- -// VectorFieldValue +// VectorFieldRecord // repeated .milvus.grpc.RowRecord value = 1; -inline int VectorFieldValue::value_size() const { +inline int VectorFieldRecord::value_size() const { return value_.size(); } -inline void VectorFieldValue::clear_value() { +inline void VectorFieldRecord::clear_value() { value_.Clear(); } -inline ::milvus::grpc::RowRecord* VectorFieldValue::mutable_value(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldValue.value) +inline ::milvus::grpc::RowRecord* VectorFieldRecord::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldRecord.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) +VectorFieldRecord::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldRecord.value) return &value_; } -inline const ::milvus::grpc::RowRecord& VectorFieldValue::value(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldValue.value) +inline const ::milvus::grpc::RowRecord& VectorFieldRecord::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldRecord.value) return value_.Get(index); } -inline ::milvus::grpc::RowRecord* VectorFieldValue::add_value() { - // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldValue.value) +inline ::milvus::grpc::RowRecord* VectorFieldRecord::add_value() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldRecord.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) +VectorFieldRecord::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldRecord.value) return value_; } @@ -10920,36 +10956,7 @@ VectorFieldValue::value() const { // 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; +// int64 int64_value = 1; inline bool FieldValue::has_int64_value() const { return value_case() == kInt64Value; } @@ -10978,36 +10985,7 @@ inline void FieldValue::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 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; +// double double_value = 2; inline bool FieldValue::has_double_value() const { return value_case() == kDoubleValue; } @@ -11036,7 +11014,7 @@ inline void FieldValue::set_double_value(double value) { // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.double_value) } -// string string_value = 5; +// string string_value = 3; inline bool FieldValue::has_string_value() const { return value_case() == kStringValue; } @@ -11126,7 +11104,7 @@ inline void FieldValue::set_allocated_string_value(std::string* string_value) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.string_value) } -// bool bool_value = 6; +// bool bool_value = 4; inline bool FieldValue::has_bool_value() const { return value_case() == kBoolValue; } @@ -11155,7 +11133,7 @@ inline void FieldValue::set_bool_value(bool value) { // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.bool_value) } -// .milvus.grpc.VectorFieldValue vector_value = 7; +// .milvus.grpc.VectorFieldRecord vector_value = 5; inline bool FieldValue::has_vector_value() const { return value_case() == kVectorValue; } @@ -11168,28 +11146,28 @@ inline void FieldValue::clear_vector_value() { clear_has_value(); } } -inline ::milvus::grpc::VectorFieldValue* FieldValue::release_vector_value() { +inline ::milvus::grpc::VectorFieldRecord* 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_; + ::milvus::grpc::VectorFieldRecord* temp = value_.vector_value_; value_.vector_value_ = nullptr; return temp; } else { return nullptr; } } -inline const ::milvus::grpc::VectorFieldValue& FieldValue::vector_value() const { +inline const ::milvus::grpc::VectorFieldRecord& 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_); + : *reinterpret_cast< ::milvus::grpc::VectorFieldRecord*>(&::milvus::grpc::_VectorFieldRecord_default_instance_); } -inline ::milvus::grpc::VectorFieldValue* FieldValue::mutable_vector_value() { +inline ::milvus::grpc::VectorFieldRecord* FieldValue::mutable_vector_value() { if (!has_vector_value()) { clear_value(); set_has_vector_value(); - value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >( + value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldRecord >( GetArenaNoVirtual()); } // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.vector_value) @@ -11483,58 +11461,67 @@ inline void TermQuery::set_allocated_field_name(std::string* field_name) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name) } -// bytes values = 2; -inline void TermQuery::clear_values() { - values_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// repeated int64 int_value = 2; +inline int TermQuery::int_value_size() const { + return int_value_.size(); } -inline const std::string& TermQuery::values() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.values) - return values_.GetNoArena(); +inline void TermQuery::clear_int_value() { + int_value_.Clear(); } -inline void TermQuery::set_values(const std::string& value) { - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) +inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::int_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.int_value) + return int_value_.Get(index); } -inline void TermQuery::set_values(std::string&& value) { - - values_.SetNoArena( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.values) +inline void TermQuery::set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.int_value) } -inline void TermQuery::set_values(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.values) +inline void TermQuery::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.int_value) } -inline void TermQuery::set_values(const void* value, size_t size) { - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.values) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +TermQuery::int_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.int_value) + return int_value_; } -inline std::string* TermQuery::mutable_values() { - - // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.values) - return values_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +TermQuery::mutable_int_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.int_value) + return &int_value_; } -inline std::string* TermQuery::release_values() { - // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.values) - - return values_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + +// repeated double double_value = 3; +inline int TermQuery::double_value_size() const { + return double_value_.size(); } -inline void TermQuery::set_allocated_values(std::string* values) { - if (values != nullptr) { - - } else { - - } - values_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), values); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.values) +inline void TermQuery::clear_double_value() { + double_value_.Clear(); +} +inline double TermQuery::double_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.double_value) + return double_value_.Get(index); +} +inline void TermQuery::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.double_value) +} +inline void TermQuery::add_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.double_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +TermQuery::double_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.double_value) + return double_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +TermQuery::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.double_value) + return &double_value_; } -// int64 value_num = 3; +// int64 value_num = 4; inline void TermQuery::clear_value_num() { value_num_ = PROTOBUF_LONGLONG(0); } @@ -11548,7 +11535,7 @@ inline void TermQuery::set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value) { // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.value_num) } -// float boost = 4; +// float boost = 5; inline void TermQuery::clear_boost() { boost_ = 0; } @@ -11562,7 +11549,7 @@ inline void TermQuery::set_boost(float value) { // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost) } -// repeated .milvus.grpc.KeyValuePair extra_params = 5; +// repeated .milvus.grpc.KeyValuePair extra_params = 6; inline int TermQuery::extra_params_size() const { return extra_params_.size(); } @@ -12483,69 +12470,64 @@ inline void HSearchInSegmentsParam::set_allocated_search_param(::milvus::grpc::H // AttrRecord -// repeated string value = 1; -inline int AttrRecord::value_size() const { - return value_.size(); +// repeated int64 int_value = 1; +inline int AttrRecord::int_value_size() const { + return int_value_.size(); } -inline void AttrRecord::clear_value() { - value_.Clear(); +inline void AttrRecord::clear_int_value() { + int_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 ::PROTOBUF_NAMESPACE_ID::int64 AttrRecord::int_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.int_value) + return int_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_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.int_value) } -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::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.int_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 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +AttrRecord::int_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.int_value) + return int_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 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +AttrRecord::mutable_int_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.int_value) + return &int_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) + +// repeated double double_value = 2; +inline int AttrRecord::double_value_size() const { + return double_value_.size(); } -inline std::string* AttrRecord::add_value() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.AttrRecord.value) - return value_.Add(); +inline void AttrRecord::clear_double_value() { + double_value_.Clear(); } -inline void AttrRecord::add_value(const std::string& value) { - value_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +inline double AttrRecord::double_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.double_value) + return double_value_.Get(index); } -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::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.double_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_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.double_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::RepeatedField< double >& +AttrRecord::double_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.double_value) + return double_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_; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +AttrRecord::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.double_value) + return &double_value_; } // ------------------------------------------------------------------- @@ -12597,19 +12579,35 @@ inline void HEntity::set_allocated_status(::milvus::grpc::Status* status) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntity.status) } -// int64 entity_id = 2; +// repeated int64 entity_id = 2; +inline int HEntity::entity_id_size() const { + return entity_id_.size(); +} inline void HEntity::clear_entity_id() { - entity_id_ = PROTOBUF_LONGLONG(0); + entity_id_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id() const { +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id(int index) const { // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.entity_id) - return entity_id_; + return entity_id_.Get(index); } -inline void HEntity::set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { - - entity_id_ = value; +inline void HEntity::set_entity_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_.Set(index, value); // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.entity_id) } +inline void HEntity::add_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.entity_id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntity::entity_id() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.entity_id) + return entity_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntity::mutable_entity_id() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.entity_id) + return &entity_id_; +} // repeated string field_names = 3; inline int HEntity::field_names_size() const { @@ -12676,55 +12674,34 @@ HEntity::mutable_field_names() { return &field_names_; } -// bytes attr_records = 4; -inline void HEntity::clear_attr_records() { - attr_records_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} -inline const std::string& HEntity::attr_records() const { - // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_records) - return attr_records_.GetNoArena(); +// repeated .milvus.grpc.DataType data_types = 4; +inline int HEntity::data_types_size() const { + return data_types_.size(); } -inline void HEntity::set_attr_records(const std::string& value) { - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.attr_records) -} -inline void HEntity::set_attr_records(std::string&& value) { - - attr_records_.SetNoArena( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HEntity.attr_records) +inline void HEntity::clear_data_types() { + data_types_.Clear(); } -inline void HEntity::set_attr_records(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntity.attr_records) +inline ::milvus::grpc::DataType HEntity::data_types(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.data_types) + return static_cast< ::milvus::grpc::DataType >(data_types_.Get(index)); } -inline void HEntity::set_attr_records(const void* value, size_t size) { - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntity.attr_records) +inline void HEntity::set_data_types(int index, ::milvus::grpc::DataType value) { + data_types_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.data_types) } -inline std::string* HEntity::mutable_attr_records() { - - // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_records) - return attr_records_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void HEntity::add_data_types(::milvus::grpc::DataType value) { + data_types_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.data_types) } -inline std::string* HEntity::release_attr_records() { - // @@protoc_insertion_point(field_release:milvus.grpc.HEntity.attr_records) - - return attr_records_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +HEntity::data_types() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.data_types) + return data_types_; } -inline void HEntity::set_allocated_attr_records(std::string* attr_records) { - if (attr_records != nullptr) { - - } else { - - } - attr_records_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), attr_records); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntity.attr_records) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +HEntity::mutable_data_types() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.data_types) + return &data_types_; } // int64 row_num = 5; @@ -12741,34 +12718,64 @@ inline void HEntity::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) { // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.row_num) } -// repeated .milvus.grpc.FieldValue result_values = 6; -inline int HEntity::result_values_size() const { - return result_values_.size(); +// repeated .milvus.grpc.AttrRecord attr_data = 6; +inline int HEntity::attr_data_size() const { + return attr_data_.size(); } -inline void HEntity::clear_result_values() { - result_values_.Clear(); +inline void HEntity::clear_attr_data() { + attr_data_.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 ::milvus::grpc::AttrRecord* HEntity::mutable_attr_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_data) + return attr_data_.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 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* +HEntity::mutable_attr_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.attr_data) + return &attr_data_; } -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 const ::milvus::grpc::AttrRecord& HEntity::attr_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_data) + return attr_data_.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 ::milvus::grpc::AttrRecord* HEntity::add_attr_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.attr_data) + return attr_data_.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_; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& +HEntity::attr_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.attr_data) + return attr_data_; +} + +// repeated .milvus.grpc.VectorFieldRecord vector_data = 7; +inline int HEntity::vector_data_size() const { + return vector_data_.size(); +} +inline void HEntity::clear_vector_data() { + vector_data_.Clear(); +} +inline ::milvus::grpc::VectorFieldRecord* HEntity::mutable_vector_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.vector_data) + return vector_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >* +HEntity::mutable_vector_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.vector_data) + return &vector_data_; +} +inline const ::milvus::grpc::VectorFieldRecord& HEntity::vector_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.vector_data) + return vector_data_.Get(index); +} +inline ::milvus::grpc::VectorFieldRecord* HEntity::add_vector_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.vector_data) + return vector_data_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >& +HEntity::vector_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.vector_data) + return vector_data_; } // ------------------------------------------------------------------- @@ -12820,34 +12827,55 @@ inline void HQueryResult::set_allocated_status(::milvus::grpc::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(); +// .milvus.grpc.HEntity entity = 2; +inline bool HQueryResult::has_entity() const { + return this != internal_default_instance() && entity_ != nullptr; } -inline ::milvus::grpc::HEntity* HQueryResult::mutable_entities(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entities) - return entities_.Mutable(index); +inline void HQueryResult::clear_entity() { + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; + } + entity_ = nullptr; } -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::entity() const { + const ::milvus::grpc::HEntity* p = entity_; + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.entity) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HEntity_default_instance_); } -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::release_entity() { + // @@protoc_insertion_point(field_release:milvus.grpc.HQueryResult.entity) + + ::milvus::grpc::HEntity* temp = entity_; + entity_ = nullptr; + return temp; } -inline ::milvus::grpc::HEntity* HQueryResult::add_entities() { - // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.entities) - return entities_.Add(); +inline ::milvus::grpc::HEntity* HQueryResult::mutable_entity() { + + if (entity_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); + entity_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entity) + return entity_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& -HQueryResult::entities() const { - // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.entities) - return entities_; +inline void HQueryResult::set_allocated_entity(::milvus::grpc::HEntity* entity) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete entity_; + } + if (entity) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + entity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entity, submessage_arena); + } + + } else { + + } + entity_ = entity; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HQueryResult.entity) } // int64 row_num = 3; @@ -12924,6 +12952,36 @@ HQueryResult::mutable_distance() { return &distance_; } +// repeated .milvus.grpc.KeyValuePair extra_params = 6; +inline int HQueryResult::extra_params_size() const { + return extra_params_.size(); +} +inline void HQueryResult::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HQueryResult::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HQueryResult::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HQueryResult::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HQueryResult::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HQueryResult::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.extra_params) + return extra_params_; +} + // ------------------------------------------------------------------- // HInsertParam @@ -13030,55 +13088,55 @@ inline void HInsertParam::set_allocated_partition_tag(std::string* 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; +// .milvus.grpc.HEntity entity = 3; +inline bool HInsertParam::has_entity() const { + return this != internal_default_instance() && entity_ != nullptr; } -inline void HInsertParam::clear_entities() { - if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { - delete entities_; +inline void HInsertParam::clear_entity() { + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; } - entities_ = nullptr; + entity_ = nullptr; } -inline const ::milvus::grpc::HEntity& HInsertParam::entities() const { - const ::milvus::grpc::HEntity* p = entities_; - // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entities) +inline const ::milvus::grpc::HEntity& HInsertParam::entity() const { + const ::milvus::grpc::HEntity* p = entity_; + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entity) 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) +inline ::milvus::grpc::HEntity* HInsertParam::release_entity() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.entity) - ::milvus::grpc::HEntity* temp = entities_; - entities_ = nullptr; + ::milvus::grpc::HEntity* temp = entity_; + entity_ = nullptr; return temp; } -inline ::milvus::grpc::HEntity* HInsertParam::mutable_entities() { +inline ::milvus::grpc::HEntity* HInsertParam::mutable_entity() { - if (entities_ == nullptr) { + if (entity_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); - entities_ = p; + entity_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entities) - return entities_; + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entity) + return entity_; } -inline void HInsertParam::set_allocated_entities(::milvus::grpc::HEntity* entities) { +inline void HInsertParam::set_allocated_entity(::milvus::grpc::HEntity* entity) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { - delete entities_; + delete entity_; } - if (entities) { + if (entity) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; if (message_arena != submessage_arena) { - entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, entities, submessage_arena); + entity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entity, submessage_arena); } } else { } - entities_ = entities; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entities) + entity_ = entity; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entity) } // repeated int64 entity_id_array = 4; @@ -13196,19 +13254,35 @@ inline void HEntityIdentity::set_allocated_collection_name(std::string* collecti // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntityIdentity.collection_name) } -// int64 id = 2; +// repeated int64 id = 2; +inline int HEntityIdentity::id_size() const { + return id_.size(); +} inline void HEntityIdentity::clear_id() { - id_ = PROTOBUF_LONGLONG(0); + id_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id() const { +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id(int index) const { // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.id) - return id_; + return id_.Get(index); } -inline void HEntityIdentity::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) { - - id_ = value; +inline void HEntityIdentity::set_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_.Set(index, value); // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.id) } +inline void HEntityIdentity::add_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntityIdentity.id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntityIdentity::id() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntityIdentity.id) + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntityIdentity::mutable_id() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntityIdentity.id) + return &id_; +} // ------------------------------------------------------------------- diff --git a/core/src/grpc/milvus.proto b/core/src/grpc/milvus.proto index 12630803..e5582800 100644 --- a/core/src/grpc/milvus.proto +++ b/core/src/grpc/milvus.proto @@ -253,19 +253,17 @@ message FieldParam { repeated KeyValuePair extra_params = 4; } -message VectorFieldValue { +message VectorFieldRecord { 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; + int64 int64_value = 1; + double double_value = 2; + string string_value = 3; + bool bool_value = 4; + VectorFieldRecord vector_value = 5; } } @@ -287,10 +285,11 @@ message MappingList { message TermQuery { string field_name = 1; - bytes values = 2; - int64 value_num = 3; - float boost = 4; - repeated KeyValuePair extra_params = 5; + repeated int64 int_value = 2; + repeated double double_value = 3; + int64 value_num = 4; + float boost = 5; + repeated KeyValuePair extra_params = 6; } enum CompareOperator { @@ -358,37 +357,40 @@ message HSearchInSegmentsParam { /////////////////////////////////////////////////////////////////// message AttrRecord { - repeated string value = 1; + repeated int64 int_value = 1; + repeated double double_value = 2; } message HEntity { Status status = 1; - int64 entity_id = 2; + repeated int64 entity_id = 2; repeated string field_names = 3; - bytes attr_records = 4; + repeated DataType data_types = 4; int64 row_num = 5; - repeated FieldValue result_values = 6; + repeated AttrRecord attr_data = 6; + repeated VectorFieldRecord vector_data = 7; } message HQueryResult { Status status = 1; - repeated HEntity entities = 2; + HEntity entity = 2; int64 row_num = 3; repeated float score = 4; repeated float distance = 5; + repeated KeyValuePair extra_params = 6; } message HInsertParam { string collection_name = 1; string partition_tag = 2; - HEntity entities = 3; + HEntity entity = 3; repeated int64 entity_id_array = 4; repeated KeyValuePair extra_params = 5; } message HEntityIdentity { string collection_name = 1; - int64 id = 2; + repeated int64 id = 2; } message HEntityIDs { @@ -672,12 +674,11 @@ service MilvusService { rpc InsertEntity(HInsertParam) returns (HEntityIDs) {} - // TODO(yukun): will change to HQueryResult - rpc HybridSearch(HSearchParam) returns (TopKQueryResult) {} + rpc HybridSearch(HSearchParam) returns (HQueryResult) {} rpc HybridSearchInSegments(HSearchInSegmentsParam) returns (TopKQueryResult) {} - rpc GetEntityByID(HEntityIdentity) returns (HEntity) {} + rpc GetEntityByID(VectorsIdentity) returns (HEntity) {} rpc GetEntityIDs(HGetEntityIDsParam) returns (HEntityIDs) {} diff --git a/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.cpp b/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.cpp index f0cec5ac..c4bf7965 100644 --- a/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.cpp +++ b/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.cpp @@ -22,6 +22,156 @@ namespace faiss { ConcurrentBitset::ConcurrentBitset(id_type_t capacity) : capacity_(capacity), bitset_((capacity + 8 - 1) >> 3) { } +std::vector>& +ConcurrentBitset::bitset() { + return bitset_; +} + +ConcurrentBitset& +ConcurrentBitset::operator&=(ConcurrentBitset& bitset) { + // for (id_type_t i = 0; i < ((capacity_ + 8 -1) >> 3); ++i) { + // bitset_[i].fetch_and(bitset.bitset()[i].load()); + // } + + auto u8_1 = const_cast(data()); + auto u8_2 = const_cast(bitset.data()); + auto u64_1 = reinterpret_cast(u8_1); + auto u64_2 = reinterpret_cast(u8_2); + + size_t n8 = bitset_.size(); + size_t n64 = n8 / 8; + + for (size_t i = 0; i < n64; i++) { + u64_1[i] &= u64_2[i]; + } + + size_t remain = n8 % 8; + u8_1 += n64 * 8; + u8_2 += n64 * 8; + for (size_t i = 0; i < remain; i++) { + u8_1[i] &= u8_2[i]; + } + + return *this; +} + +std::shared_ptr +ConcurrentBitset::operator&(std::shared_ptr& bitset) { + auto result_bitset = std::make_shared(bitset->capacity()); + + auto result_8 = const_cast(result_bitset->data()); + auto result_64 = reinterpret_cast(result_8); + + auto u8_1 = const_cast(data()); + auto u8_2 = const_cast(bitset->data()); + auto u64_1 = reinterpret_cast(u8_1); + auto u64_2 = reinterpret_cast(u8_2); + + size_t n8 = bitset_.size(); + size_t n64 = n8 / 8; + + for (size_t i = 0; i < n64; i++) { + result_64[i] = u64_1[i] & u64_2[i]; + } + + size_t remain = n8 % 8; + u8_1 += n64 * 8; + u8_2 += n64 * 8; + result_8 += n64 * 8; + for (size_t i = 0; i < remain; i++) { + result_8[i] = u8_1[i] & u8_2[i]; + } + + + return result_bitset; +} + +ConcurrentBitset& +ConcurrentBitset::operator|=(ConcurrentBitset& bitset) { + // for (id_type_t i = 0; i < ((capacity_ + 8 -1) >> 3); ++i) { + // bitset_[i].fetch_or(bitset.bitset()[i].load()); + // } + + auto u8_1 = const_cast(data()); + auto u8_2 = const_cast(bitset.data()); + auto u64_1 = reinterpret_cast(u8_1); + auto u64_2 = reinterpret_cast(u8_2); + + size_t n8 = bitset_.size(); + size_t n64 = n8 / 8; + + for (size_t i = 0; i < n64; i++) { + u64_1[i] &= u64_2[i]; + } + + size_t remain = n8 % 8; + u8_1 += n64 * 8; + u8_2 += n64 * 8; + for (size_t i = 0; i < remain; i++) { + u8_1[i] |= u8_2[i]; + } + + return *this; +} + +std::shared_ptr +ConcurrentBitset::operator|(std::shared_ptr& bitset) { + auto result_bitset = std::make_shared(bitset->capacity()); + + auto result_8 = const_cast(result_bitset->data()); + auto result_64 = reinterpret_cast(result_8); + + auto u8_1 = const_cast(data()); + auto u8_2 = const_cast(bitset->data()); + auto u64_1 = reinterpret_cast(u8_1); + auto u64_2 = reinterpret_cast(u8_2); + + size_t n8 = bitset_.size(); + size_t n64 = n8 / 8; + + for (size_t i = 0; i < n64; i++) { + result_64[i] = u64_1[i] & u64_2[i]; + } + + size_t remain = n8 % 8; + u8_1 += n64 * 8; + u8_2 += n64 * 8; + result_8 += n64 * 8; + for (size_t i = 0; i < remain; i++) { + result_8[i] = u8_1[i] | u8_2[i]; + } + + return result_bitset; +} + +ConcurrentBitset& +ConcurrentBitset::operator^=(ConcurrentBitset& bitset) { + // for (id_type_t i = 0; i < ((capacity_ + 8 -1) >> 3); ++i) { + // bitset_[i].fetch_xor(bitset.bitset()[i].load()); + // } + + auto u8_1 = const_cast(data()); + auto u8_2 = const_cast(bitset.data()); + auto u64_1 = reinterpret_cast(u8_1); + auto u64_2 = reinterpret_cast(u8_2); + + size_t n8 = bitset_.size(); + size_t n64 = n8 / 8; + + for (size_t i = 0; i < n64; i++) { + u64_1[i] &= u64_2[i]; + } + + size_t remain = n8 % 8; + u8_1 += n64 * 8; + u8_2 += n64 * 8; + for (size_t i = 0; i < remain; i++) { + u8_1[i] ^= u8_2[i]; + } + + return *this; +} + bool ConcurrentBitset::test(id_type_t id) { return bitset_[id >> 3].load() & (0x1 << (id & 0x7)); diff --git a/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.h b/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.h index 4ccdc7c8..6b682904 100644 --- a/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.h +++ b/core/src/index/thirdparty/faiss/utils/ConcurrentBitset.h @@ -33,6 +33,24 @@ class ConcurrentBitset { // ConcurrentBitset& // operator=(const ConcurrentBitset&) = delete; + std::vector>& + bitset(); + + ConcurrentBitset& + operator&=(ConcurrentBitset& bitset); + + std::shared_ptr + operator&(std::shared_ptr& bitset); + + ConcurrentBitset& + operator|=(ConcurrentBitset& bitset); + + std::shared_ptr + operator|(std::shared_ptr& bitset); + + ConcurrentBitset& + operator^=(ConcurrentBitset& bitset); + bool test(id_type_t id); @@ -54,7 +72,6 @@ class ConcurrentBitset { private: size_t capacity_; std::vector> bitset_; - }; using ConcurrentBitsetPtr = std::shared_ptr; diff --git a/core/src/query/BinaryQuery.cpp b/core/src/query/BinaryQuery.cpp index 21d1cda9..29f36066 100644 --- a/core/src/query/BinaryQuery.cpp +++ b/core/src/query/BinaryQuery.cpp @@ -64,7 +64,7 @@ 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 + // Put VectorQuery to the end of leaf queries auto query_size = query->getLeafQueries().size(); for (uint64_t i = 0; i < query_size; ++i) { if (query->getLeafQueries()[i]->vector_query != nullptr) { @@ -211,9 +211,8 @@ BinaryQueryHeight(BinaryQueryPtr& binary_query) { bool ValidateBinaryQuery(BinaryQueryPtr& binary_query) { - // Only for one layer BooleanQuery uint64_t height = BinaryQueryHeight(binary_query); - return height > 1 && height < 4; + return height > 1; } } // namespace query diff --git a/core/src/scheduler/task/SearchTask.cpp b/core/src/scheduler/task/SearchTask.cpp index b1ee3f00..70a8e22a 100644 --- a/core/src/scheduler/task/SearchTask.cpp +++ b/core/src/scheduler/task/SearchTask.cpp @@ -267,8 +267,7 @@ XSearchTask::Execute() { 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); + s = index_engine_->HybridSearch(general_query, types, nq, topk, output_distance, output_ids); if (!s.ok()) { search_job->GetStatus() = s; diff --git a/core/src/segment/SegmentReader.cpp b/core/src/segment/SegmentReader.cpp index d717bf86..4a154df0 100644 --- a/core/src/segment/SegmentReader.cpp +++ b/core/src/segment/SegmentReader.cpp @@ -73,6 +73,21 @@ SegmentReader::LoadVectors(off_t offset, size_t num_bytes, std::vector& return Status::OK(); } +Status +SegmentReader::LoadAttrs(const std::string& field_name, off_t offset, size_t num_bytes, + std::vector& raw_attrs) { + codec::DefaultCodec default_codec; + try { + fs_ptr_->operation_ptr_->CreateDirectory(); + default_codec.GetAttrsFormat()->read_attrs(fs_ptr_, field_name, offset, num_bytes, raw_attrs); + } catch (std::exception& e) { + std::string err_msg = "Failed to load raw attributes: " + std::string(e.what()); + LOG_ENGINE_ERROR_ << err_msg; + return Status(DB_ERROR, err_msg); + } + return Status::OK(); +} + Status SegmentReader::LoadUids(std::vector& uids) { codec::DefaultCodec default_codec; diff --git a/core/src/segment/SegmentReader.h b/core/src/segment/SegmentReader.h index d260bbc3..a69b1f36 100644 --- a/core/src/segment/SegmentReader.h +++ b/core/src/segment/SegmentReader.h @@ -42,6 +42,9 @@ class SegmentReader { Status LoadVectors(off_t offset, size_t num_bytes, std::vector& raw_vectors); + Status + LoadAttrs(const std::string& field_name, off_t offset, size_t num_bytes, std::vector& raw_attrs); + Status LoadUids(std::vector& uids); diff --git a/core/src/server/delivery/RequestHandler.cpp b/core/src/server/delivery/RequestHandler.cpp index ac3d2341..0fb64e98 100644 --- a/core/src/server/delivery/RequestHandler.cpp +++ b/core/src/server/delivery/RequestHandler.cpp @@ -42,6 +42,7 @@ #include "server/delivery/hybrid_request/CreateHybridCollectionRequest.h" #include "server/delivery/hybrid_request/DescribeHybridCollectionRequest.h" +#include "server/delivery/hybrid_request/GetEntityByIDRequest.h" #include "server/delivery/hybrid_request/HybridSearchRequest.h" #include "server/delivery/hybrid_request/InsertEntityRequest.h" @@ -304,13 +305,26 @@ RequestHandler::InsertEntity(const std::shared_ptr& context, const std: return request_ptr->status(); } +Status +RequestHandler::GetEntityByID(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& ids, std::vector& attrs, + std::vector& vectors) { + BaseRequestPtr request_ptr = GetEntityByIDRequest::Create(context, collection_name, ids, attrs, vectors); + + 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); + milvus::json& json_params, std::vector& field_names, + engine::QueryResult& result) { + BaseRequestPtr request_ptr = + HybridSearchRequest::Create(context, hybrid_search_context, collection_name, partition_list, general_query, + json_params, field_names, result); + RequestScheduler::ExecRequest(request_ptr); return request_ptr->status(); diff --git a/core/src/server/delivery/RequestHandler.h b/core/src/server/delivery/RequestHandler.h index 8024189d..3fa1e68f 100644 --- a/core/src/server/delivery/RequestHandler.h +++ b/core/src/server/delivery/RequestHandler.h @@ -140,10 +140,16 @@ class RequestHandler { const std::string& partition_tag, uint64_t& row_num, std::vector& field_names, std::vector& attr_values, std::unordered_map& vector_datas); + Status + GetEntityByID(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& ids, std::vector& attrs, + std::vector& vectors); + 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); + query::GeneralQueryPtr& general_query, milvus::json& json_params, + std::vector& field_names, engine::QueryResult& result); }; } // namespace server diff --git a/core/src/server/delivery/hybrid_request/GetEntityByIDRequest.cpp b/core/src/server/delivery/hybrid_request/GetEntityByIDRequest.cpp new file mode 100644 index 00000000..d1eaa83e --- /dev/null +++ b/core/src/server/delivery/hybrid_request/GetEntityByIDRequest.cpp @@ -0,0 +1,97 @@ +// 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 "server/delivery/hybrid_request/GetEntityByIDRequest.h" +#include "server/DBWrapper.h" +#include "utils/Log.h" +#include "utils/TimeRecorder.h" +#include "utils/ValidationUtil.h" + +#include +#include + +namespace milvus { +namespace server { + +constexpr uint64_t MAX_COUNT_RETURNED = 1000; + +GetEntityByIDRequest::GetEntityByIDRequest(const std::shared_ptr& context, + const std::string& collection_name, const std::vector& ids, + std::vector& attrs, + std::vector& vectors) + : BaseRequest(context, BaseRequest::kGetVectorByID), + collection_name_(collection_name), + ids_(ids), + attrs_(attrs), + vectors_(vectors) { +} + +BaseRequestPtr +GetEntityByIDRequest::Create(const std::shared_ptr& context, + const std::string& collection_name, const std::vector& ids, + std::vector& attrs, std::vector& vectors) { + return std::shared_ptr(new GetEntityByIDRequest(context, collection_name, ids, attrs, vectors)); +} + +Status +GetEntityByIDRequest::OnExecute() { + try { + std::string hdr = "GetEntitiesByIDRequest(collection=" + collection_name_ + ")"; + TimeRecorderAuto rc(hdr); + + // step 1: check arguments + if (ids_.empty()) { + return Status(SERVER_INVALID_ARGUMENT, "No entity id specified"); + } + + if (ids_.size() > MAX_COUNT_RETURNED) { + std::string msg = "Input id array size cannot exceed: " + std::to_string(MAX_COUNT_RETURNED); + return Status(SERVER_INVALID_ARGUMENT, msg); + } + + auto status = ValidationUtil::ValidateCollectionName(collection_name_); + if (!status.ok()) { + return status; + } + + // only process root collection, ignore partition collection + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_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_)); + } + } + + // step 2: get vector data, now only support get one id + return DBWrapper::DB()->GetEntitiesByID(collection_name_, ids_, vectors_, attrs_); + } 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/GetEntityByIDRequest.h b/core/src/server/delivery/hybrid_request/GetEntityByIDRequest.h new file mode 100644 index 00000000..fcf5d141 --- /dev/null +++ b/core/src/server/delivery/hybrid_request/GetEntityByIDRequest.h @@ -0,0 +1,52 @@ +// 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 "server/delivery/request/BaseRequest.h" + +#include +#include +#include + +namespace milvus { +namespace server { + +class GetEntityByIDRequest : public BaseRequest { + public: + static BaseRequestPtr + Create(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& ids, std::vector& attrs, + std::vector& vectors); + + protected: + GetEntityByIDRequest(const std::shared_ptr& context, const std::string& collection_name, + const std::vector& ids, std::vector& attrs, + std::vector& vectors); + + Status + OnExecute() override; + + private: + std::string collection_name_; + std::vector ids_; + std::vector& attrs_; + std::vector& vectors_; +}; + +} // namespace server +} // namespace milvus diff --git a/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp b/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp index 7e768b27..9cffe607 100644 --- a/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp +++ b/core/src/server/delivery/hybrid_request/HybridSearchRequest.cpp @@ -33,12 +33,14 @@ 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) + milvus::query::GeneralQueryPtr& general_query, milvus::json& json_params, + std::vector& field_names, engine::QueryResult& result) : BaseRequest(context, BaseRequest::kHybridSearch), - hybrid_search_contxt_(hybrid_search_context), + hybrid_search_context_(hybrid_search_context), collection_name_(collection_name), partition_list_(partition_list), general_query_(general_query), + field_names_(field_names), result_(result) { } @@ -46,9 +48,11 @@ 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) { + milvus::json& json_params, std::vector& field_names, + engine::QueryResult& result) { return std::shared_ptr(new HybridSearchRequest(context, hybrid_search_context, collection_name, - partition_list, general_query, result)); + partition_list, general_query, json_params, field_names, + result)); } Status @@ -85,18 +89,25 @@ HybridSearchRequest::OnExecute() { } std::unordered_map attr_type; - for (uint64_t i = 0; i < fields_schema.fields_schema_.size(); ++i) { + for (auto& field_schema : fields_schema.fields_schema_) { attr_type.insert( - std::make_pair(fields_schema.fields_schema_[i].field_name_, - (engine::meta::hybrid::DataType)fields_schema.fields_schema_[i].field_type_)); + std::make_pair(field_schema.field_name_, (engine::meta::hybrid::DataType)field_schema.field_type_)); } - engine::ResultIds result_ids; - engine::ResultDistances result_distances; - uint64_t nq; + if (json_params.contains("field_names")) { + if (json_params["field_names"].is_array()) { + for (auto& name : json_params["field_names"]) { + field_names_.emplace_back(name.get()); + } + } + } else { + for (auto& field_schema : fields_schema.fields_schema_) { + field_names_.emplace_back(field_schema.field_name_); + } + } - status = DBWrapper::DB()->HybridQuery(context_, collection_name_, partition_list_, hybrid_search_contxt_, - general_query_, attr_type, nq, result_ids, result_distances); + status = DBWrapper::DB()->HybridQuery(context_, collection_name_, partition_list_, hybrid_search_context_, + general_query_, field_names_, attr_type, result_); #ifdef ENABLE_CPU_PROFILING ProfilerStop(); @@ -106,18 +117,14 @@ HybridSearchRequest::OnExecute() { if (!status.ok()) { return status; } - fiu_do_on("SearchRequest.OnExecute.empty_result_ids", result_ids.clear()); - if (result_ids.empty()) { + fiu_do_on("SearchRequest.OnExecute.empty_result_ids", result_.result_ids_.clear()); + if (result_.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 diff --git a/core/src/server/delivery/hybrid_request/HybridSearchRequest.h b/core/src/server/delivery/hybrid_request/HybridSearchRequest.h index a0f91a50..814335b8 100644 --- a/core/src/server/delivery/hybrid_request/HybridSearchRequest.h +++ b/core/src/server/delivery/hybrid_request/HybridSearchRequest.h @@ -27,23 +27,25 @@ class HybridSearchRequest : public BaseRequest { 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); + milvus::json& json_params, std::vector& field_names, engine::QueryResult& 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); + milvus::json& json_params, std::vector& field_names, engine::QueryResult& result); Status OnExecute() override; private: - context::HybridSearchContextPtr hybrid_search_contxt_; + context::HybridSearchContextPtr hybrid_search_context_; const std::string collection_name_; - std::vector& partition_list_; - milvus::query::GeneralQueryPtr& general_query_; - TopKQueryResult& result_; + std::vector partition_list_; + milvus::query::GeneralQueryPtr general_query_; + milvus::json json_params; + std::vector& field_names_; + engine::QueryResult& result_; }; } // namespace server diff --git a/core/src/server/delivery/request/BaseRequest.cpp b/core/src/server/delivery/request/BaseRequest.cpp index 558d8e30..93378496 100644 --- a/core/src/server/delivery/request/BaseRequest.cpp +++ b/core/src/server/delivery/request/BaseRequest.cpp @@ -40,6 +40,7 @@ RequestGroup(BaseRequest::RequestType type) { {BaseRequest::kGetVectorByID, INFO_REQUEST_GROUP}, {BaseRequest::kGetVectorIDs, INFO_REQUEST_GROUP}, {BaseRequest::kInsertEntity, DDL_DML_REQUEST_GROUP}, + {BaseRequest::kGetEntityByID, INFO_REQUEST_GROUP}, // collection operations {BaseRequest::kShowCollections, INFO_REQUEST_GROUP}, diff --git a/core/src/server/delivery/request/BaseRequest.h b/core/src/server/delivery/request/BaseRequest.h index 8a629942..b94f13e4 100644 --- a/core/src/server/delivery/request/BaseRequest.h +++ b/core/src/server/delivery/request/BaseRequest.h @@ -72,7 +72,9 @@ struct HybridQueryResult { int64_t row_num_; engine::ResultIds id_list_; engine::ResultDistances distance_list_; - engine::Entity entities_; + + std::vector vectors_; + std::vector attrs_; }; struct IndexParam { @@ -118,6 +120,7 @@ class BaseRequest { kGetVectorByID, kGetVectorIDs, kInsertEntity, + kGetEntityByID, // collection operations kShowCollections = 300, diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.cpp b/core/src/server/grpc_impl/GrpcRequestHandler.cpp index 3c1d3122..916619af 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/core/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -149,6 +149,134 @@ ConstructResults(const TopKQueryResult& result, ::milvus::grpc::TopKQueryResult* result.distance_list_.size() * sizeof(float)); } +void +ConstructHEntityResults(const std::vector& attrs, const std::vector& vectors, + std::vector& field_names, ::milvus::grpc::HEntity* response) { + if (!response) { + return; + } + + response->set_row_num(attrs.size()); + if (field_names.size() > 0) { + for (auto& name : field_names) { + response->add_field_names(name); + } + } else { + if (attrs.size() > 0) { + auto attr_it = attrs[0].attr_type_.begin(); + for (; attr_it != attrs[0].attr_type_.end(); attr_it++) { + field_names.emplace_back(attr_it->first); + response->add_field_names(attr_it->first); + } + } + } + + for (uint64_t i = 0; i < field_names.size() - 1; i++) { + auto field_name = field_names[i]; + if (attrs.size() > 0) { + if (attrs[0].attr_type_.find(field_name) != attrs[0].attr_type_.end()) { + response->add_data_types((::milvus::grpc::DataType)attrs[0].attr_type_.at(field_name)); + } + } + auto grpc_attr_data = response->add_attr_data(); + std::vector int_data; + std::vector double_data; + for (auto& attr : attrs) { + auto attr_data = attr.attr_data_.at(field_name); + int64_t grpc_int_data; + double grpc_double_data; + switch (attr.attr_type_.at(field_name)) { + case engine::meta::hybrid::DataType::INT8: { + if (attr_data.size() == sizeof(int8_t)) { + grpc_int_data = attr_data[0]; + int_data.emplace_back(grpc_int_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + case engine::meta::hybrid::DataType::INT16: { + if (attr_data.size() == sizeof(int16_t)) { + memcpy(&grpc_int_data, attr_data.data(), sizeof(int16_t)); + int_data.emplace_back(grpc_int_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + case engine::meta::hybrid::DataType::INT32: { + if (attr_data.size() == sizeof(int32_t)) { + memcpy(&grpc_int_data, attr_data.data(), sizeof(int32_t)); + int_data.emplace_back(grpc_int_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + case engine::meta::hybrid::DataType::INT64: { + if (attr_data.size() == sizeof(int64_t)) { + memcpy(&grpc_int_data, attr_data.data(), sizeof(int64_t)); + int_data.emplace_back(grpc_int_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + case engine::meta::hybrid::DataType::FLOAT: { + if (attr_data.size() == sizeof(float)) { + float float_data; + memcpy(&float_data, attr_data.data(), sizeof(float)); + grpc_double_data = float_data; + double_data.emplace_back(grpc_double_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + case engine::meta::hybrid::DataType::DOUBLE: { + if (attr_data.size() == sizeof(double)) { + memcpy(&grpc_double_data, attr_data.data(), sizeof(double)); + double_data.emplace_back(grpc_double_data); + } else { + response->mutable_status()->set_error_code(::milvus::grpc::ErrorCode::UNEXPECTED_ERROR); + return; + } + break; + } + default: { break; } + } + } + if (int_data.size() > 0) { + grpc_attr_data->mutable_int_value()->Resize(static_cast(int_data.size()), 0); + memcpy(grpc_attr_data->mutable_int_value()->mutable_data(), int_data.data(), + int_data.size() * sizeof(int64_t)); + } else if (double_data.size() > 0) { + grpc_attr_data->mutable_double_value()->Resize(static_cast(double_data.size()), 0.0); + memcpy(grpc_attr_data->mutable_double_value()->mutable_data(), double_data.data(), + double_data.size() * sizeof(double)); + } + } + + ::milvus::grpc::VectorFieldRecord* grpc_vector_data = response->add_vector_data(); + for (auto& vector : vectors) { + auto grpc_data = grpc_vector_data->add_value(); + if (!vector.float_data_.empty()) { + grpc_data->mutable_float_data()->Resize(vector.float_data_.size(), 0); + memcpy(grpc_data->mutable_float_data()->mutable_data(), vector.float_data_.data(), + vector.float_data_.size() * sizeof(float)); + } else if (!vector.binary_data_.empty()) { + grpc_data->mutable_binary_data()->resize(vector.binary_data_.size()); + memcpy(grpc_data->mutable_binary_data()->data(), vector.binary_data_.data(), + vector.binary_data_.size() * sizeof(uint8_t)); + } + } +} + class GrpcConnectionContext : public milvus::server::ConnectionContext { public: explicit GrpcConnectionContext(::grpc::ServerContext* context) : context_(context) { @@ -938,40 +1066,53 @@ GrpcRequestHandler::DescribeHybridCollection(::grpc::ServerContext* context, ::grpc::Status GrpcRequestHandler::InsertEntity(::grpc::ServerContext* context, const ::milvus::grpc::HInsertParam* request, ::milvus::grpc::HEntityIDs* response) { + // engine::VectorsData vectors; + // CopyRowRecords(request->entity().vector_data(0).value(), request->entity_id_array(), vectors); + CHECK_NULLPTR_RETURN(request); LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->RequestID().c_str(), __func__); - auto attr_size = request->entities().attr_records().size(); - std::vector attr_values(attr_size, 0); - std::unordered_map vector_datas; - - memcpy(attr_values.data(), request->entities().attr_records().data(), attr_size); - - uint64_t row_num = request->entities().row_num(); + auto attr_size = request->entity().attr_data().size(); + uint64_t row_num = request->entity().row_num(); + std::vector attr_data(attr_size * row_num * sizeof(int64_t)); + std::unordered_map vector_data; + int64_t offset = 0; + for (uint64_t i = 0; i < attr_size; i++) { + auto grpc_int_size = request->entity().attr_data(i).int_value_size(); + auto grpc_double_size = request->entity().attr_data(i).double_value_size(); + if (grpc_int_size > 0) { + memcpy(attr_data.data() + offset, request->entity().attr_data(i).int_value().data(), + grpc_int_size * sizeof(int64_t)); + offset += grpc_int_size * sizeof(int64_t); + } else if (grpc_double_size > 0) { + memcpy(attr_data.data() + offset, request->entity().attr_data(i).double_value().data(), + grpc_double_size * sizeof(double)); + offset += grpc_double_size * sizeof(double); + } + } std::vector field_names; - auto field_size = request->entities().field_names_size(); + auto field_size = request->entity().field_names_size(); field_names.resize(field_size - 1); for (uint64_t i = 0; i < field_size - 1; ++i) { - field_names[i] = request->entities().field_names(i); + field_names[i] = request->entity().field_names(i); } - auto vector_size = request->entities().result_values_size(); + auto vector_size = request->entity().vector_data_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(field_size - 1), vectors)); + CopyRowRecords(request->entity().vector_data(i).value(), request->entity_id_array(), vectors); + vector_data.insert(std::make_pair(request->entity().field_names(field_size - 1), 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, row_num, - field_names, attr_values, vector_datas); + field_names, attr_data, vector_data); - 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)); + response->mutable_entity_id_array()->Resize(static_cast(vector_data.begin()->second.id_array_.size()), 0); + memcpy(response->mutable_entity_id_array()->mutable_data(), vector_data.begin()->second.id_array_.data(), + vector_data.begin()->second.id_array_.size() * sizeof(int64_t)); LOG_SERVER_INFO_ << LogOut("Request [%s] %s end.", GetContext(context)->RequestID().c_str(), __func__); SET_RESPONSE(response->mutable_status(), status, context); @@ -995,9 +1136,17 @@ DeSerialization(const ::milvus::grpc::GeneralQuery& general_query, query::Boolea query::TermQueryPtr term_query = std::make_shared(); term_query->field_name = query.term_query().field_name(); term_query->boost = query.term_query().boost(); - auto size = query.term_query().values().size(); - term_query->field_value.resize(size); - memcpy(term_query->field_value.data(), query.term_query().values().data(), size); + size_t int_size = query.term_query().int_value_size(); + size_t double_size = query.term_query().double_value_size(); + if (int_size > 0) { + term_query->field_value.resize(int_size * sizeof(int64_t)); + memcpy(term_query->field_value.data(), query.term_query().int_value().data(), + int_size * sizeof(int64_t)); + } else if (double_size > 0) { + term_query->field_value.resize(double_size * sizeof(double)); + memcpy(term_query->field_value.data(), query.term_query().double_value().data(), + double_size * sizeof(double)); + } leaf_query->term_query = term_query; boolean_clause->AddLeafQuery(leaf_query); } @@ -1046,7 +1195,7 @@ DeSerialization(const ::milvus::grpc::GeneralQuery& general_query, query::Boolea ::grpc::Status GrpcRequestHandler::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, - ::milvus::grpc::TopKQueryResult* response) { + ::milvus::grpc::HQueryResult* response) { CHECK_NULLPTR_RETURN(request); LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->RequestID().c_str(), __func__); @@ -1074,13 +1223,56 @@ GrpcRequestHandler::HybridSearch(::grpc::ServerContext* context, const ::milvus: partition_list[i] = request->partition_tag_array(i); } - TopKQueryResult result; + milvus::json json_params; + for (int i = 0; i < request->extra_params_size(); i++) { + const ::milvus::grpc::KeyValuePair& extra = request->extra_params(i); + if (extra.key() == EXTRA_PARAM_KEY) { + json_params = json::parse(extra.value()); + } + } + engine::QueryResult result; + std::vector field_names; status = request_handler_.HybridSearch(GetContext(context), hybrid_search_context, request->collection_name(), - partition_list, general_query, result); + partition_list, general_query, json_params, field_names, result); // step 6: construct and return result - ConstructResults(result, response); + response->set_row_num(result.row_num_); + auto grpc_entity = response->mutable_entity(); + ConstructHEntityResults(result.attrs_, result.vectors_, field_names, grpc_entity); + grpc_entity->mutable_entity_id()->Resize(static_cast(result.result_ids_.size()), 0); + memcpy(grpc_entity->mutable_entity_id()->mutable_data(), result.result_ids_.data(), + result.result_ids_.size() * sizeof(int64_t)); + + response->mutable_distance()->Resize(static_cast(result.result_distances_.size()), 0.0); + memcpy(response->mutable_distance()->mutable_data(), result.result_distances_.data(), + result.result_distances_.size() * sizeof(float)); + + LOG_SERVER_INFO_ << LogOut("Request [%s] %s end.", GetContext(context)->RequestID().c_str(), __func__); + SET_RESPONSE(response->mutable_status(), status, context); + + return ::grpc::Status::OK; +} + +::grpc::Status +GrpcRequestHandler::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* request, + ::milvus::grpc::HEntity* response) { + CHECK_NULLPTR_RETURN(request); + LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->RequestID().c_str(), __func__); + + std::vector vector_ids; + vector_ids.reserve(request->id_array_size()); + for (int i = 0; i < request->id_array_size(); i++) { + vector_ids.push_back(request->id_array(i)); + } + + std::vector attrs; + std::vector vectors; + Status status = + request_handler_.GetEntityByID(GetContext(context), request->collection_name(), vector_ids, attrs, vectors); + + std::vector field_names; + ConstructHEntityResults(attrs, vectors, field_names, response); LOG_SERVER_INFO_ << LogOut("Request [%s] %s end.", GetContext(context)->RequestID().c_str(), __func__); SET_RESPONSE(response->mutable_status(), status, context); diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.h b/core/src/server/grpc_impl/GrpcRequestHandler.h index 20736db9..3dd6884e 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.h +++ b/core/src/server/grpc_impl/GrpcRequestHandler.h @@ -362,7 +362,11 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, ::grpc::Status HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, - ::milvus::grpc::TopKQueryResult* response) override; + ::milvus::grpc::HQueryResult* response) override; + + ::grpc::Status + GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* request, + ::milvus::grpc::HEntity* response) override; // // ::grpc::Status // HybridSearchInSegments(::grpc::ServerContext* context, @@ -370,10 +374,7 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // 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, diff --git a/core/src/server/web_impl/controller/WebController.hpp b/core/src/server/web_impl/controller/WebController.hpp index e53d9add..6c67723f 100644 --- a/core/src/server/web_impl/controller/WebController.hpp +++ b/core/src/server/web_impl/controller/WebController.hpp @@ -577,8 +577,8 @@ class WebController : public oatpp::web::server::api::ApiController { * * GetVectorByID ?id= */ - ENDPOINT("GET", "/collections/{collection_name}/vectors", GetVectors, - PATH(String, collection_name), QUERIES(const QueryParams&, query_params)) { + ENDPOINT("GET", "/collections/{collection_name}/vectors", GetVectors, PATH(String, collection_name), + QUERIES(const QueryParams&, query_params)) { auto handler = WebRequestHandler(); String response; auto status_dto = handler.GetVector(collection_name, query_params, response); @@ -653,6 +653,36 @@ class WebController : public oatpp::web::server::api::ApiController { return response; } + ADD_CORS(EntityOp) + + ENDPOINT("PUT", "/hybrid_collections/{collection_name}/entities", EntityOp, PATH(String, collection_name), + BODY_STRING(String, body)) { + TimeRecorder tr(std::string(WEB_LOG_PREFIX) + "PUT \'/hybrid_collections/" + collection_name->std_str() + + "/vectors\'"); + tr.RecordSection("Received request."); + + WebRequestHandler handler = WebRequestHandler(); + + OString result; + std::shared_ptr response; + auto status_dto = handler.VectorsOp(collection_name, body, result); + switch (status_dto->code->getValue()) { + case StatusCode::SUCCESS: + response = createResponse(Status::CODE_200, result); + break; + case StatusCode::COLLECTION_NOT_EXISTS: + response = createDtoResponse(Status::CODE_404, status_dto); + break; + default: + response = createDtoResponse(Status::CODE_400, status_dto); + } + + tr.ElapseFromBegin("Done. Status: code = " + std::to_string(status_dto->code->getValue()) + + ", reason = " + status_dto->message->std_str() + ". Total cost"); + + return response; + } + ADD_CORS(VectorsOp) ENDPOINT("PUT", "/collections/{collection_name}/vectors", VectorsOp, PATH(String, collection_name), diff --git a/core/src/server/web_impl/handler/WebRequestHandler.cpp b/core/src/server/web_impl/handler/WebRequestHandler.cpp index 06a8dde8..5cdb4a75 100644 --- a/core/src/server/web_impl/handler/WebRequestHandler.cpp +++ b/core/src/server/web_impl/handler/WebRequestHandler.cpp @@ -679,6 +679,109 @@ WebRequestHandler::ProcessBoolQueryJson(const nlohmann::json& query_json, query: } } +void +ConvertRowToColumnJson(const std::vector& row_attrs, std::vector& field_names, + const int64_t row_num, nlohmann::json& column_attrs_json) { + if (field_names.size() == 0) { + if (row_attrs.size() > 0) { + auto attr_it = row_attrs[0].attr_type_.begin(); + for (; attr_it != row_attrs[0].attr_type_.end(); attr_it++) { + field_names.emplace_back(attr_it->first); + } + } + } + + for (uint64_t i = 0; i < field_names.size() - 1; i++) { + std::vector int_data; + std::vector double_data; + for (auto& attr : row_attrs) { + int64_t int_value; + double double_value; + auto attr_data = attr.attr_data_.at(field_names[i]); + switch (attr.attr_type_.at(field_names[i])) { + case engine::meta::hybrid::DataType::INT8: { + if (attr_data.size() == sizeof(int8_t)) { + int_value = attr_data[0]; + int_data.emplace_back(int_value); + } + break; + } + case engine::meta::hybrid::DataType::INT16: { + if (attr_data.size() == sizeof(int16_t)) { + memcpy(&int_value, attr_data.data(), sizeof(int16_t)); + int_data.emplace_back(int_value); + } + break; + } + case engine::meta::hybrid::DataType::INT32: { + if (attr_data.size() == sizeof(int32_t)) { + memcpy(&int_value, attr_data.data(), sizeof(int32_t)); + int_data.emplace_back(int_value); + } + break; + } + case engine::meta::hybrid::DataType::INT64: { + if (attr_data.size() == sizeof(int64_t)) { + memcpy(&int_value, attr_data.data(), sizeof(int64_t)); + int_data.emplace_back(int_value); + } + break; + } + case engine::meta::hybrid::DataType::FLOAT: { + if (attr_data.size() == sizeof(float)) { + float float_value; + memcpy(&float_value, attr_data.data(), sizeof(float)); + double_value = float_value; + double_data.emplace_back(double_value); + } + break; + } + case engine::meta::hybrid::DataType::DOUBLE: { + if (attr_data.size() == sizeof(double)) { + memcpy(&double_value, attr_data.data(), sizeof(double)); + double_data.emplace_back(double_value); + } + break; + } + default: { return; } + } + } + if (int_data.size() > 0) { + if (row_num == -1) { + nlohmann::json int_data_json(int_data); + column_attrs_json[field_names[i]] = int_data_json; + } else { + nlohmann::json topk_int_result; + int64_t topk = int_data.size() / row_num; + for (int64_t j = 0; j < row_num; j++) { + std::vector one_int_result(topk); + memcpy(one_int_result.data(), int_data.data() + j * topk, sizeof(int64_t) * topk); + nlohmann::json one_int_result_json(one_int_result); + std::string tag = "top" + std::to_string(j); + topk_int_result[tag] = one_int_result_json; + } + column_attrs_json[field_names[i]] = topk_int_result; + } + } else if (double_data.size() > 0) { + if (row_num == -1) { + nlohmann::json double_data_json(double_data); + column_attrs_json[field_names[i]] = double_data_json; + } else { + nlohmann::json topk_double_result; + int64_t topk = int_data.size() / row_num; + for (int64_t j = 0; j < row_num; j++) { + std::vector one_double_result(topk); + memcpy(one_double_result.data(), double_data.data() + j * topk, sizeof(double) * topk); + nlohmann::json one_double_result_json(one_double_result); + std::string tag = "top" + std::to_string(j); + topk_double_result[tag] = one_double_result_json; + } + column_attrs_json[field_names[i]] = topk_double_result; + } + } + } +} + Status WebRequestHandler::HybridSearch(const std::string& collection_name, const nlohmann::json& json, std::string& result_str) { @@ -689,9 +792,17 @@ WebRequestHandler::HybridSearch(const std::string& collection_name, const nlohma return Status{UNEXPECTED_ERROR, "DescribeHybridCollection failed"}; } + milvus::json extra_params; + if (json.contains("fields")) { + if (json["fields"].is_array()) { + extra_params["fields"] = json["fields"]; + } + } + auto query_json = json["query"]; + std::vector partition_tags; - if (json.contains("partition_tags")) { - auto tags = json["partition_tags"]; + if (query_json.contains("partition_tags")) { + auto tags = query_json["partition_tags"]; if (!tags.is_null() && !tags.is_array()) { return Status(BODY_PARSE_FAIL, "Field \"partition_tags\" must be a array"); } @@ -701,8 +812,8 @@ WebRequestHandler::HybridSearch(const std::string& collection_name, const nlohma } } - if (json.contains("bool")) { - auto boolean_query_json = json["bool"]; + if (query_json.contains("bool")) { + auto boolean_query_json = query_json["bool"]; query::BooleanQueryPtr boolean_query = std::make_shared(); status = ProcessBoolQueryJson(boolean_query_json, boolean_query); @@ -713,9 +824,10 @@ WebRequestHandler::HybridSearch(const std::string& collection_name, const nlohma query::GenBinaryQuery(boolean_query, general_query->bin); context::HybridSearchContextPtr hybrid_search_context = std::make_shared(); - TopKQueryResult result; + engine::QueryResult result; + std::vector field_names; status = request_handler_.HybridSearch(context_ptr_, hybrid_search_context, collection_name, partition_tags, - general_query, result); + general_query, extra_params, field_names, result); if (!status.ok()) { return status; @@ -729,18 +841,21 @@ WebRequestHandler::HybridSearch(const std::string& collection_name, const nlohma return Status::OK(); } - auto step = result.id_list_.size() / result.row_num_; + auto step = result.result_ids_.size() / result.row_num_; nlohmann::json search_result_json; for (size_t i = 0; i < result.row_num_; i++) { nlohmann::json raw_result_json; for (size_t j = 0; j < step; j++) { nlohmann::json one_result_json; - one_result_json["id"] = std::to_string(result.id_list_.at(i * step + j)); - one_result_json["distance"] = std::to_string(result.distance_list_.at(i * step + j)); + one_result_json["id"] = std::to_string(result.result_ids_.at(i * step + j)); + one_result_json["distance"] = std::to_string(result.result_distances_.at(i * step + j)); raw_result_json.emplace_back(one_result_json); } search_result_json.emplace_back(raw_result_json); } + nlohmann::json attr_json; + ConvertRowToColumnJson(result.attrs_, field_names, result.row_num_, attr_json); + result_json["Entity"] = attr_json; result_json["result"] = search_result_json; result_str = result_json.dump(); } @@ -777,6 +892,39 @@ WebRequestHandler::DeleteByIDs(const std::string& collection_name, const nlohman return status; } +Status +WebRequestHandler::GetEntityByIDs(const std::string& collection_name, const std::vector& ids, + nlohmann::json& json_out) { + std::vector vector_batch; + std::vector attr_batch; + auto status = request_handler_.GetEntityByID(context_ptr_, collection_name, ids, attr_batch, vector_batch); + if (!status.ok()) { + return status; + } + + bool bin; + status = IsBinaryCollection(collection_name, bin); + if (!status.ok()) { + return status; + } + + nlohmann::json vectors_json, attrs_json; + for (size_t i = 0; i < vector_batch.size(); i++) { + nlohmann::json vector_json; + if (bin) { + vector_json["vector"] = vector_batch.at(i).binary_data_; + } else { + vector_json["vector"] = vector_batch.at(i).float_data_; + } + vector_json["id"] = std::to_string(ids[i]); + vectors_json.push_back(vector_json); + } + std::vector field_names; + ConvertRowToColumnJson(attr_batch, field_names, -1, attrs_json); + json_out["vectors"] = vectors_json; + json_out["attributes"] = attrs_json; +} + Status WebRequestHandler::GetVectorsByIDs(const std::string& collection_name, const std::vector& ids, nlohmann::json& json_out) { @@ -1692,6 +1840,44 @@ WebRequestHandler::InsertEntity(const OString& collection_name, const milvus::se ASSIGN_RETURN_STATUS_DTO(status) } +StatusDto::ObjectWrapper +WebRequestHandler::GetEntity(const milvus::server::web::OString& collection_name, + const milvus::server::web::OQueryParams& query_params, + milvus::server::web::OString& response) { + auto status = Status::OK(); + try { + auto query_ids = query_params.get("ids"); + if (query_ids == nullptr || query_ids.get() == nullptr) { + RETURN_STATUS_DTO(QUERY_PARAM_LOSS, "Query param ids is required."); + } + + std::vector ids; + StringHelpFunctions::SplitStringByDelimeter(query_ids->c_str(), ",", ids); + std::vector entity_ids; + for (auto& id : ids) { + entity_ids.push_back(std::stol(id)); + } + nlohmann::json entity_result_json; + status = GetEntityByIDs(collection_name->std_str(), entity_ids, entity_result_json); + if (!status.ok()) { + response = "NULL"; + ASSIGN_RETURN_STATUS_DTO(status) + } + + nlohmann::json json; + AddStatusToJson(json, status.code(), status.message()); + if (entity_result_json.empty()) { + json["entities"] = std::vector(); + } else { + json["entities"] = entity_result_json; + } + } catch (std::exception& e) { + RETURN_STATUS_DTO(SERVER_UNEXPECTED_ERROR, e.what()); + } + + ASSIGN_RETURN_STATUS_DTO(status); +} + StatusDto::ObjectWrapper WebRequestHandler::GetVector(const OString& collection_name, const OQueryParams& query_params, OString& response) { auto status = Status::OK(); @@ -1744,7 +1930,7 @@ WebRequestHandler::VectorsOp(const OString& collection_name, const OString& payl } else if (payload_json.contains("search")) { status = Search(collection_name->std_str(), payload_json["search"], result_str); } else if (payload_json.contains("query")) { - status = HybridSearch(collection_name->c_str(), payload_json["query"], result_str); + status = HybridSearch(collection_name->c_str(), payload_json, result_str); } else { status = Status(ILLEGAL_BODY, "Unknown body"); } diff --git a/core/src/server/web_impl/handler/WebRequestHandler.h b/core/src/server/web_impl/handler/WebRequestHandler.h index 57f37ded..28085096 100644 --- a/core/src/server/web_impl/handler/WebRequestHandler.h +++ b/core/src/server/web_impl/handler/WebRequestHandler.h @@ -141,6 +141,9 @@ class WebRequestHandler { Status GetVectorsByIDs(const std::string& collection_name, const std::vector& ids, nlohmann::json& json_out); + Status + GetEntityByIDs(const std::string& collection_name, const std::vector& ids, nlohmann::json& json_out); + public: WebRequestHandler() { context_ptr_ = GenContextPtr("Web Handler"); @@ -219,6 +222,9 @@ class WebRequestHandler { StatusDto::ObjectWrapper InsertEntity(const OString& collection_name, const OString& body, VectorIdsDto::ObjectWrapper& ids_dto); + StatusDto::ObjectWrapper + GetEntity(const OString& collection_name, const OQueryParams& query_params, OString& response); + StatusDto::ObjectWrapper GetVector(const OString& collection_name, const OQueryParams& query_params, OString& response); diff --git a/core/unittest/db/test_hybrid_db.cpp b/core/unittest/db/test_hybrid_db.cpp index eb62db00..f38bf107 100644 --- a/core/unittest/db/test_hybrid_db.cpp +++ b/core/unittest/db/test_hybrid_db.cpp @@ -29,25 +29,25 @@ #include "utils/CommonUtil.h" namespace { -static const char* TABLE_NAME = "test_hybrid"; -static constexpr int64_t TABLE_DIM = 128; +static const char* COLLECTION_NAME = "test_hybrid"; +static constexpr int64_t COLLECTION_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; +static constexpr int64_t TOPK = 10; 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; +BuildCollectionSchema(milvus::engine::meta::CollectionSchema& collection_schema, + milvus::engine::meta::hybrid::FieldsSchema& fields_schema, + std::unordered_map& attr_type) { + collection_schema.dimension_ = COLLECTION_DIM; + collection_schema.collection_id_ = COLLECTION_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[i].collection_id_ = COLLECTION_NAME; + fields[i].field_name_ = "field_" + std::to_string(i); } fields[0].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT32; fields[1].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT64; @@ -64,11 +64,11 @@ 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); + vectors.float_data_.resize(n * COLLECTION_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.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; vectors.id_array_.push_back(n * batch_index + i); } @@ -79,11 +79,11 @@ 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); + vectors.float_data_.resize(n * COLLECTION_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.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; vectors.id_array_.push_back(n * batch_index + i); } @@ -94,10 +94,13 @@ BuildEntity(uint64_t n, uint64_t batch_index, milvus::engine::Entity& entity) { value_0.resize(n); value_1.resize(n); value_2.resize(n); + + std::default_random_engine e; + std::uniform_real_distribution u(0, 1); for (uint64_t i = 0; i < n; ++i) { value_0[i] = i; value_1[i] = i + n; - value_2[i] = (double)((i + 100) / (n + 1)); + value_2[i] = u(e); } entity.entity_count_ = n; size_t attr_size = n * (sizeof(int64_t) + sizeof(double) + sizeof(int64_t)); @@ -143,16 +146,16 @@ ConstructGeneralQuery(milvus::query::GeneralQueryPtr& general_query) { auto vector_query = std::make_shared(); vector_query->field_name = "field_3"; - vector_query->topk = 100; + vector_query->topk = TOPK; 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); + record.float_data.resize(NQ * COLLECTION_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.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; } vector_query->query_vector = record; @@ -172,16 +175,16 @@ 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); + BuildCollectionSchema(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; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t qb = 1000; milvus::engine::Entity entity; @@ -189,7 +192,7 @@ TEST_F(DBTest, HYBRID_DB_TEST) { std::vector field_names = {"field_0", "field_1", "field_2"}; - stat = db_->InsertEntities(TABLE_NAME, "", field_names, entity, attr_type); + stat = db_->InsertEntities(COLLECTION_NAME, "", field_names, entity, attr_type); ASSERT_TRUE(stat.ok()); stat = db_->Flush(); @@ -199,25 +202,24 @@ TEST_F(DBTest, HYBRID_DB_TEST) { // index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; // index.extra_params_ = {{"nlist", 16384}}; // - // stat = db_->CreateIndex(TABLE_NAME, index); + // stat = db_->CreateIndex(COLLECTION_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); + BuildCollectionSchema(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; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t qb = 1000; milvus::engine::Entity entity; @@ -225,7 +227,7 @@ TEST_F(DBTest, HYBRID_SEARCH_TEST) { std::vector field_names = {"field_0", "field_1", "field_2"}; - stat = db_->InsertEntities(TABLE_NAME, "", field_names, entity, attr_type); + stat = db_->InsertEntities(COLLECTION_NAME, "", field_names, entity, attr_type); ASSERT_TRUE(stat.ok()); stat = db_->Flush(); @@ -237,29 +239,28 @@ TEST_F(DBTest, HYBRID_SEARCH_TEST) { 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); + milvus::engine::QueryResult result; + stat = db_->HybridQuery(dummy_context_, COLLECTION_NAME, tags, hybrid_context, general_query, field_names, + attr_type, result); ASSERT_TRUE(stat.ok()); - //#endif + ASSERT_EQ(result.row_num_, NQ); + ASSERT_EQ(result.result_ids_.size(), NQ * TOPK); } 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); + BuildCollectionSchema(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; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeHybridCollection(collection_info_get, fields_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t vector_count = 1000; milvus::engine::Entity entity; @@ -267,7 +268,7 @@ TEST_F(DBTest, COMPACT_TEST) { std::vector field_names = {"field_0", "field_1", "field_2"}; - stat = db_->InsertEntities(TABLE_NAME, "", field_names, entity, attr_type); + stat = db_->InsertEntities(COLLECTION_NAME, "", field_names, entity, attr_type); ASSERT_TRUE(stat.ok()); stat = db_->Flush(); @@ -292,15 +293,54 @@ TEST_F(DBTest, COMPACT_TEST) { milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; - stat = db_->QueryByIDs(dummy_context_, - collection_info.collection_id_, - tags, - topk, - json_params, - ids_to_delete, - result_ids, - result_distances); + stat = db_->QueryByIDs(dummy_context_, collection_info.collection_id_, tags, topk, json_params, ids_to_delete, + result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids[0], -1); ASSERT_EQ(result_distances[0], std::numeric_limits::max()); } + +TEST_F(DBTest2, GET_ENTITY_BY_ID_TEST) { + milvus::engine::meta::CollectionSchema collection_schema; + milvus::engine::meta::hybrid::FieldsSchema fields_schema; + std::unordered_map attr_type; + BuildCollectionSchema(collection_schema, fields_schema, attr_type); + + auto stat = db_->CreateHybridCollection(collection_schema, fields_schema); + ASSERT_TRUE(stat.ok()); + + uint64_t vector_count = 1000; + milvus::engine::Entity entity; + BuildEntity(vector_count, 0, entity); + + std::vector field_names = {"field_0", "field_1", "field_2"}; + + stat = db_->InsertEntities(COLLECTION_NAME, "", field_names, entity, attr_type); + ASSERT_TRUE(stat.ok()); + + stat = db_->Flush(); + ASSERT_TRUE(stat.ok()); + + std::vector attrs; + std::vector vectors; + stat = db_->GetEntitiesByID(COLLECTION_NAME, entity.id_array_, vectors, attrs); + ASSERT_TRUE(stat.ok()); + ASSERT_EQ(vectors.size(), entity.id_array_.size()); + ASSERT_EQ(vectors[0].float_data_.size(), COLLECTION_DIM); + ASSERT_EQ(attrs[0].attr_data_.at("field_0").size(), sizeof(int32_t)); + + for (int64_t i = 0; i < COLLECTION_DIM; i++) { + ASSERT_FLOAT_EQ(vectors[0].float_data_[i], entity.vector_data_.at("field_3").float_data_[i]); + } + + std::vector empty_array; + vectors.clear(); + attrs.clear(); + stat = db_->GetEntitiesByID(COLLECTION_NAME, empty_array, vectors, attrs); + ASSERT_TRUE(stat.ok()); + for (auto& vector : vectors) { + ASSERT_EQ(vector.vector_count_, 0); + ASSERT_TRUE(vector.float_data_.empty()); + ASSERT_TRUE(vector.binary_data_.empty()); + } +} diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp index ad5de73c..1f145a47 100644 --- a/core/unittest/server/test_rpc.cpp +++ b/core/unittest/server/test_rpc.cpp @@ -988,30 +988,35 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) { milvus::grpc::HEntityIDs entity_ids; insert_param.set_collection_name("test_hybrid"); - auto entity = insert_param.mutable_entities(); + auto entity = insert_param.mutable_entity(); 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 attr_record = entity->add_attr_data(); entity->set_row_num(row_num); std::vector field_value(row_num, 0); for (uint64_t i = 0; i < row_num; i++) { field_value[i] = i; } - entity->set_attr_records(field_value.data(), row_num * sizeof(int64_t)); + attr_record->mutable_int_value()->Resize(static_cast(row_num), 0); + memcpy(attr_record->mutable_int_value()->mutable_data(), field_value.data(), row_num * sizeof(int64_t)); std::vector> vector_field; vector_field.resize(row_num); + + std::default_random_engine e; + std::uniform_real_distribution u(0, 1); 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)); + vector_field[i][j] = u(e); } } - auto vector_record = entity->add_result_values(); + auto vector_record = entity->add_vector_data(); for (uint64_t i = 0; i < row_num; ++i) { - auto record = vector_record->mutable_vector_value()->add_value(); + auto record = vector_record->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)); @@ -1034,7 +1039,8 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) { term_value[i] = i + nq; } term_query->set_value_num(nq); - term_query->set_values(term_value.data(), nq * sizeof(int64_t)); + term_query->mutable_int_value()->Resize(static_cast(nq), 0); + memcpy(term_query->mutable_int_value()->mutable_data(), term_value.data(), nq * sizeof(int64_t)); auto vector_query = boolean_query_2->add_general_query()->mutable_vector_query(); vector_query->set_field_name("field_1"); @@ -1045,7 +1051,7 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) { 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)); + query_vector[i][j] = u(e); } } for (auto record : query_vector) { @@ -1062,7 +1068,7 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) { search_extra_param->set_key("params"); search_extra_param->set_value(""); - milvus::grpc::TopKQueryResult topk_query_result; + milvus::grpc::HQueryResult topk_query_result; handler->HybridSearch(&context, &search_param, &topk_query_result); } diff --git a/sdk/examples/hybrid/src/ClientTest.cpp b/sdk/examples/hybrid/src/ClientTest.cpp index 1d29e89f..17b9c11a 100644 --- a/sdk/examples/hybrid/src/ClientTest.cpp +++ b/sdk/examples/hybrid/src/ClientTest.cpp @@ -39,6 +39,17 @@ constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::IVFSQ8; constexpr int32_t NLIST = 16384; constexpr uint64_t FIELD_NUM = 3; +void +PrintHybridQueryResult(const std::vector& id_array, const milvus::HybridQueryResult& result) { + for (size_t i = 0; i < id_array.size(); i++) { + std::string prefix = "No." + std::to_string(i) + " id:" + std::to_string(id_array[i]); + std::cout<< prefix << "\t["; + for (size_t j = 0; j < result.attr_records.size(); i++) { + + } + } +} + } // namespace ClientTest::ClientTest(const std::string& address, const std::string& port) { @@ -87,23 +98,19 @@ ClientTest::Flush(const std::string& collection_name) { void ClientTest::InsertHybridEntities(std::string& collection_name, int64_t row_num) { - std::unordered_map> numerica_value; + std::unordered_map> numerica_int_value; + std::unordered_map> numerica_double_value; std::vector value1; std::vector value2; value1.resize(row_num); value2.resize(row_num); for (uint64_t i = 0; i < row_num; ++i) { value1[i] = i; - value2[i] = i + row_num; + value2[i] = (double)(i + row_num); } - std::vector numerica1(row_num * sizeof(int64_t), 0); - std::vector numerica2(row_num * sizeof(double), 0); - memcpy(numerica1.data(), value1.data(), row_num * sizeof(int64_t)); - memcpy(numerica2.data(), value2.data(), row_num * sizeof(double)); - - numerica_value.insert(std::make_pair("field_1", numerica1)); - numerica_value.insert(std::make_pair("field_2", numerica2)); + numerica_int_value.insert(std::make_pair("field_1", value1)); + numerica_double_value.insert(std::make_pair("field_2", value2)); std::unordered_map> vector_value; std::vector entity_array; @@ -113,7 +120,7 @@ ClientTest::InsertHybridEntities(std::string& collection_name, int64_t row_num) } vector_value.insert(std::make_pair("field_3", entity_array)); - milvus::HEntity entity = {row_num, numerica_value, vector_value}; + milvus::HEntity entity = {row_num, numerica_int_value, numerica_double_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; @@ -122,7 +129,7 @@ ClientTest::InsertHybridEntities(std::string& collection_name, int64_t row_num) void ClientTest::HybridSearch(std::string& collection_name) { std::vector partition_tags; - milvus::TopKQueryResult topk_query_result; + milvus::TopKHybridQueryResult topk_query_result; auto leaf_queries = milvus_sdk::Utils::GenLeafQuery(); @@ -138,17 +145,46 @@ ClientTest::HybridSearch(std::string& collection_name) { 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++) { + for (auto attr : topk_query_result[i].attr_records) { + std::cout << "Field: " << attr.first << std::endl; + if (attr.second.int_record.size() > 0) { + for (auto record : attr.second.int_record) { + std::cout << record << "\t"; + } + } else if (attr.second.double_record.size() > 0) { + for (auto record : attr.second.double_record) { + std::cout << record << "\t"; + } + } + std::cout << std::endl; + } + } + 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 << topk_query_result[i].ids[1] << " --------- " << topk_query_result[i].distances[1] << std::endl; } std::cout << "HybridSearch function call status: " << status.message() << std::endl; } +void +ClientTest::GetHEntityByID(const std::string& collection_name, const std::vector& id_array) { + milvus::HybridQueryResult result; + { + milvus_sdk::TimeRecorder rc("GetHybridEntityByID"); + milvus::Status stat = conn_->GetHEntityByID(collection_name, id_array, result); + std::cout << "GetEntitiesByID function call status: " << stat.message() << std::endl; + } + + PrintHybridQueryResult(id_array, result); +} + void ClientTest::TestHybrid() { std::string collection_name = "HYBRID_TEST"; CreateHybridCollection(collection_name); - InsertHybridEntities(collection_name, 1000); + InsertHybridEntities(collection_name, 10000); Flush(collection_name); sleep(2); HybridSearch(collection_name); diff --git a/sdk/examples/hybrid/src/ClientTest.h b/sdk/examples/hybrid/src/ClientTest.h index 7ac2dba4..a4f1d610 100644 --- a/sdk/examples/hybrid/src/ClientTest.h +++ b/sdk/examples/hybrid/src/ClientTest.h @@ -39,6 +39,9 @@ class ClientTest { void HybridSearch(std::string&); + void + GetHEntityByID(const std::string&, const std::vector&); + 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 4428af52..90afdc77 100644 --- a/sdk/examples/utils/Utils.cpp +++ b/sdk/examples/utils/Utils.cpp @@ -16,6 +16,7 @@ #include #include +#include #include #include @@ -136,11 +137,13 @@ Utils::BuildEntities(int64_t from, int64_t to, std::vector& enti entity_array.clear(); entity_ids.clear(); + std::default_random_engine e; + std::uniform_real_distribution u(0, 1); for (int64_t k = from; k < to; k++) { milvus::Entity entity; entity.float_data.resize(dimension); for (int64_t i = 0; i < dimension; i++) { - entity.float_data[i] = (float)((k + 100) % (i + 1)); + entity.float_data[i] = (u(e)); } entity_array.emplace_back(entity); @@ -231,10 +234,12 @@ Utils::DoSearch(std::shared_ptr conn, const std::string& col void ConstructVector(uint64_t nq, uint64_t dimension, std::vector& query_vector) { query_vector.resize(nq); + std::default_random_engine e; + std::uniform_real_distribution u(0, 1); 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)); + query_vector[i].float_data[j] = u(e); } } } @@ -242,20 +247,18 @@ void ConstructVector(uint64_t nq, uint64_t dimension, std::vector Utils::GenLeafQuery() { //Construct TermQuery - uint64_t row_num = 1000; + uint64_t row_num = 10000; std::vector field_value; field_value.resize(row_num); for (uint64_t i = 0; i < row_num; ++i) { field_value[i] = i; } - std::vector term_value(row_num * sizeof(int64_t)); - memcpy(term_value.data(), field_value.data(), row_num * sizeof(int64_t)); milvus::TermQueryPtr tq = std::make_shared(); tq->field_name = "field_1"; - tq->field_value = term_value; + tq->int_value = field_value; //Construct RangeQuery - milvus::CompareExpr ce1 = {milvus::CompareOperator::LTE, "10000"}, ce2 = {milvus::CompareOperator::GTE, "1"}; + milvus::CompareExpr ce1 = {milvus::CompareOperator::LTE, "100000"}, ce2 = {milvus::CompareOperator::GTE, "1"}; std::vector ces{ce1, ce2}; milvus::RangeQueryPtr rq = std::make_shared(); rq->field_name = "field_2"; diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc index 29756467..9dde7b29 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc @@ -1061,32 +1061,32 @@ void MilvusService::Stub::experimental_async::InsertEntity(::grpc::ClientContext 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) { +::grpc::Status MilvusService::Stub::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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) { +void MilvusService::Stub::experimental_async::HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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::HQueryResult>* MilvusService::Stub::AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HQueryResult>::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::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>* MilvusService::Stub::PrepareAsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HQueryResult>::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) { @@ -1117,11 +1117,11 @@ void MilvusService::Stub::experimental_async::HybridSearchInSegments(::grpc::Cli 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) { +::grpc::Status MilvusService::Stub::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, std::move(f)); } @@ -1129,7 +1129,7 @@ void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContex ::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) { +void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_GetEntityByID_, context, request, response, reactor); } @@ -1137,11 +1137,11 @@ void MilvusService::Stub::experimental_async::GetEntityByID(::grpc::ClientContex ::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) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* MilvusService::Stub::PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::HEntity>::Create(channel_.get(), cq, rpcmethod_GetEntityByID_, context, request, false); } @@ -1375,7 +1375,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[34], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>( std::mem_fn(&MilvusService::Service::HybridSearch), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[35], @@ -1385,7 +1385,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[36], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>( std::mem_fn(&MilvusService::Service::GetEntityByID), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[37], @@ -1640,7 +1640,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::TopKQueryResult* response) { +::grpc::Status MilvusService::Service::HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response) { (void) context; (void) request; (void) response; @@ -1654,7 +1654,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::HEntityIdentity* request, ::milvus::grpc::HEntity* response) { +::grpc::Status MilvusService::Service::GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* request, ::milvus::grpc::HEntity* response) { (void) context; (void) request; (void) response; diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h index 969758d7..c90fa1ba 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h @@ -447,13 +447,12 @@ class MilvusService final { 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)); + virtual ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>>(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)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>>(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) { @@ -462,11 +461,11 @@ class MilvusService final { 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) { + virtual ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::milvus::grpc::HEntity* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -784,18 +783,17 @@ class MilvusService final { 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 HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* response, std::function) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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 ::milvus::grpc::VectorsIdentity* 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 ::milvus::grpc::VectorsIdentity* 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; @@ -876,12 +874,12 @@ class MilvusService final { 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::HQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HQueryResult>* 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::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1128,12 +1126,12 @@ class MilvusService final { 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)); + ::grpc::Status HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::milvus::grpc::HQueryResult* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>> AsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>>(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)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>> PrepareAsyncHybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>>(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) { @@ -1142,11 +1140,11 @@ class MilvusService final { 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) { + ::grpc::Status GetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::milvus::grpc::HEntity* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> AsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>> PrepareAsyncGetEntityByID(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1302,17 +1300,17 @@ class MilvusService final { 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 HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* response, std::function) override; + void HybridSearch(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HybridSearch(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::HQueryResult* 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 ::milvus::grpc::VectorsIdentity* 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 ::milvus::grpc::VectorsIdentity* 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; @@ -1401,12 +1399,12 @@ class MilvusService final { ::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::HQueryResult>* AsyncHybridSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::HSearchParam& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HQueryResult>* 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::HEntity>* AsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::HEntity>* PrepareAsyncGetEntityByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::VectorsIdentity& 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; @@ -1653,10 +1651,9 @@ class MilvusService final { // ///////////////////////////////////////////////////////////////// // 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 HybridSearch(::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, ::milvus::grpc::HQueryResult* 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 GetEntityByID(::grpc::ServerContext* context, const ::milvus::grpc::VectorsIdentity* 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); }; @@ -2352,11 +2349,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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) { + void RequestHybridSearch(::grpc::ServerContext* context, ::milvus::grpc::HSearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HQueryResult>* 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); } }; @@ -2392,11 +2389,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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) { + void RequestGetEntityByID(::grpc::ServerContext* context, ::milvus::grpc::VectorsIdentity* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::HEntity>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(36, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -3502,17 +3499,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_HybridSearch() { ::grpc::Service::experimental().MarkMethodCallback(34, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>( [this](::grpc::ServerContext* context, const ::milvus::grpc::HSearchParam* request, - ::milvus::grpc::TopKQueryResult* response, + ::milvus::grpc::HQueryResult* 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::experimental::MessageAllocator< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>*>( ::grpc::Service::experimental().GetHandler(34)) ->SetMessageAllocator(allocator); } @@ -3520,11 +3517,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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, "")); } + virtual void HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_HybridSearchInSegments : public BaseClass { @@ -3564,17 +3561,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_GetEntityByID() { ::grpc::Service::experimental().MarkMethodCallback(36, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::HEntityIdentity* request, + const ::milvus::grpc::VectorsIdentity* 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::experimental::MessageAllocator< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::VectorsIdentity, ::milvus::grpc::HEntity>*>( ::grpc::Service::experimental().GetHandler(36)) ->SetMessageAllocator(allocator); } @@ -3582,11 +3579,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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, "")); } + virtual void GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_GetEntityIDs : public BaseClass { @@ -4241,7 +4238,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -4275,7 +4272,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5006,7 +5003,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5046,7 +5043,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -5963,7 +5960,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::TopKQueryResult* /*response*/) override { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -6013,7 +6010,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HEntityIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*request*/, ::milvus::grpc::HEntity* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -6756,18 +6753,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_HybridSearch() { ::grpc::Service::MarkMethodStreamed(34, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::TopKQueryResult>(std::bind(&WithStreamedUnaryMethod_HybridSearch::StreamedHybridSearch, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HSearchParam, ::milvus::grpc::HQueryResult>(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 { + ::grpc::Status HybridSearch(::grpc::ServerContext* /*context*/, const ::milvus::grpc::HSearchParam* /*request*/, ::milvus::grpc::HQueryResult* /*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; + virtual ::grpc::Status StreamedHybridSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::HSearchParam,::milvus::grpc::HQueryResult>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_HybridSearchInSegments : public BaseClass { @@ -6796,18 +6793,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_GetEntityByID() { ::grpc::Service::MarkMethodStreamed(36, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::HEntityIdentity, ::milvus::grpc::HEntity>(std::bind(&WithStreamedUnaryMethod_GetEntityByID::StreamedGetEntityByID, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::VectorsIdentity, ::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 { + ::grpc::Status GetEntityByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::VectorsIdentity* /*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; + virtual ::grpc::Status StreamedGetEntityByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::VectorsIdentity,::milvus::grpc::HEntity>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_GetEntityIDs : public BaseClass { diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.pb.cc index 289aea93..b5e05c1a 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.cc @@ -15,12 +15,12 @@ #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<2> scc_info_HEntity_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; @@ -30,7 +30,7 @@ extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal 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<1> scc_info_VectorFieldRecord_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_VectorQuery_milvus_2eproto; namespace milvus { namespace grpc { @@ -144,20 +144,18 @@ class FieldParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _FieldParam_default_instance_; -class VectorFieldValueDefaultTypeInternal { +class VectorFieldRecordDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _VectorFieldValue_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _VectorFieldRecord_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_; + const ::milvus::grpc::VectorFieldRecord* vector_value_; } _FieldValue_default_instance_; class MappingDefaultTypeInternal { public: @@ -454,7 +452,7 @@ static void InitDefaultsscc_info_FieldValue_milvus_2eproto() { ::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,}}; + &scc_info_VectorFieldRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_FlushParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -509,10 +507,11 @@ static void InitDefaultsscc_info_HEntity_milvus_2eproto() { ::milvus::grpc::HEntity::InitAsDefaultInstance(); } -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_HEntity_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_HEntity_milvus_2eproto}, { +::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_FieldValue_milvus_2eproto.base,}}; + &scc_info_AttrRecord_milvus_2eproto.base, + &scc_info_VectorFieldRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_HEntityIDs_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -600,10 +599,11 @@ static void InitDefaultsscc_info_HQueryResult_milvus_2eproto() { ::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}, { +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<3> scc_info_HQueryResult_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 3, InitDefaultsscc_info_HQueryResult_milvus_2eproto}, { &scc_info_Status_status_2eproto.base, - &scc_info_HEntity_milvus_2eproto.base,}}; + &scc_info_HEntity_milvus_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; static void InitDefaultsscc_info_HSearchInSegmentsParam_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -878,19 +878,19 @@ static void InitDefaultsscc_info_VectorFieldParam_milvus_2eproto() { ::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() { +static void InitDefaultsscc_info_VectorFieldRecord_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; { - void* ptr = &::milvus::grpc::_VectorFieldValue_default_instance_; - new (ptr) ::milvus::grpc::VectorFieldValue(); + void* ptr = &::milvus::grpc::_VectorFieldRecord_default_instance_; + new (ptr) ::milvus::grpc::VectorFieldRecord(); ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); } - ::milvus::grpc::VectorFieldValue::InitAsDefaultInstance(); + ::milvus::grpc::VectorFieldRecord::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}, { +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorFieldRecord_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorFieldRecord_milvus_2eproto}, { &scc_info_RowRecord_milvus_2eproto.base,}}; static void InitDefaultsscc_info_VectorIds_milvus_2eproto() { @@ -1165,19 +1165,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT 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_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldValue, value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorFieldRecord, 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_), @@ -1205,7 +1203,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~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, int_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, double_value_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, value_num_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, boost_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TermQuery, extra_params_), @@ -1273,7 +1272,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, int_value_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::AttrRecord, double_value_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, _internal_metadata_), ~0u, // no _extensions_ @@ -1282,19 +1282,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT 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, data_types_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, row_num_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, result_values_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, attr_data_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HEntity, vector_data_), ~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, entity_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, row_num_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, score_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, distance_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::HQueryResult, extra_params_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, _internal_metadata_), ~0u, // no _extensions_ @@ -1302,7 +1304,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~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_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, entity_id_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::HInsertParam, extra_params_), ~0u, // no _has_bits_ @@ -1371,27 +1373,27 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 182, -1, sizeof(::milvus::grpc::VectorFieldParam)}, { 188, -1, sizeof(::milvus::grpc::FieldType)}, { 196, -1, sizeof(::milvus::grpc::FieldParam)}, - { 205, -1, sizeof(::milvus::grpc::VectorFieldValue)}, + { 205, -1, sizeof(::milvus::grpc::VectorFieldRecord)}, { 211, -1, sizeof(::milvus::grpc::FieldValue)}, - { 224, -1, sizeof(::milvus::grpc::Mapping)}, - { 233, -1, sizeof(::milvus::grpc::MappingList)}, - { 240, -1, sizeof(::milvus::grpc::TermQuery)}, - { 250, -1, sizeof(::milvus::grpc::CompareExpr)}, - { 257, -1, sizeof(::milvus::grpc::RangeQuery)}, - { 266, -1, sizeof(::milvus::grpc::VectorQuery)}, - { 276, -1, sizeof(::milvus::grpc::BooleanQuery)}, - { 283, -1, sizeof(::milvus::grpc::GeneralQuery)}, - { 293, -1, sizeof(::milvus::grpc::HSearchParam)}, - { 302, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, - { 309, -1, sizeof(::milvus::grpc::AttrRecord)}, + { 222, -1, sizeof(::milvus::grpc::Mapping)}, + { 231, -1, sizeof(::milvus::grpc::MappingList)}, + { 238, -1, sizeof(::milvus::grpc::TermQuery)}, + { 249, -1, sizeof(::milvus::grpc::CompareExpr)}, + { 256, -1, sizeof(::milvus::grpc::RangeQuery)}, + { 265, -1, sizeof(::milvus::grpc::VectorQuery)}, + { 275, -1, sizeof(::milvus::grpc::BooleanQuery)}, + { 282, -1, sizeof(::milvus::grpc::GeneralQuery)}, + { 292, -1, sizeof(::milvus::grpc::HSearchParam)}, + { 301, -1, sizeof(::milvus::grpc::HSearchInSegmentsParam)}, + { 308, -1, sizeof(::milvus::grpc::AttrRecord)}, { 315, -1, sizeof(::milvus::grpc::HEntity)}, - { 326, -1, sizeof(::milvus::grpc::HQueryResult)}, - { 336, -1, sizeof(::milvus::grpc::HInsertParam)}, - { 346, -1, sizeof(::milvus::grpc::HEntityIdentity)}, - { 353, -1, sizeof(::milvus::grpc::HEntityIDs)}, - { 360, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, - { 367, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, - { 374, -1, sizeof(::milvus::grpc::HIndexParam)}, + { 327, -1, sizeof(::milvus::grpc::HQueryResult)}, + { 338, -1, sizeof(::milvus::grpc::HInsertParam)}, + { 348, -1, sizeof(::milvus::grpc::HEntityIdentity)}, + { 355, -1, sizeof(::milvus::grpc::HEntityIDs)}, + { 362, -1, sizeof(::milvus::grpc::HGetEntityIDsParam)}, + { 369, -1, sizeof(::milvus::grpc::HDeleteByIDParam)}, + { 376, -1, sizeof(::milvus::grpc::HIndexParam)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1422,7 +1424,7 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = 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::_VectorFieldRecord_default_instance_), reinterpret_cast(&::milvus::grpc::_FieldValue_default_instance_), reinterpret_cast(&::milvus::grpc::_Mapping_default_instance_), reinterpret_cast(&::milvus::grpc::_MappingList_default_instance_), @@ -1508,150 +1510,153 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "amH\000B\007\n\005value\"}\n\nFieldParam\022\n\n\002id\030\001 \001(\004\022" "\014\n\004name\030\002 \001(\t\022$\n\004type\030\003 \001(\0132\026.milvus.grp" "c.FieldType\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"9\n\020VectorFieldValue" - "\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord\"" - "\327\001\n\nFieldValue\022\025\n\013int32_value\030\001 \001(\005H\000\022\025\n" - "\013int64_value\030\002 \001(\003H\000\022\025\n\013float_value\030\003 \001(" - "\002H\000\022\026\n\014double_value\030\004 \001(\001H\000\022\026\n\014string_va" - "lue\030\005 \001(\tH\000\022\024\n\nbool_value\030\006 \001(\010H\000\0225\n\014vec" - "tor_value\030\007 \001(\0132\035.milvus.grpc.VectorFiel" - "dValueH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030" - "\001 \001(\0132\023.milvus.grpc.Status\022\025\n\rcollection" - "_id\030\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fi" - "elds\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013M" - "appingList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" - ".Status\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.g" - "rpc.Mapping\"\202\001\n\tTermQuery\022\022\n\nfield_name\030" - "\001 \001(\t\022\016\n\006values\030\002 \001(\014\022\021\n\tvalue_num\030\003 \001(\003" - "\022\r\n\005boost\030\004 \001(\002\022/\n\014extra_params\030\005 \003(\0132\031." - "milvus.grpc.KeyValuePair\"N\n\013CompareExpr\022" - ".\n\010operator\030\001 \001(\0162\034.milvus.grpc.CompareO" - "perator\022\017\n\007operand\030\002 \001(\t\"\213\001\n\nRangeQuery\022" - "\022\n\nfield_name\030\001 \001(\t\022)\n\007operand\030\002 \003(\0132\030.m" - "ilvus.grpc.CompareExpr\022\r\n\005boost\030\003 \001(\002\022/\n" - "\014extra_params\030\004 \003(\0132\031.milvus.grpc.KeyVal" - "uePair\"\236\001\n\013VectorQuery\022\022\n\nfield_name\030\001 \001" - "(\t\022\023\n\013query_boost\030\002 \001(\002\022\'\n\007records\030\003 \003(\013" - "2\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/" - "\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyVa" - "luePair\"c\n\014BooleanQuery\022!\n\005occur\030\001 \001(\0162\022" - ".milvus.grpc.Occur\0220\n\rgeneral_query\030\002 \003(" - "\0132\031.milvus.grpc.GeneralQuery\"\333\001\n\014General" - "Query\0222\n\rboolean_query\030\001 \001(\0132\031.milvus.gr" - "pc.BooleanQueryH\000\022,\n\nterm_query\030\002 \001(\0132\026." - "milvus.grpc.TermQueryH\000\022.\n\013range_query\030\003" - " \001(\0132\027.milvus.grpc.RangeQueryH\000\0220\n\014vecto" - "r_query\030\004 \001(\0132\030.milvus.grpc.VectorQueryH" - "\000B\007\n\005query\"\247\001\n\014HSearchParam\022\027\n\017collectio" - "n_name\030\001 \001(\t\022\033\n\023partition_tag_array\030\002 \003(" - "\t\0220\n\rgeneral_query\030\003 \001(\0132\031.milvus.grpc.G" - "eneralQuery\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"c\n\026HSearchInSegment" - "sParam\022\030\n\020segment_id_array\030\001 \003(\t\022/\n\014sear" - "ch_param\030\002 \001(\0132\031.milvus.grpc.HSearchPara" - "m\"\033\n\nAttrRecord\022\r\n\005value\030\001 \003(\t\"\255\001\n\007HEnti" - "ty\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\021\n\tentity_id\030\002 \001(\003\022\023\n\013field_names\030\003 \003(\t\022" - "\024\n\014attr_records\030\004 \001(\014\022\017\n\007row_num\030\005 \001(\003\022." - "\n\rresult_values\030\006 \003(\0132\027.milvus.grpc.Fiel" - "dValue\"\215\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132" - "\023.milvus.grpc.Status\022&\n\010entities\030\002 \003(\0132\024" - ".milvus.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n" - "\005score\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\"\260\001\n\014HInse" - "rtParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\rpart" - "ition_tag\030\002 \001(\t\022&\n\010entities\030\003 \001(\0132\024.milv" - "us.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003(\003" - "\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Key" - "ValuePair\"6\n\017HEntityIdentity\022\027\n\017collecti" - "on_name\030\001 \001(\t\022\n\n\002id\030\002 \001(\003\"J\n\nHEntityIDs\022" - "#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017" - "entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDsPa" - "ram\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segment_" - "name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017collec" - "tion_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013HI" - "ndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nindex" - "_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milv" - "us.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004NUL" - "L\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005I" - "NT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020(\022" - "\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*C\n" - "\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020" - "\002\022\006\n\002GT\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007I" - "NVALID\020\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_N" - "OT\020\0032\324\026\n\rMilvusService\022H\n\020CreateCollecti" - "on\022\035.milvus.grpc.CollectionSchema\032\023.milv" - "us.grpc.Status\"\000\022F\n\rHasCollection\022\033.milv" - "us.grpc.CollectionName\032\026.milvus.grpc.Boo" - "lReply\"\000\022R\n\022DescribeCollection\022\033.milvus." - "grpc.CollectionName\032\035.milvus.grpc.Collec" - "tionSchema\"\000\022Q\n\017CountCollection\022\033.milvus" - ".grpc.CollectionName\032\037.milvus.grpc.Colle" - "ctionRowCount\"\000\022J\n\017ShowCollections\022\024.mil" - "vus.grpc.Command\032\037.milvus.grpc.Collectio" - "nNameList\"\000\022P\n\022ShowCollectionInfo\022\033.milv" - "us.grpc.CollectionName\032\033.milvus.grpc.Col" - "lectionInfo\"\000\022D\n\016DropCollection\022\033.milvus" - ".grpc.CollectionName\032\023.milvus.grpc.Statu" - "s\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexPa" - "ram\032\023.milvus.grpc.Status\"\000\022G\n\rDescribeIn" - "dex\022\033.milvus.grpc.CollectionName\032\027.milvu" - "s.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022E\n\017CreatePartition\022\033.milvus.grpc.Pa" - "rtitionParam\032\023.milvus.grpc.Status\"\000\022E\n\014H" - "asPartition\022\033.milvus.grpc.PartitionParam" - "\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPartit" - "ions\022\033.milvus.grpc.CollectionName\032\032.milv" - "us.grpc.PartitionList\"\000\022C\n\rDropPartition" - "\022\033.milvus.grpc.PartitionParam\032\023.milvus.g" - "rpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.Ins" - "ertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016Ge" - "tVectorsByID\022\034.milvus.grpc.VectorsIdenti" - "ty\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetVec" - "torIDs\022\036.milvus.grpc.GetVectorIDsParam\032\026" - ".milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.mil" - "vus.grpc.SearchParam\032\034.milvus.grpc.TopKQ" - "ueryResult\"\000\022J\n\nSearchByID\022\034.milvus.grpc" - ".SearchByIDParam\032\034.milvus.grpc.TopKQuery" - "Result\"\000\022P\n\rSearchInFiles\022\037.milvus.grpc." - "SearchInFilesParam\032\034.milvus.grpc.TopKQue" - "ryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032" - "\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteByI" - "D\022\034.milvus.grpc.DeleteByIDParam\032\023.milvus" - ".grpc.Status\"\000\022G\n\021PreloadCollection\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPara" - "m\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033.mi" - "lvus.grpc.CollectionName\032\023.milvus.grpc.S" - "tatus\"\000\022E\n\026CreateHybridCollection\022\024.milv" - "us.grpc.Mapping\032\023.milvus.grpc.Status\"\000\022L" - "\n\023HasHybridCollection\022\033.milvus.grpc.Coll" - "ectionName\032\026.milvus.grpc.BoolReply\"\000\022J\n\024" - "DropHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\023.milvus.grpc.Status\"\000\022O\n\030Desc" - "ribeHybridCollection\022\033.milvus.grpc.Colle" - "ctionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025Cou" - "ntHybridCollection\022\033.milvus.grpc.Collect" - "ionName\032\037.milvus.grpc.CollectionRowCount" - "\"\000\022I\n\025ShowHybridCollections\022\024.milvus.grp" - "c.Command\032\030.milvus.grpc.MappingList\"\000\022V\n" - "\030ShowHybridCollectionInfo\022\033.milvus.grpc." - "CollectionName\032\033.milvus.grpc.CollectionI" - "nfo\"\000\022M\n\027PreloadHybridCollection\022\033.milvu" - "s.grpc.CollectionName\032\023.milvus.grpc.Stat" - "us\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HInse" - "rtParam\032\027.milvus.grpc.HEntityIDs\"\000\022I\n\014Hy" - "bridSearch\022\031.milvus.grpc.HSearchParam\032\034." - "milvus.grpc.TopKQueryResult\"\000\022]\n\026HybridS" - "earchInSegments\022#.milvus.grpc.HSearchInS" - "egmentsParam\032\034.milvus.grpc.TopKQueryResu" - "lt\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.HEnt" - "ityIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014G" - "etEntityIDs\022\037.milvus.grpc.HGetEntityIDsP" - "aram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delet" - "eEntitiesByID\022\035.milvus.grpc.HDeleteByIDP" - "aram\032\023.milvus.grpc.Status\"\000b\006proto3" + "us.grpc.KeyValuePair\":\n\021VectorFieldRecor" + "d\022%\n\005value\030\001 \003(\0132\026.milvus.grpc.RowRecord" + "\"\252\001\n\nFieldValue\022\025\n\013int64_value\030\001 \001(\003H\000\022\026" + "\n\014double_value\030\002 \001(\001H\000\022\026\n\014string_value\030\003" + " \001(\tH\000\022\024\n\nbool_value\030\004 \001(\010H\000\0226\n\014vector_v" + "alue\030\005 \001(\0132\036.milvus.grpc.VectorFieldReco" + "rdH\000B\007\n\005value\"\207\001\n\007Mapping\022#\n\006status\030\001 \001(" + "\0132\023.milvus.grpc.Status\022\025\n\rcollection_id\030" + "\002 \001(\004\022\027\n\017collection_name\030\003 \001(\t\022\'\n\006fields" + "\030\004 \003(\0132\027.milvus.grpc.FieldParam\"^\n\013Mappi" + "ngList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Sta" + "tus\022*\n\014mapping_list\030\002 \003(\0132\024.milvus.grpc." + "Mapping\"\233\001\n\tTermQuery\022\022\n\nfield_name\030\001 \001(" + "\t\022\021\n\tint_value\030\002 \003(\003\022\024\n\014double_value\030\003 \003" + "(\001\022\021\n\tvalue_num\030\004 \001(\003\022\r\n\005boost\030\005 \001(\002\022/\n\014" + "extra_params\030\006 \003(\0132\031.milvus.grpc.KeyValu" + "ePair\"N\n\013CompareExpr\022.\n\010operator\030\001 \001(\0162\034" + ".milvus.grpc.CompareOperator\022\017\n\007operand\030" + "\002 \001(\t\"\213\001\n\nRangeQuery\022\022\n\nfield_name\030\001 \001(\t" + "\022)\n\007operand\030\002 \003(\0132\030.milvus.grpc.CompareE" + "xpr\022\r\n\005boost\030\003 \001(\002\022/\n\014extra_params\030\004 \003(\013" + "2\031.milvus.grpc.KeyValuePair\"\236\001\n\013VectorQu" + "ery\022\022\n\nfield_name\030\001 \001(\t\022\023\n\013query_boost\030\002" + " \001(\002\022\'\n\007records\030\003 \003(\0132\026.milvus.grpc.RowR" + "ecord\022\014\n\004topk\030\004 \001(\003\022/\n\014extra_params\030\005 \003(" + "\0132\031.milvus.grpc.KeyValuePair\"c\n\014BooleanQ" + "uery\022!\n\005occur\030\001 \001(\0162\022.milvus.grpc.Occur\022" + "0\n\rgeneral_query\030\002 \003(\0132\031.milvus.grpc.Gen" + "eralQuery\"\333\001\n\014GeneralQuery\0222\n\rboolean_qu" + "ery\030\001 \001(\0132\031.milvus.grpc.BooleanQueryH\000\022," + "\n\nterm_query\030\002 \001(\0132\026.milvus.grpc.TermQue" + "ryH\000\022.\n\013range_query\030\003 \001(\0132\027.milvus.grpc." + "RangeQueryH\000\0220\n\014vector_query\030\004 \001(\0132\030.mil" + "vus.grpc.VectorQueryH\000B\007\n\005query\"\247\001\n\014HSea" + "rchParam\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023par" + "tition_tag_array\030\002 \003(\t\0220\n\rgeneral_query\030" + "\003 \001(\0132\031.milvus.grpc.GeneralQuery\022/\n\014extr" + "a_params\030\004 \003(\0132\031.milvus.grpc.KeyValuePai" + "r\"c\n\026HSearchInSegmentsParam\022\030\n\020segment_i" + "d_array\030\001 \003(\t\022/\n\014search_param\030\002 \001(\0132\031.mi" + "lvus.grpc.HSearchParam\"5\n\nAttrRecord\022\021\n\t" + "int_value\030\001 \003(\003\022\024\n\014double_value\030\002 \003(\001\"\363\001" + "\n\007HEntity\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." + "Status\022\021\n\tentity_id\030\002 \003(\003\022\023\n\013field_names" + "\030\003 \003(\t\022)\n\ndata_types\030\004 \003(\0162\025.milvus.grpc" + ".DataType\022\017\n\007row_num\030\005 \001(\003\022*\n\tattr_data\030" + "\006 \003(\0132\027.milvus.grpc.AttrRecord\0223\n\013vector" + "_data\030\007 \003(\0132\036.milvus.grpc.VectorFieldRec" + "ord\"\274\001\n\014HQueryResult\022#\n\006status\030\001 \001(\0132\023.m" + "ilvus.grpc.Status\022$\n\006entity\030\002 \001(\0132\024.milv" + "us.grpc.HEntity\022\017\n\007row_num\030\003 \001(\003\022\r\n\005scor" + "e\030\004 \003(\002\022\020\n\010distance\030\005 \003(\002\022/\n\014extra_param" + "s\030\006 \003(\0132\031.milvus.grpc.KeyValuePair\"\256\001\n\014H" + "InsertParam\022\027\n\017collection_name\030\001 \001(\t\022\025\n\r" + "partition_tag\030\002 \001(\t\022$\n\006entity\030\003 \001(\0132\024.mi" + "lvus.grpc.HEntity\022\027\n\017entity_id_array\030\004 \003" + "(\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.K" + "eyValuePair\"6\n\017HEntityIdentity\022\027\n\017collec" + "tion_name\030\001 \001(\t\022\n\n\002id\030\002 \003(\003\"J\n\nHEntityID" + "s\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" + "\n\017entity_id_array\030\002 \003(\003\"C\n\022HGetEntityIDs" + "Param\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014segmen" + "t_name\030\002 \001(\t\"=\n\020HDeleteByIDParam\022\027\n\017coll" + "ection_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"\220\001\n\013" + "HIndexParam\022#\n\006status\030\001 \001(\0132\023.milvus.grp" + "c.Status\022\027\n\017collection_name\030\002 \001(\t\022\022\n\nind" + "ex_type\030\003 \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.mi" + "lvus.grpc.KeyValuePair*\206\001\n\010DataType\022\010\n\004N" + "ULL\020\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n" + "\005INT64\020\004\022\n\n\006STRING\020\024\022\010\n\004BOOL\020\036\022\t\n\005FLOAT\020" + "(\022\n\n\006DOUBLE\020)\022\n\n\006VECTOR\020d\022\014\n\007UNKNOWN\020\217N*" + "C\n\017CompareOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002E" + "Q\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\321\026\n\rMilvusService\022H\n\020CreateCollec" + "tion\022\035.milvus.grpc.CollectionSchema\032\023.mi" + "lvus.grpc.Status\"\000\022F\n\rHasCollection\022\033.mi" + "lvus.grpc.CollectionName\032\026.milvus.grpc.B" + "oolReply\"\000\022R\n\022DescribeCollection\022\033.milvu" + "s.grpc.CollectionName\032\035.milvus.grpc.Coll" + "ectionSchema\"\000\022Q\n\017CountCollection\022\033.milv" + "us.grpc.CollectionName\032\037.milvus.grpc.Col" + "lectionRowCount\"\000\022J\n\017ShowCollections\022\024.m" + "ilvus.grpc.Command\032\037.milvus.grpc.Collect" + "ionNameList\"\000\022P\n\022ShowCollectionInfo\022\033.mi" + "lvus.grpc.CollectionName\032\033.milvus.grpc.C" + "ollectionInfo\"\000\022D\n\016DropCollection\022\033.milv" + "us.grpc.CollectionName\032\023.milvus.grpc.Sta" + "tus\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.Index" + "Param\032\023.milvus.grpc.Status\"\000\022G\n\rDescribe" + "Index\022\033.milvus.grpc.CollectionName\032\027.mil" + "vus.grpc.IndexParam\"\000\022\?\n\tDropIndex\022\033.mil" + "vus.grpc.CollectionName\032\023.milvus.grpc.St" + "atus\"\000\022E\n\017CreatePartition\022\033.milvus.grpc." + "PartitionParam\032\023.milvus.grpc.Status\"\000\022E\n" + "\014HasPartition\022\033.milvus.grpc.PartitionPar" + "am\032\026.milvus.grpc.BoolReply\"\000\022K\n\016ShowPart" + "itions\022\033.milvus.grpc.CollectionName\032\032.mi" + "lvus.grpc.PartitionList\"\000\022C\n\rDropPartiti" + "on\022\033.milvus.grpc.PartitionParam\032\023.milvus" + ".grpc.Status\"\000\022<\n\006Insert\022\030.milvus.grpc.I" + "nsertParam\032\026.milvus.grpc.VectorIds\"\000\022J\n\016" + "GetVectorsByID\022\034.milvus.grpc.VectorsIden" + "tity\032\030.milvus.grpc.VectorsData\"\000\022H\n\014GetV" + "ectorIDs\022\036.milvus.grpc.GetVectorIDsParam" + "\032\026.milvus.grpc.VectorIds\"\000\022B\n\006Search\022\030.m" + "ilvus.grpc.SearchParam\032\034.milvus.grpc.Top" + "KQueryResult\"\000\022J\n\nSearchByID\022\034.milvus.gr" + "pc.SearchByIDParam\032\034.milvus.grpc.TopKQue" + "ryResult\"\000\022P\n\rSearchInFiles\022\037.milvus.grp" + "c.SearchInFilesParam\032\034.milvus.grpc.TopKQ" + "ueryResult\"\000\0227\n\003Cmd\022\024.milvus.grpc.Comman" + "d\032\030.milvus.grpc.StringReply\"\000\022A\n\nDeleteB" + "yID\022\034.milvus.grpc.DeleteByIDParam\032\023.milv" + "us.grpc.Status\"\000\022G\n\021PreloadCollection\022\033." + "milvus.grpc.CollectionName\032\023.milvus.grpc" + ".Status\"\000\0227\n\005Flush\022\027.milvus.grpc.FlushPa" + "ram\032\023.milvus.grpc.Status\"\000\022=\n\007Compact\022\033." + "milvus.grpc.CollectionName\032\023.milvus.grpc" + ".Status\"\000\022E\n\026CreateHybridCollection\022\024.mi" + "lvus.grpc.Mapping\032\023.milvus.grpc.Status\"\000" + "\022L\n\023HasHybridCollection\022\033.milvus.grpc.Co" + "llectionName\032\026.milvus.grpc.BoolReply\"\000\022J" + "\n\024DropHybridCollection\022\033.milvus.grpc.Col" + "lectionName\032\023.milvus.grpc.Status\"\000\022O\n\030De" + "scribeHybridCollection\022\033.milvus.grpc.Col" + "lectionName\032\024.milvus.grpc.Mapping\"\000\022W\n\025C" + "ountHybridCollection\022\033.milvus.grpc.Colle" + "ctionName\032\037.milvus.grpc.CollectionRowCou" + "nt\"\000\022I\n\025ShowHybridCollections\022\024.milvus.g" + "rpc.Command\032\030.milvus.grpc.MappingList\"\000\022" + "V\n\030ShowHybridCollectionInfo\022\033.milvus.grp" + "c.CollectionName\032\033.milvus.grpc.Collectio" + "nInfo\"\000\022M\n\027PreloadHybridCollection\022\033.mil" + "vus.grpc.CollectionName\032\023.milvus.grpc.St" + "atus\"\000\022D\n\014InsertEntity\022\031.milvus.grpc.HIn" + "sertParam\032\027.milvus.grpc.HEntityIDs\"\000\022F\n\014" + "HybridSearch\022\031.milvus.grpc.HSearchParam\032" + "\031.milvus.grpc.HQueryResult\"\000\022]\n\026HybridSe" + "archInSegments\022#.milvus.grpc.HSearchInSe" + "gmentsParam\032\034.milvus.grpc.TopKQueryResul" + "t\"\000\022E\n\rGetEntityByID\022\034.milvus.grpc.Vecto" + "rsIdentity\032\024.milvus.grpc.HEntity\"\000\022J\n\014Ge" + "tEntityIDs\022\037.milvus.grpc.HGetEntityIDsPa" + "ram\032\027.milvus.grpc.HEntityIDs\"\000\022J\n\022Delete" + "EntitiesByID\022\035.milvus.grpc.HDeleteByIDPa" + "ram\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, @@ -1699,7 +1704,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_TermQuery_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorFieldParam_milvus_2eproto.base, - &scc_info_VectorFieldValue_milvus_2eproto.base, + &scc_info_VectorFieldRecord_milvus_2eproto.base, &scc_info_VectorIds_milvus_2eproto.base, &scc_info_VectorQuery_milvus_2eproto.base, &scc_info_VectorsData_milvus_2eproto.base, @@ -1708,7 +1713,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8235, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 8354, &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 47, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, file_level_metadata_milvus_2eproto, 48, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, @@ -11480,48 +11485,48 @@ void FieldParam::InternalSwap(FieldParam* other) { // =================================================================== -void VectorFieldValue::InitAsDefaultInstance() { +void VectorFieldRecord::InitAsDefaultInstance() { } -class VectorFieldValue::_Internal { +class VectorFieldRecord::_Internal { public: }; -VectorFieldValue::VectorFieldValue() +VectorFieldRecord::VectorFieldRecord() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(constructor:milvus.grpc.VectorFieldRecord) } -VectorFieldValue::VectorFieldValue(const VectorFieldValue& from) +VectorFieldRecord::VectorFieldRecord(const VectorFieldRecord& 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) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorFieldRecord) } -void VectorFieldValue::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldValue_milvus_2eproto.base); +void VectorFieldRecord::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorFieldRecord_milvus_2eproto.base); } -VectorFieldValue::~VectorFieldValue() { - // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldValue) +VectorFieldRecord::~VectorFieldRecord() { + // @@protoc_insertion_point(destructor:milvus.grpc.VectorFieldRecord) SharedDtor(); } -void VectorFieldValue::SharedDtor() { +void VectorFieldRecord::SharedDtor() { } -void VectorFieldValue::SetCachedSize(int size) const { +void VectorFieldRecord::SetCachedSize(int size) const { _cached_size_.Set(size); } -const VectorFieldValue& VectorFieldValue::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldValue_milvus_2eproto.base); +const VectorFieldRecord& VectorFieldRecord::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorFieldRecord_milvus_2eproto.base); return *internal_default_instance(); } -void VectorFieldValue::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11531,7 +11536,7 @@ void VectorFieldValue::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* VectorFieldValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* VectorFieldRecord::_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; @@ -11570,11 +11575,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool VectorFieldValue::MergePartialFromCodedStream( +bool VectorFieldRecord::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) + // @@protoc_insertion_point(parse_start:milvus.grpc.VectorFieldRecord) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -11603,18 +11608,18 @@ bool VectorFieldValue::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(parse_success:milvus.grpc.VectorFieldRecord) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorFieldRecord) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void VectorFieldValue::SerializeWithCachedSizes( +void VectorFieldRecord::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11631,12 +11636,12 @@ void VectorFieldValue::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorFieldRecord) } -::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldValue::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* VectorFieldRecord::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11652,12 +11657,12 @@ void VectorFieldValue::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorFieldRecord) return target; } -size_t VectorFieldValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldValue) +size_t VectorFieldRecord::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorFieldRecord) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -11685,23 +11690,23 @@ size_t VectorFieldValue::ByteSizeLong() const { return total_size; } -void VectorFieldValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorFieldRecord) GOOGLE_DCHECK_NE(&from, this); - const VectorFieldValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const VectorFieldRecord* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorFieldRecord) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorFieldRecord) MergeFrom(*source); } } -void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::MergeFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorFieldRecord) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11710,31 +11715,31 @@ void VectorFieldValue::MergeFrom(const VectorFieldValue& from) { value_.MergeFrom(from.value_); } -void VectorFieldValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorFieldRecord) if (&from == this) return; Clear(); MergeFrom(from); } -void VectorFieldValue::CopyFrom(const VectorFieldValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldValue) +void VectorFieldRecord::CopyFrom(const VectorFieldRecord& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorFieldRecord) if (&from == this) return; Clear(); MergeFrom(from); } -bool VectorFieldValue::IsInitialized() const { +bool VectorFieldRecord::IsInitialized() const { return true; } -void VectorFieldValue::InternalSwap(VectorFieldValue* other) { +void VectorFieldRecord::InternalSwap(VectorFieldRecord* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&value_)->InternalSwap(CastToBase(&other->value_)); } -::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldValue::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata VectorFieldRecord::GetMetadata() const { return GetMetadataStatic(); } @@ -11742,26 +11747,24 @@ void VectorFieldValue::InternalSwap(VectorFieldValue* other) { // =================================================================== 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()); + ::milvus::grpc::_FieldValue_default_instance_.vector_value_ = const_cast< ::milvus::grpc::VectorFieldRecord*>( + ::milvus::grpc::VectorFieldRecord::internal_default_instance()); } class FieldValue::_Internal { public: - static const ::milvus::grpc::VectorFieldValue& vector_value(const FieldValue* msg); + static const ::milvus::grpc::VectorFieldRecord& vector_value(const FieldValue* msg); }; -const ::milvus::grpc::VectorFieldValue& +const ::milvus::grpc::VectorFieldRecord& FieldValue::_Internal::vector_value(const FieldValue* msg) { return *msg->value_.vector_value_; } -void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldValue* vector_value) { +void FieldValue::set_allocated_vector_value(::milvus::grpc::VectorFieldRecord* vector_value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); clear_value(); if (vector_value) { @@ -11786,18 +11789,10 @@ FieldValue::FieldValue(const FieldValue& from) _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; @@ -11811,7 +11806,7 @@ FieldValue::FieldValue(const FieldValue& from) break; } case kVectorValue: { - mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + mutable_vector_value()->::milvus::grpc::VectorFieldRecord::MergeFrom(from.vector_value()); break; } case VALUE_NOT_SET: { @@ -11849,18 +11844,10 @@ const FieldValue& FieldValue::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; @@ -11903,51 +11890,37 @@ const char* FieldValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // int32 int32_value = 1; + // int64 int64_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)) { + // double double_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { 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)) { + // string string_value = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { 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)) { + // bool bool_value = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { 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)) { + // .milvus.grpc.VectorFieldRecord vector_value = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(mutable_vector_value(), ptr); CHK_(ptr); } else goto handle_unusual; @@ -11982,23 +11955,9 @@ bool FieldValue::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // int32 int32_value = 1; + // int64 int64_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>( @@ -12010,23 +11969,9 @@ bool FieldValue::MergePartialFromCodedStream( 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)) { + // double double_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) { clear_value(); DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( @@ -12038,9 +11983,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // string string_value = 5; - case 5: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + // string string_value = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( input, this->mutable_string_value())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( @@ -12053,9 +11998,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // bool bool_value = 6; - case 6: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + // bool bool_value = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { clear_value(); DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>( @@ -12067,9 +12012,9 @@ bool FieldValue::MergePartialFromCodedStream( break; } - // .milvus.grpc.VectorFieldValue vector_value = 7; - case 7: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + // .milvus.grpc.VectorFieldRecord vector_value = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( input, mutable_vector_value())); } else { @@ -12105,45 +12050,35 @@ void FieldValue::SerializeWithCachedSizes( ::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; + // int64 int64_value = 1; 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); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->int64_value(), output); } - // double double_value = 4; + // double double_value = 2; if (has_double_value()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(4, this->double_value(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(2, this->double_value(), output); } - // string string_value = 5; + // string string_value = 3; 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); + 3, this->string_value(), output); } - // bool bool_value = 6; + // bool bool_value = 4; if (has_bool_value()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(6, this->bool_value(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(4, this->bool_value(), output); } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; if (has_vector_value()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 7, _Internal::vector_value(this), output); + 5, _Internal::vector_value(this), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -12159,27 +12094,17 @@ void FieldValue::SerializeWithCachedSizes( ::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; + // int64 int64_value = 1; 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); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->int64_value(), target); } - // double double_value = 4; + // double double_value = 2; if (has_double_value()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->double_value(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->double_value(), target); } - // string string_value = 5; + // string string_value = 3; if (has_string_value()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->string_value().data(), static_cast(this->string_value().length()), @@ -12187,19 +12112,19 @@ void FieldValue::SerializeWithCachedSizes( "milvus.grpc.FieldValue.string_value"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 5, this->string_value(), target); + 3, this->string_value(), target); } - // bool bool_value = 6; + // bool bool_value = 4; if (has_bool_value()) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->bool_value(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->bool_value(), target); } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; if (has_vector_value()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 7, _Internal::vector_value(this), target); + 5, _Internal::vector_value(this), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -12224,43 +12149,31 @@ size_t FieldValue::ByteSizeLong() const { (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; + // int64 int64_value = 1; 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; + // double double_value = 2; case kDoubleValue: { total_size += 1 + 8; break; } - // string string_value = 5; + // string string_value = 3; case kStringValue: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->string_value()); break; } - // bool bool_value = 6; + // bool bool_value = 4; case kBoolValue: { total_size += 1 + 1; break; } - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; case kVectorValue: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -12299,18 +12212,10 @@ void FieldValue::MergeFrom(const FieldValue& from) { (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; @@ -12324,7 +12229,7 @@ void FieldValue::MergeFrom(const FieldValue& from) { break; } case kVectorValue: { - mutable_vector_value()->::milvus::grpc::VectorFieldValue::MergeFrom(from.vector_value()); + mutable_vector_value()->::milvus::grpc::VectorFieldRecord::MergeFrom(from.vector_value()); break; } case VALUE_NOT_SET: { @@ -13141,16 +13046,14 @@ TermQuery::TermQuery() TermQuery::TermQuery(const TermQuery& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), + int_value_(from.int_value_), + double_value_(from.double_value_), 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_); } - values_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.values().empty()) { - values_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.values_); - } ::memcpy(&value_num_, &from.value_num_, static_cast(reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13160,7 +13063,6 @@ TermQuery::TermQuery(const TermQuery& from) void TermQuery::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TermQuery_milvus_2eproto.base); field_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&value_num_, 0, static_cast( reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13173,7 +13075,6 @@ TermQuery::~TermQuery() { void TermQuery::SharedDtor() { field_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void TermQuery::SetCachedSize(int size) const { @@ -13191,9 +13092,10 @@ void TermQuery::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + int_value_.Clear(); + double_value_.Clear(); extra_params_.Clear(); field_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - values_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&value_num_, 0, static_cast( reinterpret_cast(&boost_) - reinterpret_cast(&value_num_)) + sizeof(boost_)); @@ -13215,37 +13117,50 @@ const char* TermQuery::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // bytes values = 2; + // repeated int64 int_value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_values(), ptr, ctx); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; - // int64 value_num = 3; + // repeated double double_value = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - value_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); } else goto handle_unusual; continue; - // float boost = 4; + // int64 value_num = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + value_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float boost = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) { boost_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(float); } 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)) { + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { 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); + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); } else goto handle_unusual; continue; default: { @@ -13293,20 +13208,41 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // bytes values = 2; + // repeated int64 int_value = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { - DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( - input, this->mutable_values())); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int_value()))); + } 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_int_value()))); } else { goto handle_unusual; } break; } - // int64 value_num = 3; + // repeated double double_value = 3; case 3: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (25 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 26u, input, this->mutable_double_value()))); + } else { + goto handle_unusual; + } + break; + } + + // int64 value_num = 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>( @@ -13317,9 +13253,9 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // float boost = 4; - case 4: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (37 & 0xFF)) { + // float boost = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (45 & 0xFF)) { DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>( @@ -13330,9 +13266,9 @@ bool TermQuery::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; - case 5: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( input, add_extra_params())); } else { @@ -13378,27 +13314,41 @@ void TermQuery::SerializeWithCachedSizes( 1, this->field_name(), output); } - // bytes values = 2; - if (this->values().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( - 2, this->values(), output); + // repeated int64 int_value = 2; + if (this->int_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int_value(i), output); + } + + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); } - // int64 value_num = 3; + // int64 value_num = 4; if (this->value_num() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->value_num(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->value_num(), output); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(4, this->boost(), output); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloat(5, this->boost(), output); } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; for (unsigned int i = 0, n = static_cast(this->extra_params_size()); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 5, + 6, this->extra_params(static_cast(i)), output); } @@ -13427,29 +13377,48 @@ void TermQuery::SerializeWithCachedSizes( 1, this->field_name(), target); } - // bytes values = 2; - if (this->values().size() > 0) { - target = - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( - 2, this->values(), target); + // repeated int64 int_value = 2; + if (this->int_value_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( + _int_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int_value_, target); } - // int64 value_num = 3; + // repeated double double_value = 3; + if (this->double_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 3, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_value_, target); + } + + // int64 value_num = 4; if (this->value_num() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->value_num(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->value_num(), target); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->boost(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->boost(), target); } - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; 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); + 6, this->extra_params(static_cast(i)), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -13473,7 +13442,37 @@ size_t TermQuery::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated int64 int_value = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int_value_); + 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); + _int_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 3; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * 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); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; { unsigned int count = static_cast(this->extra_params_size()); total_size += 1UL * count; @@ -13491,21 +13490,14 @@ size_t TermQuery::ByteSizeLong() const { this->field_name()); } - // bytes values = 2; - if (this->values().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->values()); - } - - // int64 value_num = 3; + // int64 value_num = 4; if (this->value_num() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( this->value_num()); } - // float boost = 4; + // float boost = 5; if (!(this->boost() <= 0 && this->boost() >= 0)) { total_size += 1 + 4; } @@ -13537,15 +13529,13 @@ void TermQuery::MergeFrom(const TermQuery& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + int_value_.MergeFrom(from.int_value_); + double_value_.MergeFrom(from.double_value_); 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.values().size() > 0) { - - values_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.values_); - } if (from.value_num() != 0) { set_value_num(from.value_num()); } @@ -13575,11 +13565,11 @@ bool TermQuery::IsInitialized() const { void TermQuery::InternalSwap(TermQuery* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + int_value_.InternalSwap(&other->int_value_); + double_value_.InternalSwap(&other->double_value_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); field_name_.Swap(&other->field_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - values_.Swap(&other->values_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - GetArenaNoVirtual()); swap(value_num_, other->value_num_); swap(boost_, other->boost_); } @@ -16412,13 +16402,13 @@ AttrRecord::AttrRecord() AttrRecord::AttrRecord(const AttrRecord& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - value_(from.value_) { + int_value_(from.int_value_), + double_value_(from.double_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() { @@ -16444,7 +16434,8 @@ void AttrRecord::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - value_.Clear(); + int_value_.Clear(); + double_value_.Clear(); _internal_metadata_.Clear(); } @@ -16456,16 +16447,24 @@ const char* AttrRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // repeated string value = 1; + // repeated int64 int_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); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_int_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { + add_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated double double_value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(mutable_double_value(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17) { + add_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); } else goto handle_unusual; continue; default: { @@ -16498,16 +16497,32 @@ bool AttrRecord::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // repeated string value = 1; + // repeated int64 int_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")); + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + 1, 10u, input, this->mutable_int_value()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated double double_value = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_value()))); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) { + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 18u, input, this->mutable_double_value()))); } else { goto handle_unusual; } @@ -16541,14 +16556,24 @@ void AttrRecord::SerializeWithCachedSizes( ::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); + // repeated int64 int_value = 1; + if (this->int_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_int_value_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->int_value_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->int_value(i), output); + } + + // repeated double double_value = 2; + if (this->double_value_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_double_value_cached_byte_size_.load( + std::memory_order_relaxed)); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleArray( + this->double_value().data(), this->double_value_size(), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -16564,16 +16589,32 @@ void AttrRecord::SerializeWithCachedSizes( ::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); - } - + // repeated int64 int_value = 1; + if (this->int_value_size() > 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( + 1, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( + _int_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int_value_, target); + } + + // repeated double double_value = 2; + if (this->double_value_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( + _double_value_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_value_, target); + } + if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); @@ -16595,12 +16636,34 @@ size_t AttrRecord::ByteSizeLong() const { // 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)); + // repeated int64 int_value = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->int_value_); + 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); + _int_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_value = 2; + { + unsigned int count = static_cast(this->double_value_size()); + size_t data_size = 8UL * 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); + _double_value_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -16630,7 +16693,8 @@ void AttrRecord::MergeFrom(const AttrRecord& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - value_.MergeFrom(from.value_); + int_value_.MergeFrom(from.int_value_); + double_value_.MergeFrom(from.double_value_); } void AttrRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -16654,7 +16718,8 @@ bool AttrRecord::IsInitialized() const { void AttrRecord::InternalSwap(AttrRecord* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - value_.InternalSwap(CastToBase(&other->value_)); + int_value_.InternalSwap(&other->int_value_); + double_value_.InternalSwap(&other->double_value_); } ::PROTOBUF_NAMESPACE_ID::Metadata AttrRecord::GetMetadata() const { @@ -16691,27 +16756,23 @@ HEntity::HEntity() HEntity::HEntity(const HEntity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), + entity_id_(from.entity_id_), field_names_(from.field_names_), - result_values_(from.result_values_) { + data_types_(from.data_types_), + attr_data_(from.attr_data_), + vector_data_(from.vector_data_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - attr_records_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.attr_records().empty()) { - attr_records_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.attr_records_); - } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } - ::memcpy(&entity_id_, &from.entity_id_, - static_cast(reinterpret_cast(&row_num_) - - reinterpret_cast(&entity_id_)) + sizeof(row_num_)); + row_num_ = from.row_num_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.HEntity) } void HEntity::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_HEntity_milvus_2eproto.base); - attr_records_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&row_num_) - reinterpret_cast(&status_)) + sizeof(row_num_)); @@ -16723,7 +16784,6 @@ HEntity::~HEntity() { } void HEntity::SharedDtor() { - attr_records_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } @@ -16742,16 +16802,16 @@ void HEntity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + entity_id_.Clear(); field_names_.Clear(); - result_values_.Clear(); - attr_records_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + data_types_.Clear(); + attr_data_.Clear(); + vector_data_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; - ::memset(&entity_id_, 0, static_cast( - reinterpret_cast(&row_num_) - - reinterpret_cast(&entity_id_)) + sizeof(row_num_)); + row_num_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -16770,10 +16830,13 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // int64 entity_id = 2; + // repeated 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); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_entity_id(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_entity_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -16789,11 +16852,15 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26); } else goto handle_unusual; continue; - // bytes attr_records = 4; + // repeated .milvus.grpc.DataType data_types = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_attr_records(), ptr, ctx); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(mutable_data_types(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); CHK_(ptr); + add_data_types(static_cast<::milvus::grpc::DataType>(val)); } else goto handle_unusual; continue; // int64 row_num = 5; @@ -16803,18 +16870,30 @@ const char* HEntity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr -= 1; do { ptr += 1; - ptr = ctx->ParseMessage(add_result_values(), ptr); + ptr = ctx->ParseMessage(add_attr_data(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); } else goto handle_unusual; continue; + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_vector_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -16856,13 +16935,16 @@ bool HEntity::MergePartialFromCodedStream( break; } - // int64 entity_id = 2; + // repeated int64 entity_id = 2; case 2: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { - - DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + 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, &entity_id_))); + input, this->mutable_entity_id()))); + } 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()))); } else { goto handle_unusual; } @@ -16885,11 +16967,26 @@ bool HEntity::MergePartialFromCodedStream( break; } - // bytes attr_records = 4; + // repeated .milvus.grpc.DataType data_types = 4; case 4: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { - DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes( - input, this->mutable_attr_records())); + ::PROTOBUF_NAMESPACE_ID::uint32 length; + DO_(input->ReadVarint32(&length)); + ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream::Limit limit = input->PushLimit(static_cast(length)); + while (input->BytesUntilLimit() > 0) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_data_types(static_cast< ::milvus::grpc::DataType >(value)); + } + input->PopLimit(limit); + } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + add_data_types(static_cast< ::milvus::grpc::DataType >(value)); } else { goto handle_unusual; } @@ -16909,11 +17006,22 @@ bool HEntity::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; case 6: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, add_result_values())); + input, add_attr_data())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (58 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_vector_data())); } else { goto handle_unusual; } @@ -16953,9 +17061,15 @@ void HEntity::SerializeWithCachedSizes( 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 int64 entity_id = 2; + if (this->entity_id_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_entity_id_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->entity_id_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->entity_id(i), output); } // repeated string field_names = 3; @@ -16968,10 +17082,18 @@ void HEntity::SerializeWithCachedSizes( 3, this->field_names(i), output); } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased( - 4, this->attr_records(), output); + // repeated .milvus.grpc.DataType data_types = 4; + if (this->data_types_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag( + 4, + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + output); + output->WriteVarint32(_data_types_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->data_types_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumNoTag( + this->data_types(i), output); } // int64 row_num = 5; @@ -16979,12 +17101,21 @@ void HEntity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(5, this->row_num(), output); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; for (unsigned int i = 0, - n = static_cast(this->result_values_size()); i < n; i++) { + n = static_cast(this->attr_data_size()); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( 6, - this->result_values(static_cast(i)), + this->attr_data(static_cast(i)), + output); + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + for (unsigned int i = 0, + n = static_cast(this->vector_data_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, + this->vector_data(static_cast(i)), output); } @@ -17008,9 +17139,17 @@ void HEntity::SerializeWithCachedSizes( 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 int64 entity_id = 2; + if (this->entity_id_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_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->entity_id_, target); } // repeated string field_names = 3; @@ -17023,11 +17162,16 @@ void HEntity::SerializeWithCachedSizes( WriteStringToArray(3, this->field_names(i), target); } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - target = - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesToArray( - 4, this->attr_records(), target); + // repeated .milvus.grpc.DataType data_types = 4; + if (this->data_types_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( _data_types_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumNoTagToArray( + this->data_types_, target); } // int64 row_num = 5; @@ -17035,12 +17179,20 @@ void HEntity::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->row_num(), target); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.AttrRecord attr_data = 6; + for (unsigned int i = 0, + n = static_cast(this->attr_data_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, this->attr_data(static_cast(i)), target); + } + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; for (unsigned int i = 0, - n = static_cast(this->result_values_size()); i < n; i++) { + n = static_cast(this->vector_data_size()); i < n; i++) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 6, this->result_values(static_cast(i)), target); + 7, this->vector_data(static_cast(i)), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -17064,6 +17216,21 @@ size_t HEntity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // repeated int64 entity_id = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->entity_id_); + 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_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + // repeated string field_names = 3; total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->field_names_size()); @@ -17072,22 +17239,44 @@ size_t HEntity::ByteSizeLong() const { this->field_names(i)); } - // repeated .milvus.grpc.FieldValue result_values = 6; + // repeated .milvus.grpc.DataType data_types = 4; + { + size_t data_size = 0; + unsigned int count = static_cast(this->data_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->data_types(static_cast(i))); + } + 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); + _data_types_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .milvus.grpc.AttrRecord attr_data = 6; { - unsigned int count = static_cast(this->result_values_size()); + unsigned int count = static_cast(this->attr_data_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))); + this->attr_data(static_cast(i))); } } - // bytes attr_records = 4; - if (this->attr_records().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->attr_records()); + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + { + unsigned int count = static_cast(this->vector_data_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->vector_data(static_cast(i))); + } } // .milvus.grpc.Status status = 1; @@ -17097,13 +17286,6 @@ size_t HEntity::ByteSizeLong() const { *status_); } - // int64 entity_id = 2; - if (this->entity_id() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->entity_id()); - } - // int64 row_num = 5; if (this->row_num() != 0) { total_size += 1 + @@ -17138,18 +17320,14 @@ void HEntity::MergeFrom(const HEntity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + entity_id_.MergeFrom(from.entity_id_); field_names_.MergeFrom(from.field_names_); - result_values_.MergeFrom(from.result_values_); - if (from.attr_records().size() > 0) { - - attr_records_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.attr_records_); - } + data_types_.MergeFrom(from.data_types_); + attr_data_.MergeFrom(from.attr_data_); + vector_data_.MergeFrom(from.vector_data_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } - if (from.entity_id() != 0) { - set_entity_id(from.entity_id()); - } if (from.row_num() != 0) { set_row_num(from.row_num()); } @@ -17176,12 +17354,12 @@ bool HEntity::IsInitialized() const { void HEntity::InternalSwap(HEntity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + entity_id_.InternalSwap(&other->entity_id_); field_names_.InternalSwap(CastToBase(&other->field_names_)); - CastToBase(&result_values_)->InternalSwap(CastToBase(&other->result_values_)); - attr_records_.Swap(&other->attr_records_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - GetArenaNoVirtual()); + data_types_.InternalSwap(&other->data_types_); + CastToBase(&attr_data_)->InternalSwap(CastToBase(&other->attr_data_)); + CastToBase(&vector_data_)->InternalSwap(CastToBase(&other->vector_data_)); swap(status_, other->status_); - swap(entity_id_, other->entity_id_); swap(row_num_, other->row_num_); } @@ -17195,16 +17373,23 @@ void HEntity::InternalSwap(HEntity* other) { void HQueryResult::InitAsDefaultInstance() { ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); + ::milvus::grpc::_HQueryResult_default_instance_._instance.get_mutable()->entity_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::HEntity::internal_default_instance()); } class HQueryResult::_Internal { public: static const ::milvus::grpc::Status& status(const HQueryResult* msg); + static const ::milvus::grpc::HEntity& entity(const HQueryResult* msg); }; const ::milvus::grpc::Status& HQueryResult::_Internal::status(const HQueryResult* msg) { return *msg->status_; } +const ::milvus::grpc::HEntity& +HQueryResult::_Internal::entity(const HQueryResult* msg) { + return *msg->entity_; +} void HQueryResult::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; @@ -17219,15 +17404,20 @@ HQueryResult::HQueryResult() HQueryResult::HQueryResult(const HQueryResult& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - entities_(from.entities_), score_(from.score_), - distance_(from.distance_) { + distance_(from.distance_), + extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } + if (from.has_entity()) { + entity_ = new ::milvus::grpc::HEntity(*from.entity_); + } else { + entity_ = nullptr; + } row_num_ = from.row_num_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.HQueryResult) } @@ -17246,6 +17436,7 @@ HQueryResult::~HQueryResult() { void HQueryResult::SharedDtor() { if (this != internal_default_instance()) delete status_; + if (this != internal_default_instance()) delete entity_; } void HQueryResult::SetCachedSize(int size) const { @@ -17263,13 +17454,17 @@ void HQueryResult::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - entities_.Clear(); score_.Clear(); distance_.Clear(); + extra_params_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; + } + entity_ = nullptr; row_num_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -17289,16 +17484,11 @@ const char* HQueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // repeated .milvus.grpc.HEntity entities = 2; + // .milvus.grpc.HEntity entity = 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); + ptr = ctx->ParseMessage(mutable_entity(), ptr); + CHK_(ptr); } else goto handle_unusual; continue; // int64 row_num = 3; @@ -17328,6 +17518,18 @@ const char* HQueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ptr += sizeof(float); } else goto handle_unusual; continue; + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + 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) == 50); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag & 7) == 4 || tag == 0) { @@ -17369,11 +17571,11 @@ bool HQueryResult::MergePartialFromCodedStream( break; } - // repeated .milvus.grpc.HEntity entities = 2; + // .milvus.grpc.HEntity entity = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, add_entities())); + input, mutable_entity())); } else { goto handle_unusual; } @@ -17425,6 +17627,17 @@ bool HQueryResult::MergePartialFromCodedStream( break; } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_extra_params())); + } else { + goto handle_unusual; + } + break; + } + default: { handle_unusual: if (tag == 0) { @@ -17458,13 +17671,10 @@ void HQueryResult::SerializeWithCachedSizes( 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++) { + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 2, - this->entities(static_cast(i)), - output); + 2, _Internal::entity(this), output); } // int64 row_num = 3; @@ -17490,6 +17700,15 @@ void HQueryResult::SerializeWithCachedSizes( this->distance().data(), this->distance_size(), output); } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, + this->extra_params(static_cast(i)), + output); + } + if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); @@ -17510,12 +17729,11 @@ void HQueryResult::SerializeWithCachedSizes( 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++) { + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 2, this->entities(static_cast(i)), target); + 2, _Internal::entity(this), target); } // int64 row_num = 3; @@ -17549,6 +17767,14 @@ void HQueryResult::SerializeWithCachedSizes( WriteFloatNoTagToArray(this->distance_, target); } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + for (unsigned int i = 0, + n = static_cast(this->extra_params_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, 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); @@ -17570,17 +17796,6 @@ size_t HQueryResult::ByteSizeLong() const { // 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()); @@ -17611,6 +17826,17 @@ size_t HQueryResult::ByteSizeLong() const { total_size += data_size; } + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + { + 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))); + } + } + // .milvus.grpc.Status status = 1; if (this->has_status()) { total_size += 1 + @@ -17618,6 +17844,13 @@ size_t HQueryResult::ByteSizeLong() const { *status_); } + // .milvus.grpc.HEntity entity = 2; + if (this->has_entity()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *entity_); + } + // int64 row_num = 3; if (this->row_num() != 0) { total_size += 1 + @@ -17652,12 +17885,15 @@ void HQueryResult::MergeFrom(const HQueryResult& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - entities_.MergeFrom(from.entities_); score_.MergeFrom(from.score_); distance_.MergeFrom(from.distance_); + extra_params_.MergeFrom(from.extra_params_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } + if (from.has_entity()) { + mutable_entity()->::milvus::grpc::HEntity::MergeFrom(from.entity()); + } if (from.row_num() != 0) { set_row_num(from.row_num()); } @@ -17684,10 +17920,11 @@ bool HQueryResult::IsInitialized() const { 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_); + CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); swap(status_, other->status_); + swap(entity_, other->entity_); swap(row_num_, other->row_num_); } @@ -17699,17 +17936,17 @@ void HQueryResult::InternalSwap(HQueryResult* other) { // =================================================================== void HInsertParam::InitAsDefaultInstance() { - ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entities_ = const_cast< ::milvus::grpc::HEntity*>( + ::milvus::grpc::_HInsertParam_default_instance_._instance.get_mutable()->entity_ = const_cast< ::milvus::grpc::HEntity*>( ::milvus::grpc::HEntity::internal_default_instance()); } class HInsertParam::_Internal { public: - static const ::milvus::grpc::HEntity& entities(const HInsertParam* msg); + static const ::milvus::grpc::HEntity& entity(const HInsertParam* msg); }; const ::milvus::grpc::HEntity& -HInsertParam::_Internal::entities(const HInsertParam* msg) { - return *msg->entities_; +HInsertParam::_Internal::entity(const HInsertParam* msg) { + return *msg->entity_; } HInsertParam::HInsertParam() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { @@ -17730,10 +17967,10 @@ HInsertParam::HInsertParam(const HInsertParam& from) 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_); + if (from.has_entity()) { + entity_ = new ::milvus::grpc::HEntity(*from.entity_); } else { - entities_ = nullptr; + entity_ = nullptr; } // @@protoc_insertion_point(copy_constructor:milvus.grpc.HInsertParam) } @@ -17742,7 +17979,7 @@ 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; + entity_ = nullptr; } HInsertParam::~HInsertParam() { @@ -17753,7 +17990,7 @@ HInsertParam::~HInsertParam() { 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_; + if (this != internal_default_instance()) delete entity_; } void HInsertParam::SetCachedSize(int size) const { @@ -17775,10 +18012,10 @@ void HInsertParam::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_; + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; } - entities_ = nullptr; + entity_ = nullptr; _internal_metadata_.Clear(); } @@ -17804,10 +18041,10 @@ const char* HInsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .milvus.grpc.HEntity entities = 3; + // .milvus.grpc.HEntity entity = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(mutable_entities(), ptr); + ptr = ctx->ParseMessage(mutable_entity(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -17893,11 +18130,11 @@ bool HInsertParam::MergePartialFromCodedStream( break; } - // .milvus.grpc.HEntity entities = 3; + // .milvus.grpc.HEntity entity = 3; case 3: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( - input, mutable_entities())); + input, mutable_entity())); } else { goto handle_unusual; } @@ -17978,10 +18215,10 @@ void HInsertParam::SerializeWithCachedSizes( 2, this->partition_tag(), output); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( - 3, _Internal::entities(this), output); + 3, _Internal::entity(this), output); } // repeated int64 entity_id_array = 4; @@ -18039,11 +18276,11 @@ void HInsertParam::SerializeWithCachedSizes( 2, this->partition_tag(), target); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessageToArray( - 3, _Internal::entities(this), target); + 3, _Internal::entity(this), target); } // repeated int64 entity_id_array = 4; @@ -18128,11 +18365,11 @@ size_t HInsertParam::ByteSizeLong() const { this->partition_tag()); } - // .milvus.grpc.HEntity entities = 3; - if (this->has_entities()) { + // .milvus.grpc.HEntity entity = 3; + if (this->has_entity()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *entities_); + *entity_); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -18172,8 +18409,8 @@ void HInsertParam::MergeFrom(const HInsertParam& from) { partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); } - if (from.has_entities()) { - mutable_entities()->::milvus::grpc::HEntity::MergeFrom(from.entities()); + if (from.has_entity()) { + mutable_entity()->::milvus::grpc::HEntity::MergeFrom(from.entity()); } } @@ -18204,7 +18441,7 @@ void HInsertParam::InternalSwap(HInsertParam* other) { GetArenaNoVirtual()); partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - swap(entities_, other->entities_); + swap(entity_, other->entity_); } ::PROTOBUF_NAMESPACE_ID::Metadata HInsertParam::GetMetadata() const { @@ -18227,20 +18464,19 @@ HEntityIdentity::HEntityIdentity() } HEntityIdentity::HEntityIdentity(const HEntityIdentity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), - _internal_metadata_(nullptr) { + _internal_metadata_(nullptr), + id_(from.id_) { _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() { @@ -18267,8 +18503,8 @@ void HEntityIdentity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + id_.Clear(); collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - id_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -18287,10 +18523,13 @@ const char* HEntityIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC CHK_(ptr); } else goto handle_unusual; continue; - // int64 id = 2; + // repeated int64 id = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_id(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { + add_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -18339,13 +18578,16 @@ bool HEntityIdentity::MergePartialFromCodedStream( break; } - // int64 id = 2; + // repeated int64 id = 2; case 2: { - if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { - - DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + 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, &id_))); + input, this->mutable_id()))); + } 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()))); } else { goto handle_unusual; } @@ -18389,9 +18631,15 @@ void HEntityIdentity::SerializeWithCachedSizes( 1, this->collection_name(), output); } - // int64 id = 2; - if (this->id() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->id(), output); + // repeated int64 id = 2; + if (this->id_size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(_id_cached_byte_size_.load( + std::memory_order_relaxed)); + } + for (int i = 0, n = this->id_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag( + this->id(i), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -18418,9 +18666,17 @@ void HEntityIdentity::SerializeWithCachedSizes( 1, this->collection_name(), target); } - // int64 id = 2; - if (this->id() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->id(), target); + // repeated int64 id = 2; + if (this->id_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_cached_byte_size_.load(std::memory_order_relaxed), + target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->id_, target); } if (_internal_metadata_.have_unknown_fields()) { @@ -18444,6 +18700,21 @@ size_t HEntityIdentity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // repeated int64 id = 2; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int64Size(this->id_); + 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_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 + @@ -18451,13 +18722,6 @@ size_t HEntityIdentity::ByteSizeLong() const { 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; @@ -18485,13 +18749,11 @@ void HEntityIdentity::MergeFrom(const HEntityIdentity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + id_.MergeFrom(from.id_); 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) { @@ -18515,9 +18777,9 @@ bool HEntityIdentity::IsInitialized() const { void HEntityIdentity::InternalSwap(HEntityIdentity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); + id_.InternalSwap(&other->id_); collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); - swap(id_, other->id_); } ::PROTOBUF_NAMESPACE_ID::Metadata HEntityIdentity::GetMetadata() const { @@ -20056,8 +20318,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldType* Arena::CreateMaybeMessag 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::VectorFieldRecord* Arena::CreateMaybeMessage< ::milvus::grpc::VectorFieldRecord >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::VectorFieldRecord >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::FieldValue* Arena::CreateMaybeMessage< ::milvus::grpc::FieldValue >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::FieldValue >(arena); diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.h b/sdk/grpc-gen/gen-milvus/milvus.pb.h index f9c74151..4088920a 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.h @@ -187,9 +187,9 @@ extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; class VectorFieldParam; class VectorFieldParamDefaultTypeInternal; extern VectorFieldParamDefaultTypeInternal _VectorFieldParam_default_instance_; -class VectorFieldValue; -class VectorFieldValueDefaultTypeInternal; -extern VectorFieldValueDefaultTypeInternal _VectorFieldValue_default_instance_; +class VectorFieldRecord; +class VectorFieldRecordDefaultTypeInternal; +extern VectorFieldRecordDefaultTypeInternal _VectorFieldRecord_default_instance_; class VectorIds; class VectorIdsDefaultTypeInternal; extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; @@ -248,7 +248,7 @@ template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc template<> ::milvus::grpc::TermQuery* Arena::CreateMaybeMessage<::milvus::grpc::TermQuery>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorFieldParam* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldParam>(Arena*); -template<> ::milvus::grpc::VectorFieldValue* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldValue>(Arena*); +template<> ::milvus::grpc::VectorFieldRecord* Arena::CreateMaybeMessage<::milvus::grpc::VectorFieldRecord>(Arena*); template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*); template<> ::milvus::grpc::VectorQuery* Arena::CreateMaybeMessage<::milvus::grpc::VectorQuery>(Arena*); template<> ::milvus::grpc::VectorsData* Arena::CreateMaybeMessage<::milvus::grpc::VectorsData>(Arena*); @@ -4545,23 +4545,23 @@ class FieldParam : }; // ------------------------------------------------------------------- -class VectorFieldValue : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldValue) */ { +class VectorFieldRecord : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorFieldRecord) */ { public: - VectorFieldValue(); - virtual ~VectorFieldValue(); + VectorFieldRecord(); + virtual ~VectorFieldRecord(); - VectorFieldValue(const VectorFieldValue& from); - VectorFieldValue(VectorFieldValue&& from) noexcept - : VectorFieldValue() { + VectorFieldRecord(const VectorFieldRecord& from); + VectorFieldRecord(VectorFieldRecord&& from) noexcept + : VectorFieldRecord() { *this = ::std::move(from); } - inline VectorFieldValue& operator=(const VectorFieldValue& from) { + inline VectorFieldRecord& operator=(const VectorFieldRecord& from) { CopyFrom(from); return *this; } - inline VectorFieldValue& operator=(VectorFieldValue&& from) noexcept { + inline VectorFieldRecord& operator=(VectorFieldRecord&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -4579,37 +4579,37 @@ class VectorFieldValue : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const VectorFieldValue& default_instance(); + static const VectorFieldRecord& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const VectorFieldValue* internal_default_instance() { - return reinterpret_cast( - &_VectorFieldValue_default_instance_); + static inline const VectorFieldRecord* internal_default_instance() { + return reinterpret_cast( + &_VectorFieldRecord_default_instance_); } static constexpr int kIndexInFileMessages = 27; - friend void swap(VectorFieldValue& a, VectorFieldValue& b) { + friend void swap(VectorFieldRecord& a, VectorFieldRecord& b) { a.Swap(&b); } - inline void Swap(VectorFieldValue* other) { + inline void Swap(VectorFieldRecord* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline VectorFieldValue* New() const final { - return CreateMaybeMessage(nullptr); + inline VectorFieldRecord* New() const final { + return CreateMaybeMessage(nullptr); } - VectorFieldValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + VectorFieldRecord* 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); + void CopyFrom(const VectorFieldRecord& from); + void MergeFrom(const VectorFieldRecord& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -4630,10 +4630,10 @@ class VectorFieldValue : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(VectorFieldValue* other); + void InternalSwap(VectorFieldRecord* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.VectorFieldValue"; + return "milvus.grpc.VectorFieldRecord"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -4671,7 +4671,7 @@ class VectorFieldValue : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >& value() const; - // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldValue) + // @@protoc_insertion_point(class_scope:milvus.grpc.VectorFieldRecord) private: class _Internal; @@ -4719,13 +4719,11 @@ class FieldValue : static const FieldValue& default_instance(); enum ValueCase { - kInt32Value = 1, - kInt64Value = 2, - kFloatValue = 3, - kDoubleValue = 4, - kStringValue = 5, - kBoolValue = 6, - kVectorValue = 7, + kInt64Value = 1, + kDoubleValue = 2, + kStringValue = 3, + kBoolValue = 4, + kVectorValue = 5, VALUE_NOT_SET = 0, }; @@ -4806,23 +4804,13 @@ class FieldValue : // accessors ------------------------------------------------------- enum : int { - kInt32ValueFieldNumber = 1, - kInt64ValueFieldNumber = 2, - kFloatValueFieldNumber = 3, - kDoubleValueFieldNumber = 4, - kStringValueFieldNumber = 5, - kBoolValueFieldNumber = 6, - kVectorValueFieldNumber = 7, + kInt64ValueFieldNumber = 1, + kDoubleValueFieldNumber = 2, + kStringValueFieldNumber = 3, + kBoolValueFieldNumber = 4, + kVectorValueFieldNumber = 5, }; - // 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; + // int64 int64_value = 1; private: bool has_int64_value() const; public: @@ -4830,15 +4818,7 @@ class FieldValue : ::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; + // double double_value = 2; private: bool has_double_value() const; public: @@ -4846,7 +4826,7 @@ class FieldValue : double double_value() const; void set_double_value(double value); - // string string_value = 5; + // string string_value = 3; private: bool has_string_value() const; public: @@ -4860,7 +4840,7 @@ class FieldValue : std::string* release_string_value(); void set_allocated_string_value(std::string* string_value); - // bool bool_value = 6; + // bool bool_value = 4; private: bool has_bool_value() const; public: @@ -4868,22 +4848,20 @@ class FieldValue : bool bool_value() const; void set_bool_value(bool value); - // .milvus.grpc.VectorFieldValue vector_value = 7; + // .milvus.grpc.VectorFieldRecord vector_value = 5; 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); + const ::milvus::grpc::VectorFieldRecord& vector_value() const; + ::milvus::grpc::VectorFieldRecord* release_vector_value(); + ::milvus::grpc::VectorFieldRecord* mutable_vector_value(); + void set_allocated_vector_value(::milvus::grpc::VectorFieldRecord* 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(); @@ -4895,13 +4873,11 @@ class FieldValue : ::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_; + ::milvus::grpc::VectorFieldRecord* vector_value_; } value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -5337,13 +5313,36 @@ class TermQuery : // accessors ------------------------------------------------------- enum : int { - kExtraParamsFieldNumber = 5, + kIntValueFieldNumber = 2, + kDoubleValueFieldNumber = 3, + kExtraParamsFieldNumber = 6, kFieldNameFieldNumber = 1, - kValuesFieldNumber = 2, - kValueNumFieldNumber = 3, - kBoostFieldNumber = 4, + kValueNumFieldNumber = 4, + kBoostFieldNumber = 5, }; - // repeated .milvus.grpc.KeyValuePair extra_params = 5; + // repeated int64 int_value = 2; + int int_value_size() const; + void clear_int_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const; + void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int_value(); + + // repeated double double_value = 3; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); + + // repeated .milvus.grpc.KeyValuePair extra_params = 6; int extra_params_size() const; void clear_extra_params(); ::milvus::grpc::KeyValuePair* mutable_extra_params(int index); @@ -5365,23 +5364,12 @@ class TermQuery : std::string* release_field_name(); void set_allocated_field_name(std::string* field_name); - // bytes values = 2; - void clear_values(); - const std::string& values() const; - void set_values(const std::string& value); - void set_values(std::string&& value); - void set_values(const char* value); - void set_values(const void* value, size_t size); - std::string* mutable_values(); - std::string* release_values(); - void set_allocated_values(std::string* values); - - // int64 value_num = 3; + // int64 value_num = 4; void clear_value_num(); ::PROTOBUF_NAMESPACE_ID::int64 value_num() const; void set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value); - // float boost = 4; + // float boost = 5; void clear_boost(); float boost() const; void set_boost(float value); @@ -5391,9 +5379,12 @@ class TermQuery : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_; + mutable std::atomic _int_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr field_name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr values_; ::PROTOBUF_NAMESPACE_ID::int64 value_num_; float boost_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -6667,31 +6658,40 @@ class AttrRecord : // accessors ------------------------------------------------------- enum : int { - kValueFieldNumber = 1, + kIntValueFieldNumber = 1, + kDoubleValueFieldNumber = 2, }; - // 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(); + // repeated int64 int_value = 1; + int int_value_size() const; + void clear_int_value(); + ::PROTOBUF_NAMESPACE_ID::int64 int_value(int index) const; + void set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + int_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_int_value(); + + // repeated double double_value = 2; + int double_value_size() const; + void clear_double_value(); + double double_value(int index) const; + void set_double_value(int index, double value); + void add_double_value(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& + double_value() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* + mutable_double_value(); // @@protoc_insertion_point(class_scope:milvus.grpc.AttrRecord) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField value_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > int_value_; + mutable std::atomic _int_value_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_value_; + mutable std::atomic _double_value_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -6810,13 +6810,25 @@ class HEntity : // accessors ------------------------------------------------------- enum : int { + kEntityIdFieldNumber = 2, kFieldNamesFieldNumber = 3, - kResultValuesFieldNumber = 6, - kAttrRecordsFieldNumber = 4, + kDataTypesFieldNumber = 4, + kAttrDataFieldNumber = 6, + kVectorDataFieldNumber = 7, kStatusFieldNumber = 1, - kEntityIdFieldNumber = 2, kRowNumFieldNumber = 5, }; + // repeated int64 entity_id = 2; + int entity_id_size() const; + void clear_entity_id(); + ::PROTOBUF_NAMESPACE_ID::int64 entity_id(int index) const; + void set_entity_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + entity_id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_entity_id(); + // repeated string field_names = 3; int field_names_size() const; void clear_field_names(); @@ -6834,27 +6846,36 @@ class HEntity : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& field_names() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_field_names(); - // repeated .milvus.grpc.FieldValue result_values = 6; - 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; - - // bytes attr_records = 4; - void clear_attr_records(); - const std::string& attr_records() const; - void set_attr_records(const std::string& value); - void set_attr_records(std::string&& value); - void set_attr_records(const char* value); - void set_attr_records(const void* value, size_t size); - std::string* mutable_attr_records(); - std::string* release_attr_records(); - void set_allocated_attr_records(std::string* attr_records); + // repeated .milvus.grpc.DataType data_types = 4; + int data_types_size() const; + void clear_data_types(); + ::milvus::grpc::DataType data_types(int index) const; + void set_data_types(int index, ::milvus::grpc::DataType value); + void add_data_types(::milvus::grpc::DataType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& data_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_data_types(); + + // repeated .milvus.grpc.AttrRecord attr_data = 6; + int attr_data_size() const; + void clear_attr_data(); + ::milvus::grpc::AttrRecord* mutable_attr_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* + mutable_attr_data(); + const ::milvus::grpc::AttrRecord& attr_data(int index) const; + ::milvus::grpc::AttrRecord* add_attr_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& + attr_data() const; + + // repeated .milvus.grpc.VectorFieldRecord vector_data = 7; + int vector_data_size() const; + void clear_vector_data(); + ::milvus::grpc::VectorFieldRecord* mutable_vector_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >* + mutable_vector_data(); + const ::milvus::grpc::VectorFieldRecord& vector_data(int index) const; + ::milvus::grpc::VectorFieldRecord* add_vector_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >& + vector_data() const; // .milvus.grpc.Status status = 1; bool has_status() const; @@ -6864,11 +6885,6 @@ class HEntity : ::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); - // int64 row_num = 5; void clear_row_num(); ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; @@ -6879,11 +6895,14 @@ class HEntity : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > entity_id_; + mutable std::atomic _entity_id_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField field_names_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::FieldValue > result_values_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attr_records_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField data_types_; + mutable std::atomic _data_types_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord > attr_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord > vector_data_; ::milvus::grpc::Status* status_; - ::PROTOBUF_NAMESPACE_ID::int64 entity_id_; ::PROTOBUF_NAMESPACE_ID::int64 row_num_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -7003,23 +7022,13 @@ class HQueryResult : // accessors ------------------------------------------------------- enum : int { - kEntitiesFieldNumber = 2, kScoreFieldNumber = 4, kDistanceFieldNumber = 5, + kExtraParamsFieldNumber = 6, kStatusFieldNumber = 1, + kEntityFieldNumber = 2, 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(); @@ -7042,6 +7051,17 @@ class HQueryResult : ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >* mutable_distance(); + // repeated .milvus.grpc.KeyValuePair extra_params = 6; + 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; + // .milvus.grpc.Status status = 1; bool has_status() const; void clear_status(); @@ -7050,6 +7070,14 @@ class HQueryResult : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); + // .milvus.grpc.HEntity entity = 2; + bool has_entity() const; + void clear_entity(); + const ::milvus::grpc::HEntity& entity() const; + ::milvus::grpc::HEntity* release_entity(); + ::milvus::grpc::HEntity* mutable_entity(); + void set_allocated_entity(::milvus::grpc::HEntity* entity); + // int64 row_num = 3; void clear_row_num(); ::PROTOBUF_NAMESPACE_ID::int64 row_num() const; @@ -7060,12 +7088,13 @@ class HQueryResult : 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_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; ::milvus::grpc::Status* status_; + ::milvus::grpc::HEntity* entity_; ::PROTOBUF_NAMESPACE_ID::int64 row_num_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -7189,7 +7218,7 @@ class HInsertParam : kExtraParamsFieldNumber = 5, kCollectionNameFieldNumber = 1, kPartitionTagFieldNumber = 2, - kEntitiesFieldNumber = 3, + kEntityFieldNumber = 3, }; // repeated int64 entity_id_array = 4; int entity_id_array_size() const; @@ -7235,13 +7264,13 @@ class HInsertParam : 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); + // .milvus.grpc.HEntity entity = 3; + bool has_entity() const; + void clear_entity(); + const ::milvus::grpc::HEntity& entity() const; + ::milvus::grpc::HEntity* release_entity(); + ::milvus::grpc::HEntity* mutable_entity(); + void set_allocated_entity(::milvus::grpc::HEntity* entity); // @@protoc_insertion_point(class_scope:milvus.grpc.HInsertParam) private: @@ -7253,7 +7282,7 @@ class HInsertParam : ::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_; + ::milvus::grpc::HEntity* entity_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -7372,9 +7401,20 @@ class HEntityIdentity : // accessors ------------------------------------------------------- enum : int { - kCollectionNameFieldNumber = 1, kIdFieldNumber = 2, + kCollectionNameFieldNumber = 1, }; + // repeated int64 id = 2; + int id_size() const; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::int64 id(int index) const; + void set_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value); + void add_id(::PROTOBUF_NAMESPACE_ID::int64 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& + id() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* + mutable_id(); + // string collection_name = 1; void clear_collection_name(); const std::string& collection_name() const; @@ -7386,18 +7426,14 @@ class HEntityIdentity : 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::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_; + mutable std::atomic _id_cached_byte_size_; ::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; }; @@ -10884,35 +10920,35 @@ FieldParam::extra_params() const { // ------------------------------------------------------------------- -// VectorFieldValue +// VectorFieldRecord // repeated .milvus.grpc.RowRecord value = 1; -inline int VectorFieldValue::value_size() const { +inline int VectorFieldRecord::value_size() const { return value_.size(); } -inline void VectorFieldValue::clear_value() { +inline void VectorFieldRecord::clear_value() { value_.Clear(); } -inline ::milvus::grpc::RowRecord* VectorFieldValue::mutable_value(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldValue.value) +inline ::milvus::grpc::RowRecord* VectorFieldRecord::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorFieldRecord.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) +VectorFieldRecord::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorFieldRecord.value) return &value_; } -inline const ::milvus::grpc::RowRecord& VectorFieldValue::value(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldValue.value) +inline const ::milvus::grpc::RowRecord& VectorFieldRecord::value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorFieldRecord.value) return value_.Get(index); } -inline ::milvus::grpc::RowRecord* VectorFieldValue::add_value() { - // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldValue.value) +inline ::milvus::grpc::RowRecord* VectorFieldRecord::add_value() { + // @@protoc_insertion_point(field_add:milvus.grpc.VectorFieldRecord.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) +VectorFieldRecord::value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.VectorFieldRecord.value) return value_; } @@ -10920,36 +10956,7 @@ VectorFieldValue::value() const { // 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; +// int64 int64_value = 1; inline bool FieldValue::has_int64_value() const { return value_case() == kInt64Value; } @@ -10978,36 +10985,7 @@ inline void FieldValue::set_int64_value(::PROTOBUF_NAMESPACE_ID::int64 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; +// double double_value = 2; inline bool FieldValue::has_double_value() const { return value_case() == kDoubleValue; } @@ -11036,7 +11014,7 @@ inline void FieldValue::set_double_value(double value) { // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.double_value) } -// string string_value = 5; +// string string_value = 3; inline bool FieldValue::has_string_value() const { return value_case() == kStringValue; } @@ -11126,7 +11104,7 @@ inline void FieldValue::set_allocated_string_value(std::string* string_value) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.FieldValue.string_value) } -// bool bool_value = 6; +// bool bool_value = 4; inline bool FieldValue::has_bool_value() const { return value_case() == kBoolValue; } @@ -11155,7 +11133,7 @@ inline void FieldValue::set_bool_value(bool value) { // @@protoc_insertion_point(field_set:milvus.grpc.FieldValue.bool_value) } -// .milvus.grpc.VectorFieldValue vector_value = 7; +// .milvus.grpc.VectorFieldRecord vector_value = 5; inline bool FieldValue::has_vector_value() const { return value_case() == kVectorValue; } @@ -11168,28 +11146,28 @@ inline void FieldValue::clear_vector_value() { clear_has_value(); } } -inline ::milvus::grpc::VectorFieldValue* FieldValue::release_vector_value() { +inline ::milvus::grpc::VectorFieldRecord* 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_; + ::milvus::grpc::VectorFieldRecord* temp = value_.vector_value_; value_.vector_value_ = nullptr; return temp; } else { return nullptr; } } -inline const ::milvus::grpc::VectorFieldValue& FieldValue::vector_value() const { +inline const ::milvus::grpc::VectorFieldRecord& 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_); + : *reinterpret_cast< ::milvus::grpc::VectorFieldRecord*>(&::milvus::grpc::_VectorFieldRecord_default_instance_); } -inline ::milvus::grpc::VectorFieldValue* FieldValue::mutable_vector_value() { +inline ::milvus::grpc::VectorFieldRecord* FieldValue::mutable_vector_value() { if (!has_vector_value()) { clear_value(); set_has_vector_value(); - value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldValue >( + value_.vector_value_ = CreateMaybeMessage< ::milvus::grpc::VectorFieldRecord >( GetArenaNoVirtual()); } // @@protoc_insertion_point(field_mutable:milvus.grpc.FieldValue.vector_value) @@ -11483,58 +11461,67 @@ inline void TermQuery::set_allocated_field_name(std::string* field_name) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.field_name) } -// bytes values = 2; -inline void TermQuery::clear_values() { - values_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// repeated int64 int_value = 2; +inline int TermQuery::int_value_size() const { + return int_value_.size(); } -inline const std::string& TermQuery::values() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.values) - return values_.GetNoArena(); +inline void TermQuery::clear_int_value() { + int_value_.Clear(); } -inline void TermQuery::set_values(const std::string& value) { - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.values) +inline ::PROTOBUF_NAMESPACE_ID::int64 TermQuery::int_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.int_value) + return int_value_.Get(index); } -inline void TermQuery::set_values(std::string&& value) { - - values_.SetNoArena( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TermQuery.values) +inline void TermQuery::set_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.int_value) } -inline void TermQuery::set_values(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TermQuery.values) +inline void TermQuery::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.int_value) } -inline void TermQuery::set_values(const void* value, size_t size) { - - values_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TermQuery.values) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +TermQuery::int_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.int_value) + return int_value_; } -inline std::string* TermQuery::mutable_values() { - - // @@protoc_insertion_point(field_mutable:milvus.grpc.TermQuery.values) - return values_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +TermQuery::mutable_int_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.int_value) + return &int_value_; } -inline std::string* TermQuery::release_values() { - // @@protoc_insertion_point(field_release:milvus.grpc.TermQuery.values) - - return values_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + +// repeated double double_value = 3; +inline int TermQuery::double_value_size() const { + return double_value_.size(); } -inline void TermQuery::set_allocated_values(std::string* values) { - if (values != nullptr) { - - } else { - - } - values_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), values); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TermQuery.values) +inline void TermQuery::clear_double_value() { + double_value_.Clear(); +} +inline double TermQuery::double_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.TermQuery.double_value) + return double_value_.Get(index); +} +inline void TermQuery::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.double_value) +} +inline void TermQuery::add_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.TermQuery.double_value) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >& +TermQuery::double_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.TermQuery.double_value) + return double_value_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +TermQuery::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TermQuery.double_value) + return &double_value_; } -// int64 value_num = 3; +// int64 value_num = 4; inline void TermQuery::clear_value_num() { value_num_ = PROTOBUF_LONGLONG(0); } @@ -11548,7 +11535,7 @@ inline void TermQuery::set_value_num(::PROTOBUF_NAMESPACE_ID::int64 value) { // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.value_num) } -// float boost = 4; +// float boost = 5; inline void TermQuery::clear_boost() { boost_ = 0; } @@ -11562,7 +11549,7 @@ inline void TermQuery::set_boost(float value) { // @@protoc_insertion_point(field_set:milvus.grpc.TermQuery.boost) } -// repeated .milvus.grpc.KeyValuePair extra_params = 5; +// repeated .milvus.grpc.KeyValuePair extra_params = 6; inline int TermQuery::extra_params_size() const { return extra_params_.size(); } @@ -12483,69 +12470,64 @@ inline void HSearchInSegmentsParam::set_allocated_search_param(::milvus::grpc::H // AttrRecord -// repeated string value = 1; -inline int AttrRecord::value_size() const { - return value_.size(); +// repeated int64 int_value = 1; +inline int AttrRecord::int_value_size() const { + return int_value_.size(); } -inline void AttrRecord::clear_value() { - value_.Clear(); +inline void AttrRecord::clear_int_value() { + int_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 ::PROTOBUF_NAMESPACE_ID::int64 AttrRecord::int_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.int_value) + return int_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_int_value(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.int_value) } -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::add_int_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + int_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.int_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 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +AttrRecord::int_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.int_value) + return int_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 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +AttrRecord::mutable_int_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.int_value) + return &int_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) + +// repeated double double_value = 2; +inline int AttrRecord::double_value_size() const { + return double_value_.size(); } -inline std::string* AttrRecord::add_value() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.AttrRecord.value) - return value_.Add(); +inline void AttrRecord::clear_double_value() { + double_value_.Clear(); } -inline void AttrRecord::add_value(const std::string& value) { - value_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.value) +inline double AttrRecord::double_value(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.AttrRecord.double_value) + return double_value_.Get(index); } -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::set_double_value(int index, double value) { + double_value_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.AttrRecord.double_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_double_value(double value) { + double_value_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.AttrRecord.double_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::RepeatedField< double >& +AttrRecord::double_value() const { + // @@protoc_insertion_point(field_list:milvus.grpc.AttrRecord.double_value) + return double_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_; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >* +AttrRecord::mutable_double_value() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.AttrRecord.double_value) + return &double_value_; } // ------------------------------------------------------------------- @@ -12597,19 +12579,35 @@ inline void HEntity::set_allocated_status(::milvus::grpc::Status* status) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntity.status) } -// int64 entity_id = 2; +// repeated int64 entity_id = 2; +inline int HEntity::entity_id_size() const { + return entity_id_.size(); +} inline void HEntity::clear_entity_id() { - entity_id_ = PROTOBUF_LONGLONG(0); + entity_id_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id() const { +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntity::entity_id(int index) const { // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.entity_id) - return entity_id_; + return entity_id_.Get(index); } -inline void HEntity::set_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { - - entity_id_ = value; +inline void HEntity::set_entity_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_.Set(index, value); // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.entity_id) } +inline void HEntity::add_entity_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + entity_id_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.entity_id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntity::entity_id() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.entity_id) + return entity_id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntity::mutable_entity_id() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.entity_id) + return &entity_id_; +} // repeated string field_names = 3; inline int HEntity::field_names_size() const { @@ -12676,55 +12674,34 @@ HEntity::mutable_field_names() { return &field_names_; } -// bytes attr_records = 4; -inline void HEntity::clear_attr_records() { - attr_records_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} -inline const std::string& HEntity::attr_records() const { - // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_records) - return attr_records_.GetNoArena(); +// repeated .milvus.grpc.DataType data_types = 4; +inline int HEntity::data_types_size() const { + return data_types_.size(); } -inline void HEntity::set_attr_records(const std::string& value) { - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.attr_records) -} -inline void HEntity::set_attr_records(std::string&& value) { - - attr_records_.SetNoArena( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.HEntity.attr_records) +inline void HEntity::clear_data_types() { + data_types_.Clear(); } -inline void HEntity::set_attr_records(const char* value) { - GOOGLE_DCHECK(value != nullptr); - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.HEntity.attr_records) +inline ::milvus::grpc::DataType HEntity::data_types(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.data_types) + return static_cast< ::milvus::grpc::DataType >(data_types_.Get(index)); } -inline void HEntity::set_attr_records(const void* value, size_t size) { - - attr_records_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.HEntity.attr_records) +inline void HEntity::set_data_types(int index, ::milvus::grpc::DataType value) { + data_types_.Set(index, value); + // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.data_types) } -inline std::string* HEntity::mutable_attr_records() { - - // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_records) - return attr_records_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void HEntity::add_data_types(::milvus::grpc::DataType value) { + data_types_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.data_types) } -inline std::string* HEntity::release_attr_records() { - // @@protoc_insertion_point(field_release:milvus.grpc.HEntity.attr_records) - - return attr_records_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +HEntity::data_types() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.data_types) + return data_types_; } -inline void HEntity::set_allocated_attr_records(std::string* attr_records) { - if (attr_records != nullptr) { - - } else { - - } - attr_records_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), attr_records); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntity.attr_records) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +HEntity::mutable_data_types() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.data_types) + return &data_types_; } // int64 row_num = 5; @@ -12741,34 +12718,64 @@ inline void HEntity::set_row_num(::PROTOBUF_NAMESPACE_ID::int64 value) { // @@protoc_insertion_point(field_set:milvus.grpc.HEntity.row_num) } -// repeated .milvus.grpc.FieldValue result_values = 6; -inline int HEntity::result_values_size() const { - return result_values_.size(); +// repeated .milvus.grpc.AttrRecord attr_data = 6; +inline int HEntity::attr_data_size() const { + return attr_data_.size(); } -inline void HEntity::clear_result_values() { - result_values_.Clear(); +inline void HEntity::clear_attr_data() { + attr_data_.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 ::milvus::grpc::AttrRecord* HEntity::mutable_attr_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.attr_data) + return attr_data_.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 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >* +HEntity::mutable_attr_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.attr_data) + return &attr_data_; } -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 const ::milvus::grpc::AttrRecord& HEntity::attr_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.attr_data) + return attr_data_.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 ::milvus::grpc::AttrRecord* HEntity::add_attr_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.attr_data) + return attr_data_.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_; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::AttrRecord >& +HEntity::attr_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.attr_data) + return attr_data_; +} + +// repeated .milvus.grpc.VectorFieldRecord vector_data = 7; +inline int HEntity::vector_data_size() const { + return vector_data_.size(); +} +inline void HEntity::clear_vector_data() { + vector_data_.Clear(); +} +inline ::milvus::grpc::VectorFieldRecord* HEntity::mutable_vector_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HEntity.vector_data) + return vector_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >* +HEntity::mutable_vector_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntity.vector_data) + return &vector_data_; +} +inline const ::milvus::grpc::VectorFieldRecord& HEntity::vector_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HEntity.vector_data) + return vector_data_.Get(index); +} +inline ::milvus::grpc::VectorFieldRecord* HEntity::add_vector_data() { + // @@protoc_insertion_point(field_add:milvus.grpc.HEntity.vector_data) + return vector_data_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::VectorFieldRecord >& +HEntity::vector_data() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntity.vector_data) + return vector_data_; } // ------------------------------------------------------------------- @@ -12820,34 +12827,55 @@ inline void HQueryResult::set_allocated_status(::milvus::grpc::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(); +// .milvus.grpc.HEntity entity = 2; +inline bool HQueryResult::has_entity() const { + return this != internal_default_instance() && entity_ != nullptr; } -inline ::milvus::grpc::HEntity* HQueryResult::mutable_entities(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entities) - return entities_.Mutable(index); +inline void HQueryResult::clear_entity() { + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; + } + entity_ = nullptr; } -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::entity() const { + const ::milvus::grpc::HEntity* p = entity_; + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.entity) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::grpc::_HEntity_default_instance_); } -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::release_entity() { + // @@protoc_insertion_point(field_release:milvus.grpc.HQueryResult.entity) + + ::milvus::grpc::HEntity* temp = entity_; + entity_ = nullptr; + return temp; } -inline ::milvus::grpc::HEntity* HQueryResult::add_entities() { - // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.entities) - return entities_.Add(); +inline ::milvus::grpc::HEntity* HQueryResult::mutable_entity() { + + if (entity_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); + entity_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.entity) + return entity_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::HEntity >& -HQueryResult::entities() const { - // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.entities) - return entities_; +inline void HQueryResult::set_allocated_entity(::milvus::grpc::HEntity* entity) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete entity_; + } + if (entity) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + entity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entity, submessage_arena); + } + + } else { + + } + entity_ = entity; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HQueryResult.entity) } // int64 row_num = 3; @@ -12924,6 +12952,36 @@ HQueryResult::mutable_distance() { return &distance_; } +// repeated .milvus.grpc.KeyValuePair extra_params = 6; +inline int HQueryResult::extra_params_size() const { + return extra_params_.size(); +} +inline void HQueryResult::clear_extra_params() { + extra_params_.Clear(); +} +inline ::milvus::grpc::KeyValuePair* HQueryResult::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* +HQueryResult::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HQueryResult.extra_params) + return &extra_params_; +} +inline const ::milvus::grpc::KeyValuePair& HQueryResult::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Get(index); +} +inline ::milvus::grpc::KeyValuePair* HQueryResult::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.HQueryResult.extra_params) + return extra_params_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& +HQueryResult::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HQueryResult.extra_params) + return extra_params_; +} + // ------------------------------------------------------------------- // HInsertParam @@ -13030,55 +13088,55 @@ inline void HInsertParam::set_allocated_partition_tag(std::string* 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; +// .milvus.grpc.HEntity entity = 3; +inline bool HInsertParam::has_entity() const { + return this != internal_default_instance() && entity_ != nullptr; } -inline void HInsertParam::clear_entities() { - if (GetArenaNoVirtual() == nullptr && entities_ != nullptr) { - delete entities_; +inline void HInsertParam::clear_entity() { + if (GetArenaNoVirtual() == nullptr && entity_ != nullptr) { + delete entity_; } - entities_ = nullptr; + entity_ = nullptr; } -inline const ::milvus::grpc::HEntity& HInsertParam::entities() const { - const ::milvus::grpc::HEntity* p = entities_; - // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entities) +inline const ::milvus::grpc::HEntity& HInsertParam::entity() const { + const ::milvus::grpc::HEntity* p = entity_; + // @@protoc_insertion_point(field_get:milvus.grpc.HInsertParam.entity) 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) +inline ::milvus::grpc::HEntity* HInsertParam::release_entity() { + // @@protoc_insertion_point(field_release:milvus.grpc.HInsertParam.entity) - ::milvus::grpc::HEntity* temp = entities_; - entities_ = nullptr; + ::milvus::grpc::HEntity* temp = entity_; + entity_ = nullptr; return temp; } -inline ::milvus::grpc::HEntity* HInsertParam::mutable_entities() { +inline ::milvus::grpc::HEntity* HInsertParam::mutable_entity() { - if (entities_ == nullptr) { + if (entity_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::HEntity>(GetArenaNoVirtual()); - entities_ = p; + entity_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entities) - return entities_; + // @@protoc_insertion_point(field_mutable:milvus.grpc.HInsertParam.entity) + return entity_; } -inline void HInsertParam::set_allocated_entities(::milvus::grpc::HEntity* entities) { +inline void HInsertParam::set_allocated_entity(::milvus::grpc::HEntity* entity) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { - delete entities_; + delete entity_; } - if (entities) { + if (entity) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; if (message_arena != submessage_arena) { - entities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, entities, submessage_arena); + entity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, entity, submessage_arena); } } else { } - entities_ = entities; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entities) + entity_ = entity; + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HInsertParam.entity) } // repeated int64 entity_id_array = 4; @@ -13196,19 +13254,35 @@ inline void HEntityIdentity::set_allocated_collection_name(std::string* collecti // @@protoc_insertion_point(field_set_allocated:milvus.grpc.HEntityIdentity.collection_name) } -// int64 id = 2; +// repeated int64 id = 2; +inline int HEntityIdentity::id_size() const { + return id_.size(); +} inline void HEntityIdentity::clear_id() { - id_ = PROTOBUF_LONGLONG(0); + id_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id() const { +inline ::PROTOBUF_NAMESPACE_ID::int64 HEntityIdentity::id(int index) const { // @@protoc_insertion_point(field_get:milvus.grpc.HEntityIdentity.id) - return id_; + return id_.Get(index); } -inline void HEntityIdentity::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) { - - id_ = value; +inline void HEntityIdentity::set_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) { + id_.Set(index, value); // @@protoc_insertion_point(field_set:milvus.grpc.HEntityIdentity.id) } +inline void HEntityIdentity::add_id(::PROTOBUF_NAMESPACE_ID::int64 value) { + id_.Add(value); + // @@protoc_insertion_point(field_add:milvus.grpc.HEntityIdentity.id) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >& +HEntityIdentity::id() const { + // @@protoc_insertion_point(field_list:milvus.grpc.HEntityIdentity.id) + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* +HEntityIdentity::mutable_id() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.HEntityIdentity.id) + return &id_; +} // ------------------------------------------------------------------- diff --git a/sdk/grpc/ClientProxy.cpp b/sdk/grpc/ClientProxy.cpp index f0fd444f..d96c2887 100644 --- a/sdk/grpc/ClientProxy.cpp +++ b/sdk/grpc/ClientProxy.cpp @@ -29,7 +29,7 @@ UriCheck(const std::string& uri) { return (index != std::string::npos); } -template +template void ConstructSearchParam(const std::string& collection_name, const std::vector& partition_tag_array, int64_t topk, const std::string& extra_params, T& search_param) { @@ -82,6 +82,59 @@ ConstructTopkResult(const ::milvus::grpc::TopKQueryResult& grpc_result, TopKQuer } } +void +ConstructTopkHybridResult(const ::milvus::grpc::HQueryResult& result, TopKHybridQueryResult& topk_query_result) { + int64_t nq = result.row_num(); + if (nq == 0) { + return; + } + topk_query_result.reserve(nq); + + auto grpc_entity = result.entity(); + int64_t topk = grpc_entity.entity_id().size() / nq; + for (int64_t i = 0; i < result.row_num(); i++) { + milvus::HybridQueryResult one_result; + one_result.ids.resize(topk); + one_result.distances.resize(topk); + memcpy(one_result.ids.data(), grpc_entity.entity_id().data() + topk * i, topk * sizeof(int64_t)); + memcpy(one_result.distances.data(), result.distance().data() + topk * i, topk * sizeof(float)); + int64_t j; + for (j = 0; j < grpc_entity.attr_data_size(); j++) { + AttrRecord attr_record; + if (grpc_entity.attr_data(j).int_value_size() > 0) { + attr_record.int_record.resize(topk); + memcpy(attr_record.int_record.data(), grpc_entity.attr_data(j).int_value().data() + topk * i, + topk * sizeof(int64_t)); + } else if (grpc_entity.attr_data(j).double_value_size() > 0) { + attr_record.double_record.resize(topk); + memcpy(attr_record.double_record.data(), grpc_entity.attr_data(j).double_value().data() + topk * i, + topk * sizeof(double)); + } + one_result.attr_records.emplace_back(std::make_pair(grpc_entity.field_names(j), attr_record)); + } + if (grpc_entity.vector_data_size() > 0) { + std::vector entities; + entities.resize(topk); + auto grpc_vector_data = grpc_entity.vector_data(0); + for (int64_t k = 0; k < topk; k++) { + auto grpc_float_size = grpc_vector_data.value(topk * i + k).float_data_size(); + auto grpc_binary_size = grpc_vector_data.value(topk * i + k).binary_data().size(); + if (grpc_float_size > 0) { + entities[k].float_data.resize(grpc_float_size); + memcpy(entities[k].float_data.data(), grpc_vector_data.value(topk * i + k).float_data().data(), + grpc_float_size * sizeof(float)); + } else if (grpc_binary_size > 0) { + entities[k].binary_data.resize(grpc_binary_size / 8); + memcpy(entities[k].binary_data.data(), grpc_vector_data.value(topk * i + k).binary_data().data(), + grpc_binary_size); + } + } + one_result.vector_records.emplace_back(std::make_pair(grpc_entity.field_names(j), entities)); + } + topk_query_result.emplace_back(one_result); + } +} + Status ClientProxy::Connect(const ConnectParam& param) { std::string uri = param.ip_address + ":" + param.port; @@ -611,19 +664,6 @@ ClientProxy::CreateHybridCollection(const HMapping& mapping) { } } -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) { @@ -634,35 +674,35 @@ ClientProxy::InsertEntity(const std::string& collection_name, const std::string& grpc_param.set_partition_tag(partition_tag); std::vector> numerica_data; - auto numerica_size = 0; - - auto numerica_it = entities.numerica_value.begin(); - auto grpc_entity = grpc_param.mutable_entities(); + auto numerica_int_it = entities.numerica_int_value.begin(); + auto grpc_entity = grpc_param.mutable_entity(); grpc_entity->set_row_num(entities.row_num); - for (; numerica_it != entities.numerica_value.end(); numerica_it++) { - auto name = grpc_entity->add_field_names(); - *name = numerica_it->first; - auto size = numerica_it->second.size(); - numerica_size += size; - numerica_data.emplace_back(numerica_it->second); + for (; numerica_int_it != entities.numerica_int_value.end(); numerica_int_it++) { + grpc_entity->add_field_names(numerica_int_it->first); + auto grpc_attr_data = grpc_entity->add_attr_data(); + auto size = numerica_int_it->second.size(); + auto mutable_int_value = grpc_attr_data->mutable_int_value(); + mutable_int_value->Resize(static_cast(size), 0l); + memcpy(mutable_int_value->mutable_data(), numerica_int_it->second.data(), size * sizeof(int64_t)); } - std::vector attr_data(numerica_size, 0); - size_t offset = 0; - for (auto data : numerica_data) { - memcpy(attr_data.data() + offset, data.data(), data.size()); - offset += data.size(); + auto numerica_double_it = entities.numerica_double_value.begin(); + for (; numerica_double_it != entities.numerica_double_value.end(); numerica_double_it++) { + grpc_entity->add_field_names(numerica_double_it->first); + auto grpc_attr_data = grpc_entity->add_attr_data(); + auto size = numerica_double_it->second.size(); + auto mutable_double_data = grpc_attr_data->mutable_double_value(); + mutable_double_data->Resize(static_cast(size), 0.0); + memcpy(mutable_double_data->mutable_data(), numerica_double_it->second.data(), size * sizeof(double)); } - grpc_entity->set_attr_records(attr_data.data(), numerica_size); - - 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); + + auto entity_it = entities.vector_value.begin(); + for (; entity_it != entities.vector_value.end(); entity_it++) { + grpc_entity->add_field_names(entity_it->first); + auto vector_field = grpc_entity->add_vector_data(); + for (auto& vector : entity_it->second) { + auto record = vector_field->add_value(); + CopyRowRecord(record, vector); } } @@ -696,8 +736,19 @@ WriteQueryToProto(::milvus::grpc::GeneralQuery* general_query, BooleanQueryPtr b 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); - term_query->set_values(leaf_query->term_query_ptr->field_value.data(), - leaf_query->term_query_ptr->field_value.size()); + if (leaf_query->term_query_ptr->int_value.size() > 0) { + auto mutable_int_value = term_query->mutable_int_value(); + auto size = leaf_query->term_query_ptr->int_value.size(); + mutable_int_value->Resize(size, 0); + memcpy(mutable_int_value->mutable_data(), leaf_query->term_query_ptr->int_value.data(), + size * sizeof(int64_t)); + } else if (leaf_query->term_query_ptr->double_value.size() > 0) { + auto mutable_double_value = term_query->mutable_double_value(); + auto size = leaf_query->term_query_ptr->double_value.size(); + mutable_double_value->Resize(size, 0); + memcpy(mutable_double_value->mutable_data(), leaf_query->term_query_ptr->double_value.data(), + size * sizeof(double)); + } } if (leaf_query->range_query_ptr != nullptr) { auto range_query = grpc_query->mutable_range_query(); @@ -735,7 +786,7 @@ WriteQueryToProto(::milvus::grpc::GeneralQuery* general_query, BooleanQueryPtr b 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) { + TopKHybridQueryResult& topk_query_result) { try { // convert boolean_query to proto ::milvus::grpc::HSearchParam search_param; @@ -744,34 +795,82 @@ ClientProxy::HybridSearch(const std::string& collection_name, const std::vector< 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); + if (extra_params.size() > 0) { + 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; + ::milvus::grpc::HQueryResult 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) { + ConstructTopkHybridResult(result, topk_query_result); + return status; + } catch (std::exception& ex) { + return Status(StatusCode::UnknownError, "Failed to search entities: " + std::string(ex.what())); + } +} + +Status +ClientProxy::GetHEntityByID(const std::string& collection_name, const std::vector& id_array, + milvus::HybridQueryResult& result) { + try { + ::milvus::grpc::VectorsIdentity vectors_identity; + vectors_identity.set_collection_name(collection_name); + for (auto id : id_array) { + vectors_identity.add_id_array(id); + } + + ::milvus::grpc::HEntity grpc_entity; + Status status = client_ptr_->GetHEntityByID(vectors_identity, grpc_entity); + if (!status.ok()) { 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); + + uint64_t row_num = grpc_entity.row_num(); + int i; + for (i = 0; i < grpc_entity.attr_data_size(); i++) { + AttrRecord attr_record; + auto grpc_int_size = grpc_entity.attr_data(i).int_value_size(); + auto grpc_double_size = grpc_entity.attr_data(i).double_value_size(); + if (grpc_int_size > 0) { + attr_record.int_record.resize(grpc_int_size); + memcpy(attr_record.int_record.data(), grpc_entity.attr_data(i).int_value().data(), + grpc_int_size * sizeof(int64_t)); + } else if (grpc_double_size > 0) { + attr_record.double_record.resize(grpc_double_size); + memcpy(attr_record.double_record.data(), grpc_entity.attr_data(i).double_value().data(), + grpc_double_size * sizeof(double)); + } + result.attr_records.emplace_back(std::make_pair(grpc_entity.field_names(i), attr_record)); } + auto grpc_vector_data = grpc_entity.vector_data(0); + std::vector entities; + for (int j = 0; j < grpc_vector_data.value_size(); j++) { + const ::milvus::grpc::RowRecord& record = grpc_vector_data.value(j); + Entity entity; + + int float_size = record.float_data_size(); + if (float_size > 0) { + entity.float_data.resize(float_size); + memcpy(entity.float_data.data(), record.float_data().data(), float_size * sizeof(float)); + } + + auto byte_size = record.binary_data().length(); + if (byte_size > 0) { + entity.binary_data.resize(byte_size); + memcpy(entity.binary_data.data(), record.binary_data().data(), byte_size); + } + entities.emplace_back(entity); + } + result.vector_records.emplace_back(std::make_pair(grpc_entity.field_names(i), entities)); return status; } catch (std::exception& ex) { - return Status(StatusCode::UnknownError, "Failed to search entities: " + std::string(ex.what())); + return Status(StatusCode::UnknownError, "Failed to get entity by id: " + std::string(ex.what())); } } diff --git a/sdk/grpc/ClientProxy.h b/sdk/grpc/ClientProxy.h index aec1749b..74af4515 100644 --- a/sdk/grpc/ClientProxy.h +++ b/sdk/grpc/ClientProxy.h @@ -63,10 +63,8 @@ class ClientProxy : public Connection { CreateIndex(const IndexParam& index_param) override; Status - Insert(const std::string& collection_name, - const std::string& partition_tag, - const std::vector& entity_array, - std::vector& id_array) override; + Insert(const std::string& collection_name, const std::string& partition_tag, + const std::vector& entity_array, std::vector& id_array) override; Status GetEntityByID(const std::string& collection_name, @@ -79,8 +77,8 @@ class ClientProxy : public Connection { Status Search(const std::string& collection_name, const std::vector& partition_tag_array, - const std::vector& entity_array, int64_t topk, - const std::string& extra_params, TopKQueryResult& topk_query_result) override; + const std::vector& entity_array, int64_t topk, const std::string& extra_params, + TopKQueryResult& topk_query_result) override; Status GetCollectionInfo(const std::string& collection_name, CollectionParam& collection_param) override; @@ -130,17 +128,17 @@ class ClientProxy : public Connection { CreateHybridCollection(const HMapping& mapping) override; Status - InsertEntity(const std::string& collection_name, - const std::string& partition_tag, - HEntity& entities, + 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; + HybridSearch(const std::string& collection_name, const std::vector& partition_list, + BooleanQueryPtr& boolean_query, const std::string& extra_params, + TopKHybridQueryResult& topk_query_result) override; + + Status + GetHEntityByID(const std::string& collection_name, const std::vector& id_array, + HybridQueryResult& result) override; private: std::shared_ptr<::grpc::Channel> channel_; diff --git a/sdk/grpc/GrpcClient.cpp b/sdk/grpc/GrpcClient.cpp index d1baf568..d2881ddf 100644 --- a/sdk/grpc/GrpcClient.cpp +++ b/sdk/grpc/GrpcClient.cpp @@ -509,7 +509,7 @@ GrpcClient::InsertEntities(milvus::grpc::HInsertParam& entities, milvus::grpc::H } Status -GrpcClient::HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::TopKQueryResult& result) { +GrpcClient::HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::HQueryResult& result) { ClientContext context; ::grpc::Status grpc_status = stub_->HybridSearch(&context, search_param, &result); @@ -525,4 +525,21 @@ GrpcClient::HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc: return Status::OK(); } +Status +GrpcClient::GetHEntityByID(milvus::grpc::VectorsIdentity& vectors_identity, milvus::grpc::HEntity& entity) { + ClientContext context; + ::grpc::Status grpc_status = stub_->GetEntityByID(&context, vectors_identity, &entity); + + if (!grpc_status.ok()) { + std::cerr << "HybridSearch gRPC failed!" << std::endl; + return Status(StatusCode::RPCFailed, grpc_status.error_message()); + } + + if (entity.status().error_code() != grpc::SUCCESS) { + std::cerr << entity.status().reason() << std::endl; + return Status(StatusCode::ServerFailed, entity.status().reason()); + } + return Status::OK(); +} + } // namespace milvus diff --git a/sdk/grpc/GrpcClient.h b/sdk/grpc/GrpcClient.h index 99333aa9..edb7bd38 100644 --- a/sdk/grpc/GrpcClient.h +++ b/sdk/grpc/GrpcClient.h @@ -115,7 +115,10 @@ class GrpcClient { InsertEntities(milvus::grpc::HInsertParam& entities, milvus::grpc::HEntityIDs& ids); Status - HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::TopKQueryResult& result); + HybridSearch(milvus::grpc::HSearchParam& search_param, milvus::grpc::HQueryResult& result); + + Status + GetHEntityByID(milvus::grpc::VectorsIdentity& vectors_identity, milvus::grpc::HEntity& entity); private: std::unique_ptr stub_; diff --git a/sdk/include/GeneralQuery.h b/sdk/include/GeneralQuery.h index 63e50f7a..d6a13494 100644 --- a/sdk/include/GeneralQuery.h +++ b/sdk/include/GeneralQuery.h @@ -13,8 +13,8 @@ #include #include -#include #include +#include namespace milvus { @@ -26,11 +26,10 @@ struct Entity { 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 + int64_t rules; // 0 is inc, 1 is dec }; struct Query { @@ -57,7 +56,8 @@ struct QueryColumn { }; struct TermQuery : Query { - std::vector field_value; + std::vector int_value; + std::vector double_value; }; using TermQueryPtr = std::shared_ptr; @@ -93,4 +93,4 @@ struct LeafQuery { }; using LeafQueryPtr = std::shared_ptr; -} // namespace milvus +} // namespace milvus diff --git a/sdk/include/MilvusApi.h b/sdk/include/MilvusApi.h index c07e4660..32aae361 100644 --- a/sdk/include/MilvusApi.h +++ b/sdk/include/MilvusApi.h @@ -13,8 +13,8 @@ #include #include -#include #include +#include #include "BooleanQuery.h" #include "Field.h" @@ -42,12 +42,12 @@ enum class IndexType { }; enum class MetricType { - L2 = 1, // Euclidean Distance - IP = 2, // Cosine Similarity - HAMMING = 3, // Hamming Distance - JACCARD = 4, // Jaccard Distance - TANIMOTO = 5, // Tanimoto Distance - SUBSTRUCTURE = 6, // Substructure Distance + L2 = 1, // Euclidean Distance + IP = 2, // Cosine Similarity + HAMMING = 3, // Hamming Distance + JACCARD = 4, // Jaccard Distance + TANIMOTO = 5, // Tanimoto Distance + SUBSTRUCTURE = 6, // Substructure Distance SUPERSTRUCTURE = 7, // Superstructure Distance }; @@ -78,6 +78,25 @@ struct QueryResult { }; using TopKQueryResult = std::vector; ///< Topk query result +/** + * @brief Attribute record + */ +struct AttrRecord { + std::vector int_record; + std::vector double_record; +}; + +/** + * @brief Hybrid query result + */ +struct HybridQueryResult { + std::vector ids; ///< Query entity ids result + std::vector distances; ///< Query distances result + std::vector> attr_records; ///< Query attributes result + std::vector>> vector_records; ///< Query vectors result +}; +using TopKHybridQueryResult = std::vector; ///< Topk hybrid query result + /** * @brief Index parameters * Note: extra_params is extra parameters list, it must be json format @@ -97,9 +116,9 @@ using TopKQueryResult = std::vector; ///< Topk query result * ///< efConstruction range:[100, 500] */ struct IndexParam { - std::string collection_name; ///< Collection name for create index - IndexType index_type; ///< Index type - std::string extra_params; ///< Extra parameters according to different index type, must be json format + std::string collection_name; ///< Collection name for create index + IndexType index_type; ///< Index type + std::string extra_params; ///< Extra parameters according to different index type, must be json format }; /** @@ -112,7 +131,6 @@ struct PartitionParam { using PartitionTagList = std::vector; - struct HMapping { std::string collection_name; std::vector numerica_fields; @@ -121,7 +139,8 @@ struct HMapping { struct HEntity { int64_t row_num; - std::unordered_map> numerica_value; + std::unordered_map> numerica_int_value; + std::unordered_map> numerica_double_value; std::unordered_map> vector_value; }; @@ -321,10 +340,8 @@ class Connection { * @return Indicate if entity array are inserted successfully */ virtual Status - Insert(const std::string& collection_name, - const std::string& partition_tag, - const std::vector& entity_array, - std::vector& id_array) = 0; + Insert(const std::string& collection_name, const std::string& partition_tag, + const std::vector& entity_array, std::vector& id_array) = 0; /** * @brief Get entity data by id @@ -384,8 +401,8 @@ class Connection { */ virtual Status Search(const std::string& collection_name, const PartitionTagList& partition_tag_array, - const std::vector& entity_array, int64_t topk, - const std::string& extra_params, TopKQueryResult& topk_query_result) = 0; + const std::vector& entity_array, int64_t topk, const std::string& extra_params, + TopKQueryResult& topk_query_result) = 0; /** * @brief Get collection information @@ -568,17 +585,17 @@ class Connection { CreateHybridCollection(const HMapping& mapping) = 0; virtual Status - InsertEntity(const std::string& collection_name, - const std::string& partition_tag, - HEntity& entities, + 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; + HybridSearch(const std::string& collection_name, const std::vector& partition_list, + BooleanQueryPtr& boolean_query, const std::string& extra_params, + TopKHybridQueryResult& query_result) = 0; + + virtual Status + GetHEntityByID(const std::string& collection_name, const std::vector& id_array, + HybridQueryResult& result) = 0; }; } // namespace milvus diff --git a/sdk/interface/ConnectionImpl.cpp b/sdk/interface/ConnectionImpl.cpp index c3f986d9..d5a69489 100644 --- a/sdk/interface/ConnectionImpl.cpp +++ b/sdk/interface/ConnectionImpl.cpp @@ -119,11 +119,7 @@ Status ConnectionImpl::Search(const std::string& collection_name, const PartitionTagList& partition_tag_array, const std::vector& entity_array, int64_t topk, const std::string& extra_params, TopKQueryResult& topk_query_result) { - return client_proxy_->Search(collection_name, - partition_tag_array, - entity_array, - topk, - extra_params, + return client_proxy_->Search(collection_name, partition_tag_array, entity_array, topk, extra_params, topk_query_result); } @@ -205,20 +201,22 @@ ConnectionImpl::CreateHybridCollection(const HMapping& mapping) { } Status -ConnectionImpl::InsertEntity(const std::string& collection_name, - const std::string& partition_tag, - HEntity& entities, +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) { +ConnectionImpl::HybridSearch(const std::string& collection_name, const std::vector& partition_list, + BooleanQueryPtr& boolean_query, const std::string& extra_params, + TopKHybridQueryResult& topk_query_result) { return client_proxy_->HybridSearch(collection_name, partition_list, boolean_query, extra_params, topk_query_result); } +Status +ConnectionImpl::GetHEntityByID(const std::string& collection_name, const std::vector& id_array, + milvus::HybridQueryResult& result) { + return client_proxy_->GetHEntityByID(collection_name, id_array, result); +} + } // namespace milvus diff --git a/sdk/interface/ConnectionImpl.h b/sdk/interface/ConnectionImpl.h index 3f003716..78ceaa56 100644 --- a/sdk/interface/ConnectionImpl.h +++ b/sdk/interface/ConnectionImpl.h @@ -65,10 +65,8 @@ class ConnectionImpl : public Connection { CreateIndex(const IndexParam& index_param) override; Status - Insert(const std::string& collection_name, - const std::string& partition_tag, - const std::vector& entity_array, - std::vector& id_array) override; + Insert(const std::string& collection_name, const std::string& partition_tag, + const std::vector& entity_array, std::vector& id_array) override; Status GetEntityByID(const std::string& collection_name, @@ -81,8 +79,8 @@ class ConnectionImpl : public Connection { Status Search(const std::string& collection_name, const PartitionTagList& partition_tag_array, - const std::vector& entity_array, int64_t topk, - const std::string& extra_params, TopKQueryResult& topk_query_result) override; + const std::vector& entity_array, int64_t topk, const std::string& extra_params, + TopKQueryResult& topk_query_result) override; Status GetCollectionInfo(const std::string& collection_name, CollectionParam& collection_param) override; @@ -132,17 +130,17 @@ class ConnectionImpl : public Connection { CreateHybridCollection(const HMapping& mapping) override; Status - InsertEntity(const std::string& collection_name, - const std::string& partition_tag, - HEntity& entities, + 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; + HybridSearch(const std::string& collection_name, const std::vector& partition_list, + BooleanQueryPtr& boolean_query, const std::string& extra_params, + TopKHybridQueryResult& topk_query_result) override; + + Status + GetHEntityByID(const std::string& collection_name, const std::vector& id_array, + HybridQueryResult& result) override; private: std::shared_ptr client_proxy_; -- GitLab