milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Support query by expression (#7386) 

Signed-off-by: fishpenguin <kun.yu@zilliz.com>
pull/7467/head
yukun 2021-09-03 17:12:55 +08:00 committed by GitHub
parent db8067d61c
commit 94272bba87
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
49 changed files with 953 additions and 1075 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
internal/core/src/common/Types.h
View File

@ -83,6 +83,17 @@ struct SearchResult {
using SearchResultPtr = std::shared_ptr<SearchResult>;
struct RetrieveResult {
RetrieveResult() = default;
public:
void* segment_;
std::vector<int64_t> result_offsets_;
std::vector<DataArray> field_data_;
};
using RetrieveResultPtr = std::shared_ptr<RetrieveResult>;
struct EntityResults {
// use protobuf results to simplify
};

119
internal/core/src/pb/plan.pb.cc
View File

@ -84,6 +84,7 @@ class PlanNodeDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PlanNode> _instance;
const ::milvus::proto::plan::VectorANNS* vector_anns_;
const ::milvus::proto::plan::Expr* predicates_;
} _PlanNode_default_instance_;
} // namespace plan
} // namespace proto
@ -188,9 +189,10 @@ static void InitDefaultsscc_info_PlanNode_plan_2eproto() {
::milvus::proto::plan::PlanNode::InitAsDefaultInstance();
}
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PlanNode_plan_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PlanNode_plan_2eproto}, {
&scc_info_VectorANNS_plan_2eproto.base,}};
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PlanNode_plan_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_PlanNode_plan_2eproto}, {
&scc_info_VectorANNS_plan_2eproto.base,
&scc_info_BinaryExpr_plan_2eproto.base,}};
static void InitDefaultsscc_info_QueryInfo_plan_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
@ -361,6 +363,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOB
PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, _oneof_case_[0]),
~0u, // no _weak_field_map_
offsetof(::milvus::proto::plan::PlanNodeDefaultTypeInternal, vector_anns_),
offsetof(::milvus::proto::plan::PlanNodeDefaultTypeInternal, predicates_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, output_field_ids_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::plan::PlanNode, node_),
};
@ -441,14 +444,15 @@ const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(pr
"y\030\001 \001(\010\022\020\n\010field_id\030\002 \001(\003\022+\n\npredicates\030"
"\003 \001(\0132\027.milvus.proto.plan.Expr\0220\n\nquery_"
"info\030\004 \001(\0132\034.milvus.proto.plan.QueryInfo"
"\022\027\n\017placeholder_tag\030\005 \001(\t\"b\n\010PlanNode\0224\n"
"\013vector_anns\030\001 \001(\0132\035.milvus.proto.plan.V"
"ectorANNSH\000\022\030\n\020output_field_ids\030\002 \003(\003B\006\n"
"\004node*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013GreaterT"
"han\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010LessThan\020\003\022\r\n"
"\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEqual\020\006B3Z"
"1github.com/milvus-io/milvus/internal/pr"
"oto/planpbb\006proto3"
"\022\027\n\017placeholder_tag\030\005 \001(\t\"\221\001\n\010PlanNode\0224"
"\n\013vector_anns\030\001 \001(\0132\035.milvus.proto.plan."
"VectorANNSH\000\022-\n\npredicates\030\002 \001(\0132\027.milvu"
"s.proto.plan.ExprH\000\022\030\n\020output_field_ids\030"
"\003 \003(\003B\006\n\004node*n\n\006OpType\022\013\n\007Invalid\020\000\022\017\n\013"
"GreaterThan\020\001\022\020\n\014GreaterEqual\020\002\022\014\n\010LessT"
"han\020\003\022\r\n\tLessEqual\020\004\022\t\n\005Equal\020\005\022\014\n\010NotEq"
"ual\020\006B3Z1github.com/milvus-io/milvus/int"
"ernal/proto/planpbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[1] = {
&::descriptor_table_schema_2eproto,
@ -468,7 +472,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_pla
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once;
static bool descriptor_table_plan_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = {
&descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2138,
&descriptor_table_plan_2eproto_initialized, descriptor_table_protodef_plan_2eproto, "plan.proto", 2186,
&descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_sccs, descriptor_table_plan_2eproto_deps, 10, 1,
schemas, file_default_instances, TableStruct_plan_2eproto::offsets,
file_level_metadata_plan_2eproto, 12, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto,
@ -5055,16 +5059,23 @@ void VectorANNS::InternalSwap(VectorANNS* other) {
void PlanNode::InitAsDefaultInstance() {
::milvus::proto::plan::_PlanNode_default_instance_.vector_anns_ = const_cast< ::milvus::proto::plan::VectorANNS*>(
::milvus::proto::plan::VectorANNS::internal_default_instance());
::milvus::proto::plan::_PlanNode_default_instance_.predicates_ = const_cast< ::milvus::proto::plan::Expr*>(
::milvus::proto::plan::Expr::internal_default_instance());
}
class PlanNode::_Internal {
public:
static const ::milvus::proto::plan::VectorANNS& vector_anns(const PlanNode* msg);
static const ::milvus::proto::plan::Expr& predicates(const PlanNode* msg);
};
const ::milvus::proto::plan::VectorANNS&
PlanNode::_Internal::vector_anns(const PlanNode* msg) {
return *msg->node_.vector_anns_;
}
const ::milvus::proto::plan::Expr&
PlanNode::_Internal::predicates(const PlanNode* msg) {
return *msg->node_.predicates_;
}
void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
clear_node();
@ -5079,6 +5090,20 @@ void PlanNode::set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vect
}
// @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.vector_anns)
}
void PlanNode::set_allocated_predicates(::milvus::proto::plan::Expr* predicates) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
clear_node();
if (predicates) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
predicates = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, predicates, submessage_arena);
}
set_has_predicates();
node_.predicates_ = predicates;
}
// @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.PlanNode.predicates)
}
PlanNode::PlanNode()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
@ -5095,6 +5120,10 @@ PlanNode::PlanNode(const PlanNode& from)
mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
break;
}
case kPredicates: {
mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(from.predicates());
break;
}
case NODE_NOT_SET: {
break;
}
@ -5134,6 +5163,10 @@ void PlanNode::clear_node() {
delete node_.vector_anns_;
break;
}
case kPredicates: {
delete node_.predicates_;
break;
}
case NODE_NOT_SET: {
break;
}
@ -5168,12 +5201,19 @@ const char* PlanNode::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i
CHK_(ptr);
} else goto handle_unusual;
continue;
// repeated int64 output_field_ids = 2;
// .milvus.proto.plan.Expr predicates = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
ptr = ctx->ParseMessage(mutable_predicates(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// repeated int64 output_field_ids = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_output_field_ids(), ptr, ctx);
CHK_(ptr);
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
add_output_field_ids(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
CHK_(ptr);
} else goto handle_unusual;
@ -5219,16 +5259,27 @@ bool PlanNode::MergePartialFromCodedStream(
break;
}
// repeated int64 output_field_ids = 2;
// .milvus.proto.plan.Expr predicates = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_predicates()));
} else {
goto handle_unusual;
}
break;
}
// repeated int64 output_field_ids = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, this->mutable_output_field_ids())));
} else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
} else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
1, 18u, input, this->mutable_output_field_ids())));
1, 26u, input, this->mutable_output_field_ids())));
} else {
goto handle_unusual;
}
@ -5268,9 +5319,15 @@ void PlanNode::SerializeWithCachedSizes(
1, _Internal::vector_anns(this), output);
}
// repeated int64 output_field_ids = 2;
// .milvus.proto.plan.Expr predicates = 2;
if (has_predicates()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
2, _Internal::predicates(this), output);
}
// repeated int64 output_field_ids = 3;
if (this->output_field_ids_size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
output->WriteVarint32(_output_field_ids_cached_byte_size_.load(
std::memory_order_relaxed));
}
@ -5299,10 +5356,17 @@ void PlanNode::SerializeWithCachedSizes(
1, _Internal::vector_anns(this), target);
}
// repeated int64 output_field_ids = 2;
// .milvus.proto.plan.Expr predicates = 2;
if (has_predicates()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(
2, _Internal::predicates(this), target);
}
// repeated int64 output_field_ids = 3;
if (this->output_field_ids_size() > 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
2,
3,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
target);
target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
@ -5333,7 +5397,7 @@ size_t PlanNode::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated int64 output_field_ids = 2;
// repeated int64 output_field_ids = 3;
{
size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
Int64Size(this->output_field_ids_);
@ -5356,6 +5420,13 @@ size_t PlanNode::ByteSizeLong() const {
*node_.vector_anns_);
break;
}
// .milvus.proto.plan.Expr predicates = 2;
case kPredicates: {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*node_.predicates_);
break;
}
case NODE_NOT_SET: {
break;
}
@ -5393,6 +5464,10 @@ void PlanNode::MergeFrom(const PlanNode& from) {
mutable_vector_anns()->::milvus::proto::plan::VectorANNS::MergeFrom(from.vector_anns());
break;
}
case kPredicates: {
mutable_predicates()->::milvus::proto::plan::Expr::MergeFrom(from.predicates());
break;
}
case NODE_NOT_SET: {
break;
}

59
internal/core/src/pb/plan.pb.h
View File

@ -2072,6 +2072,7 @@ class PlanNode :
enum NodeCase {
kVectorAnns = 1,
kPredicates = 2,
NODE_NOT_SET = 0,
};
@ -2152,10 +2153,11 @@ class PlanNode :
// accessors -------------------------------------------------------
enum : int {
kOutputFieldIdsFieldNumber = 2,
kOutputFieldIdsFieldNumber = 3,
kVectorAnnsFieldNumber = 1,
kPredicatesFieldNumber = 2,
};
// repeated int64 output_field_ids = 2;
// repeated int64 output_field_ids = 3;
int output_field_ids_size() const;
void clear_output_field_ids();
::PROTOBUF_NAMESPACE_ID::int64 output_field_ids(int index) const;
@ -2174,12 +2176,21 @@ class PlanNode :
::milvus::proto::plan::VectorANNS* mutable_vector_anns();
void set_allocated_vector_anns(::milvus::proto::plan::VectorANNS* vector_anns);
// .milvus.proto.plan.Expr predicates = 2;
bool has_predicates() const;
void clear_predicates();
const ::milvus::proto::plan::Expr& predicates() const;
::milvus::proto::plan::Expr* release_predicates();
::milvus::proto::plan::Expr* mutable_predicates();
void set_allocated_predicates(::milvus::proto::plan::Expr* predicates);
void clear_node();
NodeCase node_case() const;
// @@protoc_insertion_point(class_scope:milvus.proto.plan.PlanNode)
private:
class _Internal;
void set_has_vector_anns();
void set_has_predicates();
inline bool has_node() const;
inline void clear_has_node();
@ -2190,6 +2201,7 @@ class PlanNode :
union NodeUnion {
NodeUnion() {}
::milvus::proto::plan::VectorANNS* vector_anns_;
::milvus::proto::plan::Expr* predicates_;
} node_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
@ -3671,7 +3683,48 @@ inline ::milvus::proto::plan::VectorANNS* PlanNode::mutable_vector_anns() {
return node_.vector_anns_;
}
// repeated int64 output_field_ids = 2;
// .milvus.proto.plan.Expr predicates = 2;
inline bool PlanNode::has_predicates() const {
return node_case() == kPredicates;
}
inline void PlanNode::set_has_predicates() {
_oneof_case_[0] = kPredicates;
}
inline void PlanNode::clear_predicates() {
if (has_predicates()) {
delete node_.predicates_;
clear_has_node();
}
}
inline ::milvus::proto::plan::Expr* PlanNode::release_predicates() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.PlanNode.predicates)
if (has_predicates()) {
clear_has_node();
::milvus::proto::plan::Expr* temp = node_.predicates_;
node_.predicates_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::milvus::proto::plan::Expr& PlanNode::predicates() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.PlanNode.predicates)
return has_predicates()
? *node_.predicates_
: *reinterpret_cast< ::milvus::proto::plan::Expr*>(&::milvus::proto::plan::_Expr_default_instance_);
}
inline ::milvus::proto::plan::Expr* PlanNode::mutable_predicates() {
if (!has_predicates()) {
clear_node();
set_has_predicates();
node_.predicates_ = CreateMaybeMessage< ::milvus::proto::plan::Expr >(
GetArenaNoVirtual());
}
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.PlanNode.predicates)
return node_.predicates_;
}
// repeated int64 output_field_ids = 3;
inline int PlanNode::output_field_ids_size() const {
return output_field_ids_.size();
}

411
internal/core/src/pb/segcore.pb.cc
View File

@ -21,10 +21,6 @@ extern PROTOBUF_INTERNAL_EXPORT_segcore_2eproto ::PROTOBUF_NAMESPACE_ID::interna
namespace milvus {
namespace proto {
namespace segcore {
class RetrieveRequestDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RetrieveRequest> _instance;
} _RetrieveRequest_default_instance_;
class RetrieveResultsDefaultTypeInternal {
public:
::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RetrieveResults> _instance;
@ -69,21 +65,6 @@ static void InitDefaultsscc_info_LoadSegmentMeta_segcore_2eproto() {
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_LoadSegmentMeta_segcore_2eproto}, {
&scc_info_LoadFieldMeta_segcore_2eproto.base,}};
static void InitDefaultsscc_info_RetrieveRequest_segcore_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
{
void* ptr = &::milvus::proto::segcore::_RetrieveRequest_default_instance_;
new (ptr) ::milvus::proto::segcore::RetrieveRequest();
::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
}
::milvus::proto::segcore::RetrieveRequest::InitAsDefaultInstance();
}
::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_RetrieveRequest_segcore_2eproto =
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_RetrieveRequest_segcore_2eproto}, {
&scc_info_IDs_schema_2eproto.base,}};
static void InitDefaultsscc_info_RetrieveResults_segcore_2eproto() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
@ -100,18 +81,11 @@ static void InitDefaultsscc_info_RetrieveResults_segcore_2eproto() {
&scc_info_IDs_schema_2eproto.base,
&scc_info_FieldData_schema_2eproto.base,}};
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_segcore_2eproto[4];
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_segcore_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_segcore_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_segcore_2eproto = nullptr;
const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_segcore_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, ids_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveRequest, output_fields_id_),
~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::RetrieveResults, _internal_metadata_),
~0u, // no _extensions_
@ -137,14 +111,12 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_segcore_2eproto::offsets[] PRO
PROTOBUF_FIELD_OFFSET(::milvus::proto::segcore::LoadSegmentMeta, total_size_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
{ 0, -1, sizeof(::milvus::proto::segcore::RetrieveRequest)},
{ 7, -1, sizeof(::milvus::proto::segcore::RetrieveResults)},
{ 15, -1, sizeof(::milvus::proto::segcore::LoadFieldMeta)},
{ 23, -1, sizeof(::milvus::proto::segcore::LoadSegmentMeta)},
{ 0, -1, sizeof(::milvus::proto::segcore::RetrieveResults)},
{ 8, -1, sizeof(::milvus::proto::segcore::LoadFieldMeta)},
{ 16, -1, sizeof(::milvus::proto::segcore::LoadSegmentMeta)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_RetrieveRequest_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_RetrieveResults_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_LoadFieldMeta_default_instance_),
reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::proto::segcore::_LoadSegmentMeta_default_instance_),
@ -152,35 +124,32 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] =
const char descriptor_table_protodef_segcore_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
"\n\rsegcore.proto\022\024milvus.proto.segcore\032\014s"
"chema.proto\"R\n\017RetrieveRequest\022%\n\003ids\030\001 "
"\001(\0132\030.milvus.proto.schema.IDs\022\030\n\020output_"
"fields_id\030\002 \003(\003\"}\n\017RetrieveResults\022%\n\003id"
"s\030\001 \001(\0132\030.milvus.proto.schema.IDs\022\016\n\006off"
"set\030\002 \003(\003\0223\n\013fields_data\030\003 \003(\0132\036.milvus."
"proto.schema.FieldData\"P\n\rLoadFieldMeta\022"
"\025\n\rmin_timestamp\030\001 \001(\003\022\025\n\rmax_timestamp\030"
"\002 \001(\003\022\021\n\trow_count\030\003 \001(\003\"Y\n\017LoadSegmentM"
"eta\0222\n\005metas\030\001 \003(\0132#.milvus.proto.segcor"
"e.LoadFieldMeta\022\022\n\ntotal_size\030\002 \001(\003B6Z4g"
"ithub.com/milvus-io/milvus/internal/prot"
"o/segcorepbb\006proto3"
"chema.proto\"}\n\017RetrieveResults\022%\n\003ids\030\001 "
"\001(\0132\030.milvus.proto.schema.IDs\022\016\n\006offset\030"
"\002 \003(\003\0223\n\013fields_data\030\003 \003(\0132\036.milvus.prot"
"o.schema.FieldData\"P\n\rLoadFieldMeta\022\025\n\rm"
"in_timestamp\030\001 \001(\003\022\025\n\rmax_timestamp\030\002 \001("
"\003\022\021\n\trow_count\030\003 \001(\003\"Y\n\017LoadSegmentMeta\022"
"2\n\005metas\030\001 \003(\0132#.milvus.proto.segcore.Lo"
"adFieldMeta\022\022\n\ntotal_size\030\002 \001(\003B6Z4githu"
"b.com/milvus-io/milvus/internal/proto/se"
"gcorepbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_segcore_2eproto_deps[1] = {
&::descriptor_table_schema_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_segcore_2eproto_sccs[4] = {
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_segcore_2eproto_sccs[3] = {
&scc_info_LoadFieldMeta_segcore_2eproto.base,
&scc_info_LoadSegmentMeta_segcore_2eproto.base,
&scc_info_RetrieveRequest_segcore_2eproto.base,
&scc_info_RetrieveResults_segcore_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_segcore_2eproto_once;
static bool descriptor_table_segcore_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_segcore_2eproto = {
&descriptor_table_segcore_2eproto_initialized, descriptor_table_protodef_segcore_2eproto, "segcore.proto", 499,
&descriptor_table_segcore_2eproto_once, descriptor_table_segcore_2eproto_sccs, descriptor_table_segcore_2eproto_deps, 4, 1,
&descriptor_table_segcore_2eproto_initialized, descriptor_table_protodef_segcore_2eproto, "segcore.proto", 415,
&descriptor_table_segcore_2eproto_once, descriptor_table_segcore_2eproto_sccs, descriptor_table_segcore_2eproto_deps, 3, 1,
schemas, file_default_instances, TableStruct_segcore_2eproto::offsets,
file_level_metadata_segcore_2eproto, 4, file_level_enum_descriptors_segcore_2eproto, file_level_service_descriptors_segcore_2eproto,
file_level_metadata_segcore_2eproto, 3, file_level_enum_descriptors_segcore_2eproto, file_level_service_descriptors_segcore_2eproto,
};
// Force running AddDescriptors() at dynamic initialization time.
@ -189,347 +158,6 @@ namespace milvus {
namespace proto {
namespace segcore {
// ===================================================================
void RetrieveRequest::InitAsDefaultInstance() {
::milvus::proto::segcore::_RetrieveRequest_default_instance_._instance.get_mutable()->ids_ = const_cast< ::milvus::proto::schema::IDs*>(
::milvus::proto::schema::IDs::internal_default_instance());
}
class RetrieveRequest::_Internal {
public:
static const ::milvus::proto::schema::IDs& ids(const RetrieveRequest* msg);
};
const ::milvus::proto::schema::IDs&
RetrieveRequest::_Internal::ids(const RetrieveRequest* msg) {
return *msg->ids_;
}
void RetrieveRequest::clear_ids() {
if (GetArenaNoVirtual() == nullptr && ids_ != nullptr) {
delete ids_;
}
ids_ = nullptr;
}
RetrieveRequest::RetrieveRequest()
: ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
SharedCtor();
// @@protoc_insertion_point(constructor:milvus.proto.segcore.RetrieveRequest)
}
RetrieveRequest::RetrieveRequest(const RetrieveRequest& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr),
output_fields_id_(from.output_fields_id_) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
if (from.has_ids()) {
ids_ = new ::milvus::proto::schema::IDs(*from.ids_);
} else {
ids_ = nullptr;
}
// @@protoc_insertion_point(copy_constructor:milvus.proto.segcore.RetrieveRequest)
}
void RetrieveRequest::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_RetrieveRequest_segcore_2eproto.base);
ids_ = nullptr;
}
RetrieveRequest::~RetrieveRequest() {
// @@protoc_insertion_point(destructor:milvus.proto.segcore.RetrieveRequest)
SharedDtor();
}
void RetrieveRequest::SharedDtor() {
if (this != internal_default_instance()) delete ids_;
}
void RetrieveRequest::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
const RetrieveRequest& RetrieveRequest::default_instance() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RetrieveRequest_segcore_2eproto.base);
return *internal_default_instance();
}
void RetrieveRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:milvus.proto.segcore.RetrieveRequest)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
output_fields_id_.Clear();
if (GetArenaNoVirtual() == nullptr && ids_ != nullptr) {
delete ids_;
}
ids_ = nullptr;
_internal_metadata_.Clear();
}
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* RetrieveRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
while (!ctx->Done(&ptr)) {
::PROTOBUF_NAMESPACE_ID::uint32 tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
CHK_(ptr);
switch (tag >> 3) {
// .milvus.proto.schema.IDs ids = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
ptr = ctx->ParseMessage(mutable_ids(), ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// repeated int64 output_fields_id = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_output_fields_id(), ptr, ctx);
CHK_(ptr);
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
add_output_fields_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
CHK_(ptr);
} else goto handle_unusual;
continue;
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
ctx->SetLastTag(tag);
goto success;
}
ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
CHK_(ptr != nullptr);
continue;
}
} // switch
} // while
success:
return ptr;
failure:
ptr = nullptr;
goto success;
#undef CHK_
}
#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool RetrieveRequest::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.proto.segcore.RetrieveRequest)
for (;;) {
::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// .milvus.proto.schema.IDs ids = 1;
case 1: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
input, mutable_ids()));
} else {
goto handle_unusual;
}
break;
}
// repeated int64 output_fields_id = 2;
case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, this->mutable_output_fields_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_output_fields_id())));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:milvus.proto.segcore.RetrieveRequest)
return true;
failure:
// @@protoc_insertion_point(parse_failure:milvus.proto.segcore.RetrieveRequest)
return false;
#undef DO_
}
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void RetrieveRequest::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:milvus.proto.segcore.RetrieveRequest)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.proto.schema.IDs ids = 1;
if (this->has_ids()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
1, _Internal::ids(this), output);
}
// repeated int64 output_fields_id = 2;
if (this->output_fields_id_size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
output->WriteVarint32(_output_fields_id_cached_byte_size_.load(
std::memory_order_relaxed));
}
for (int i = 0, n = this->output_fields_id_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag(
this->output_fields_id(i), output);
}
if (_internal_metadata_.have_unknown_fields()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
_internal_metadata_.unknown_fields(), output);
}
// @@protoc_insertion_point(serialize_end:milvus.proto.segcore.RetrieveRequest)
}
::PROTOBUF_NAMESPACE_ID::uint8* RetrieveRequest::InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const {
// @@protoc_insertion_point(serialize_to_array_start:milvus.proto.segcore.RetrieveRequest)
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// .milvus.proto.schema.IDs ids = 1;
if (this->has_ids()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessageToArray(
1, _Internal::ids(this), target);
}
// repeated int64 output_fields_id = 2;
if (this->output_fields_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(
_output_fields_id_cached_byte_size_.load(std::memory_order_relaxed),
target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
WriteInt64NoTagToArray(this->output_fields_id_, target);
}
if (_internal_metadata_.have_unknown_fields()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields(), target);
}
// @@protoc_insertion_point(serialize_to_array_end:milvus.proto.segcore.RetrieveRequest)
return target;
}
size_t RetrieveRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:milvus.proto.segcore.RetrieveRequest)
size_t total_size = 0;
if (_internal_metadata_.have_unknown_fields()) {
total_size +=
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
_internal_metadata_.unknown_fields());
}
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated int64 output_fields_id = 2;
{
size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
Int64Size(this->output_fields_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);
_output_fields_id_cached_byte_size_.store(cached_size,
std::memory_order_relaxed);
total_size += data_size;
}
// .milvus.proto.schema.IDs ids = 1;
if (this->has_ids()) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*ids_);
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void RetrieveRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.segcore.RetrieveRequest)
GOOGLE_DCHECK_NE(&from, this);
const RetrieveRequest* source =
::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RetrieveRequest>(
&from);
if (source == nullptr) {
// @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.segcore.RetrieveRequest)
::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
} else {
// @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.segcore.RetrieveRequest)
MergeFrom(*source);
}
}
void RetrieveRequest::MergeFrom(const RetrieveRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.segcore.RetrieveRequest)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
output_fields_id_.MergeFrom(from.output_fields_id_);
if (from.has_ids()) {
mutable_ids()->::milvus::proto::schema::IDs::MergeFrom(from.ids());
}
}
void RetrieveRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.segcore.RetrieveRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
void RetrieveRequest::CopyFrom(const RetrieveRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.segcore.RetrieveRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool RetrieveRequest::IsInitialized() const {
return true;
}
void RetrieveRequest::InternalSwap(RetrieveRequest* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
output_fields_id_.InternalSwap(&other->output_fields_id_);
swap(ids_, other->ids_);
}
::PROTOBUF_NAMESPACE_ID::Metadata RetrieveRequest::GetMetadata() const {
return GetMetadataStatic();
}
// ===================================================================
void RetrieveResults::InitAsDefaultInstance() {
@ -1576,9 +1204,6 @@ void LoadSegmentMeta::InternalSwap(LoadSegmentMeta* other) {
} // namespace proto
} // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::milvus::proto::segcore::RetrieveRequest* Arena::CreateMaybeMessage< ::milvus::proto::segcore::RetrieveRequest >(Arena* arena) {
return Arena::CreateInternal< ::milvus::proto::segcore::RetrieveRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::milvus::proto::segcore::RetrieveResults* Arena::CreateMaybeMessage< ::milvus::proto::segcore::RetrieveResults >(Arena* arena) {
return Arena::CreateInternal< ::milvus::proto::segcore::RetrieveResults >(arena);
}

241
internal/core/src/pb/segcore.pb.h
View File

@ -48,7 +48,7 @@ struct TableStruct_segcore_2eproto {
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@ -64,9 +64,6 @@ extern LoadFieldMetaDefaultTypeInternal _LoadFieldMeta_default_instance_;
class LoadSegmentMeta;
class LoadSegmentMetaDefaultTypeInternal;
extern LoadSegmentMetaDefaultTypeInternal _LoadSegmentMeta_default_instance_;
class RetrieveRequest;
class RetrieveRequestDefaultTypeInternal;
extern RetrieveRequestDefaultTypeInternal _RetrieveRequest_default_instance_;
class RetrieveResults;
class RetrieveResultsDefaultTypeInternal;
extern RetrieveResultsDefaultTypeInternal _RetrieveResults_default_instance_;
@ -76,7 +73,6 @@ extern RetrieveResultsDefaultTypeInternal _RetrieveResults_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::proto::segcore::LoadFieldMeta* Arena::CreateMaybeMessage<::milvus::proto::segcore::LoadFieldMeta>(Arena*);
template<> ::milvus::proto::segcore::LoadSegmentMeta* Arena::CreateMaybeMessage<::milvus::proto::segcore::LoadSegmentMeta>(Arena*);
template<> ::milvus::proto::segcore::RetrieveRequest* Arena::CreateMaybeMessage<::milvus::proto::segcore::RetrieveRequest>(Arena*);
template<> ::milvus::proto::segcore::RetrieveResults* Arena::CreateMaybeMessage<::milvus::proto::segcore::RetrieveResults>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
@ -85,154 +81,6 @@ namespace segcore {
// ===================================================================
class RetrieveRequest :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.segcore.RetrieveRequest) */ {
public:
RetrieveRequest();
virtual ~RetrieveRequest();
RetrieveRequest(const RetrieveRequest& from);
RetrieveRequest(RetrieveRequest&& from) noexcept
: RetrieveRequest() {
*this = ::std::move(from);
}
inline RetrieveRequest& operator=(const RetrieveRequest& from) {
CopyFrom(from);
return *this;
}
inline RetrieveRequest& operator=(RetrieveRequest&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const RetrieveRequest& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const RetrieveRequest* internal_default_instance() {
return reinterpret_cast<const RetrieveRequest*>(
&_RetrieveRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(RetrieveRequest& a, RetrieveRequest& b) {
a.Swap(&b);
}
inline void Swap(RetrieveRequest* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline RetrieveRequest* New() const final {
return CreateMaybeMessage<RetrieveRequest>(nullptr);
}
RetrieveRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<RetrieveRequest>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const RetrieveRequest& from);
void MergeFrom(const RetrieveRequest& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(RetrieveRequest* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.segcore.RetrieveRequest";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_segcore_2eproto);
return ::descriptor_table_segcore_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kOutputFieldsIdFieldNumber = 2,
kIdsFieldNumber = 1,
};
// repeated int64 output_fields_id = 2;
int output_fields_id_size() const;
void clear_output_fields_id();
::PROTOBUF_NAMESPACE_ID::int64 output_fields_id(int index) const;
void set_output_fields_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
void add_output_fields_id(::PROTOBUF_NAMESPACE_ID::int64 value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
output_fields_id() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
mutable_output_fields_id();
// .milvus.proto.schema.IDs ids = 1;
bool has_ids() const;
void clear_ids();
const ::milvus::proto::schema::IDs& ids() const;
::milvus::proto::schema::IDs* release_ids();
::milvus::proto::schema::IDs* mutable_ids();
void set_allocated_ids(::milvus::proto::schema::IDs* ids);
// @@protoc_insertion_point(class_scope:milvus.proto.segcore.RetrieveRequest)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > output_fields_id_;
mutable std::atomic<int> _output_fields_id_cached_byte_size_;
::milvus::proto::schema::IDs* ids_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_segcore_2eproto;
};
// -------------------------------------------------------------------
class RetrieveResults :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.segcore.RetrieveResults) */ {
public:
@ -275,7 +123,7 @@ class RetrieveResults :
&_RetrieveResults_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
0;
friend void swap(RetrieveResults& a, RetrieveResults& b) {
a.Swap(&b);
@ -436,7 +284,7 @@ class LoadFieldMeta :
&_LoadFieldMeta_default_instance_);
}
static constexpr int kIndexInFileMessages =
2;
1;
friend void swap(LoadFieldMeta& a, LoadFieldMeta& b) {
a.Swap(&b);
@ -581,7 +429,7 @@ class LoadSegmentMeta :
&_LoadSegmentMeta_default_instance_);
}
static constexpr int kIndexInFileMessages =
3;
2;
friend void swap(LoadSegmentMeta& a, LoadSegmentMeta& b) {
a.Swap(&b);
@ -690,85 +538,6 @@ class LoadSegmentMeta :
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// RetrieveRequest
// .milvus.proto.schema.IDs ids = 1;
inline bool RetrieveRequest::has_ids() const {
return this != internal_default_instance() && ids_ != nullptr;
}
inline const ::milvus::proto::schema::IDs& RetrieveRequest::ids() const {
const ::milvus::proto::schema::IDs* p = ids_;
// @@protoc_insertion_point(field_get:milvus.proto.segcore.RetrieveRequest.ids)
return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::schema::IDs*>(
&::milvus::proto::schema::_IDs_default_instance_);
}
inline ::milvus::proto::schema::IDs* RetrieveRequest::release_ids() {
// @@protoc_insertion_point(field_release:milvus.proto.segcore.RetrieveRequest.ids)
::milvus::proto::schema::IDs* temp = ids_;
ids_ = nullptr;
return temp;
}
inline ::milvus::proto::schema::IDs* RetrieveRequest::mutable_ids() {
if (ids_ == nullptr) {
auto* p = CreateMaybeMessage<::milvus::proto::schema::IDs>(GetArenaNoVirtual());
ids_ = p;
}
// @@protoc_insertion_point(field_mutable:milvus.proto.segcore.RetrieveRequest.ids)
return ids_;
}
inline void RetrieveRequest::set_allocated_ids(::milvus::proto::schema::IDs* ids) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
if (message_arena == nullptr) {
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(ids_);
}
if (ids) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
if (message_arena != submessage_arena) {
ids = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, ids, submessage_arena);
}
} else {
}
ids_ = ids;
// @@protoc_insertion_point(field_set_allocated:milvus.proto.segcore.RetrieveRequest.ids)
}
// repeated int64 output_fields_id = 2;
inline int RetrieveRequest::output_fields_id_size() const {
return output_fields_id_.size();
}
inline void RetrieveRequest::clear_output_fields_id() {
output_fields_id_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RetrieveRequest::output_fields_id(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.segcore.RetrieveRequest.output_fields_id)
return output_fields_id_.Get(index);
}
inline void RetrieveRequest::set_output_fields_id(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
output_fields_id_.Set(index, value);
// @@protoc_insertion_point(field_set:milvus.proto.segcore.RetrieveRequest.output_fields_id)
}
inline void RetrieveRequest::add_output_fields_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
output_fields_id_.Add(value);
// @@protoc_insertion_point(field_add:milvus.proto.segcore.RetrieveRequest.output_fields_id)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
RetrieveRequest::output_fields_id() const {
// @@protoc_insertion_point(field_list:milvus.proto.segcore.RetrieveRequest.output_fields_id)
return output_fields_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
RetrieveRequest::mutable_output_fields_id() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.segcore.RetrieveRequest.output_fields_id)
return &output_fields_id_;
}
// -------------------------------------------------------------------
// RetrieveResults
// .milvus.proto.schema.IDs ids = 1;
@ -974,8 +743,6 @@ inline void LoadSegmentMeta::set_total_size(::PROTOBUF_NAMESPACE_ID::int64 value
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)

25
internal/core/src/query/Plan.cpp
View File

@ -396,6 +396,13 @@ CreatePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int64_t
return ProtoParser(schema).CreatePlan(plan_node);
}
std::unique_ptr<RetrievePlan>
CreateRetrievePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int size) {
proto::plan::PlanNode plan_node;
plan_node.ParseFromArray(serialized_expr_plan, size);
return ProtoParser(schema).CreateRetrievePlan(plan_node);
}
std::vector<ExprPtr>
Parser::ParseItemList(const Json& body) {
std::vector<ExprPtr> results;
@ -546,15 +553,15 @@ GetNumOfQueries(const PlaceholderGroup* group) {
return group->at(0).num_of_queries_;
}
std::unique_ptr<RetrievePlan>
CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request) {
auto plan = std::make_unique<RetrievePlan>();
plan->ids_ = std::unique_ptr<proto::schema::IDs>(request.release_ids());
for (auto& field_id : request.output_fields_id()) {
plan->field_offsets_.push_back(schema.get_offset(FieldId(field_id)));
}
return plan;
}
// std::unique_ptr<RetrievePlan>
// CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request) {
// auto plan = std::make_unique<RetrievePlan>();
// plan->ids_ = std::unique_ptr<proto::schema::IDs>(request.release_ids());
// for (auto& field_id : request.output_fields_id()) {
// plan->field_offsets_.push_back(schema.get_offset(FieldId(field_id)));
// }
// return plan;
//}
void
Plan::check_identical(Plan& other) {

5
internal/core/src/query/Plan.h
View File

@ -38,8 +38,11 @@ ParsePlaceholderGroup(const Plan* plan, const std::string& placeholder_group_blo
int64_t
GetNumOfQueries(const PlaceholderGroup*);
// std::unique_ptr<RetrievePlan>
// CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request);
std::unique_ptr<RetrievePlan>
CreateRetrievePlan(const Schema& schema, proto::segcore::RetrieveRequest&& request);
CreateRetrievePlanByExpr(const Schema& schema, const char* serialized_expr_plan, int size);
// Query Overall TopK from Plan
// Used to alloc result memory at Go side

8
internal/core/src/query/PlanImpl.h
View File

@ -81,7 +81,13 @@ struct Placeholder {
};
struct RetrievePlan {
std::unique_ptr<proto::schema::IDs> ids_;
public:
explicit RetrievePlan(const Schema& schema) : schema_(schema) {
}
public:
const Schema& schema_;
std::unique_ptr<RetrievePlanNode> plan_node_;
std::vector<FieldOffset> field_offsets_;
};

8
internal/core/src/query/PlanNode.h
View File

@ -55,4 +55,12 @@ struct BinaryVectorANNS : VectorPlanNode {
accept(PlanNodeVisitor&) override;
};
struct RetrievePlanNode : PlanNode {
public:
void
accept(PlanNodeVisitor&) override;
ExprPtr predicate_;
};
} // namespace milvus::query

29
internal/core/src/query/PlanProto.cpp
View File

@ -137,6 +137,17 @@ ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) {
return plan_node;
}
std::unique_ptr<RetrievePlanNode>
ProtoParser::RetrievePlanNodeFromProto(const planpb::PlanNode& plan_node_proto) {
Assert(plan_node_proto.has_predicates());
auto& predicate_proto = plan_node_proto.predicates();
auto expr_opt = [&]() -> ExprPtr { return ParseExpr(predicate_proto); }();
auto plan_node = [&]() -> std::unique_ptr<RetrievePlanNode> { return std::make_unique<RetrievePlanNode>(); }();
plan_node->predicate_ = std::move(expr_opt);
return plan_node;
}
std::unique_ptr<Plan>
ProtoParser::CreatePlan(const proto::plan::PlanNode& plan_node_proto) {
auto plan = std::make_unique<Plan>(schema);
@ -159,6 +170,24 @@ ProtoParser::CreatePlan(const proto::plan::PlanNode& plan_node_proto) {
return plan;
}
std::unique_ptr<RetrievePlan>
ProtoParser::CreateRetrievePlan(const proto::plan::PlanNode& plan_node_proto) {
auto retrieve_plan = std::make_unique<RetrievePlan>(schema);
auto plan_node = RetrievePlanNodeFromProto(plan_node_proto);
ExtractedPlanInfo plan_info(schema.size());
ExtractInfoPlanNodeVisitor extractor(plan_info);
plan_node->accept(extractor);
retrieve_plan->plan_node_ = std::move(plan_node);
for (auto field_id_raw : plan_node_proto.output_field_ids()) {
auto field_id = FieldId(field_id_raw);
auto offset = schema.get_offset(field_id);
retrieve_plan->field_offsets_.push_back(offset);
}
return retrieve_plan;
}
ExprPtr
ProtoParser::ParseUnaryRangeExpr(const proto::plan::UnaryRangeExpr& expr_pb) {
auto& column_info = expr_pb.column_info();

6
internal/core/src/query/PlanProto.h
View File

@ -50,9 +50,15 @@ class ProtoParser {
std::unique_ptr<VectorPlanNode>
PlanNodeFromProto(const proto::plan::PlanNode& plan_node_proto);
std::unique_ptr<RetrievePlanNode>
RetrievePlanNodeFromProto(const proto::plan::PlanNode& plan_node_proto);
std::unique_ptr<Plan>
CreatePlan(const proto::plan::PlanNode& plan_node_proto);
std::unique_ptr<RetrievePlan>
CreateRetrievePlan(const proto::plan::PlanNode& plan_node_proto);
private:
const Schema& schema;
// boost::dynamic_bitset<> involved_fields;

23
internal/core/src/query/generated/ExecPlanNodeVisitor.h
View File

@ -27,14 +27,21 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
void
visit(BinaryVectorANNS& node) override;
void
visit(RetrievePlanNode& node);
public:
using RetType = SearchResult;
using RetrieveRetType = RetrieveResult;
ExecPlanNodeVisitor(const segcore::SegmentInterface& segment,
Timestamp timestamp,
const PlaceholderGroup& placeholder_group)
: segment_(segment), timestamp_(timestamp), placeholder_group_(placeholder_group) {
}
// using RetType = nlohmann::json;
ExecPlanNodeVisitor(const segcore::SegmentInterface& segment, Timestamp timestamp)
: segment_(segment), timestamp_(timestamp) {
}
RetType
get_moved_result(PlanNode& node) {
@ -46,6 +53,17 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
return ret;
}
RetrieveRetType
get_retrieve_result(PlanNode& node) {
assert(!retrieve_ret_.has_value());
std::cout.flush();
node.accept(*this);
assert(retrieve_ret_.has_value());
auto retrieve_ret = std::move(retrieve_ret_).value();
retrieve_ret_ = std::nullopt;
return retrieve_ret;
}
private:
template <typename VectorType>
void
@ -55,8 +73,9 @@ class ExecPlanNodeVisitor : public PlanNodeVisitor {
// std::optional<RetType> ret_;
const segcore::SegmentInterface& segment_;
Timestamp timestamp_;
const PlaceholderGroup& placeholder_group_;
PlaceholderGroup placeholder_group_;
std::optional<RetType> ret_;
std::optional<RetrieveResult> retrieve_ret_;
};
} // namespace milvus::query

3
internal/core/src/query/generated/ExtractInfoPlanNodeVisitor.h
View File

@ -24,6 +24,9 @@ class ExtractInfoPlanNodeVisitor : public PlanNodeVisitor {
void
visit(BinaryVectorANNS& node) override;
void
visit(RetrievePlanNode& node);
public:
explicit ExtractInfoPlanNodeVisitor(ExtractedPlanInfo& plan_info) : plan_info_(plan_info) {
}

5
internal/core/src/query/generated/PlanNode.cpp
View File

@ -25,4 +25,9 @@ BinaryVectorANNS::accept(PlanNodeVisitor& visitor) {
visitor.visit(*this);
}
void
RetrievePlanNode::accept(PlanNodeVisitor& visitor) {
visitor.visit(*this);
}
} // namespace milvus::query

3
internal/core/src/query/generated/PlanNodeVisitor.h
View File

@ -24,5 +24,8 @@ class PlanNodeVisitor {
virtual void
visit(BinaryVectorANNS&) = 0;
virtual void
visit(RetrievePlanNode&) = 0;
};
} // namespace milvus::query

3
internal/core/src/query/generated/ShowPlanNodeVisitor.h
View File

@ -28,6 +28,9 @@ class ShowPlanNodeVisitor : public PlanNodeVisitor {
void
visit(BinaryVectorANNS& node) override;
void
visit(RetrievePlanNode& node) override;
public:
using RetType = nlohmann::json;

3
internal/core/src/query/generated/VerifyPlanNodeVisitor.h
View File

@ -27,6 +27,9 @@ class VerifyPlanNodeVisitor : public PlanNodeVisitor {
void
visit(BinaryVectorANNS& node) override;
void
visit(RetrievePlanNode& node) override;
public:
using RetType = SearchResult;
VerifyPlanNodeVisitor() = default;

27
internal/core/src/query/visitors/ExecPlanNodeVisitor.cpp
View File

@ -114,6 +114,33 @@ ExecPlanNodeVisitor::VectorVisitorImpl(VectorPlanNode& node) {
ret_ = ret;
}
void
ExecPlanNodeVisitor::visit(RetrievePlanNode& node) {
assert(!retrieve_ret_.has_value());
auto segment = dynamic_cast<const segcore::SegmentInternalInterface*>(&segment_);
AssertInfo(segment, "Support SegmentSmallIndex Only");
RetrieveRetType ret;
boost::dynamic_bitset<> bitset_holder;
auto active_count = segment->get_active_count(timestamp_);
if (active_count == 0) {
return;
}
if (node.predicate_ != nullptr) {
ExecExprVisitor::RetType expr_ret =
ExecExprVisitor(*segment, active_count, timestamp_).call_child(*(node.predicate_));
bitset_holder = std::move(expr_ret);
}
segment->mask_with_timestamps(bitset_holder, timestamp_);
auto seg_offsets = std::move(segment->search_ids(bitset_holder, MAX_TIMESTAMP));
ret.result_offsets_.assign((int64_t*)seg_offsets.data(), (int64_t*)seg_offsets.data() + seg_offsets.size());
retrieve_ret_ = ret;
}
void
ExecPlanNodeVisitor::visit(FloatVectorANNS& node) {
VectorVisitorImpl<FloatVector>(node);

7
internal/core/src/query/visitors/ExtractInfoPlanNodeVisitor.cpp
View File

@ -48,4 +48,11 @@ ExtractInfoPlanNodeVisitor::visit(BinaryVectorANNS& node) {
}
}
void
ExtractInfoPlanNodeVisitor::visit(RetrievePlanNode& node) {
// Assert(node.predicate_.has_value());
ExtractInfoExprVisitor expr_visitor(plan_info_);
node.predicate_->accept(expr_visitor);
}
} // namespace milvus::query

4
internal/core/src/query/visitors/ShowPlanNodeVisitor.cpp
View File

@ -93,4 +93,8 @@ ShowPlanNodeVisitor::visit(BinaryVectorANNS& node) {
ret_ = json_body;
}
void
ShowPlanNodeVisitor::visit(RetrievePlanNode& node) {
}
} // namespace milvus::query

4
internal/core/src/query/visitors/VerifyPlanNodeVisitor.cpp
View File

@ -108,4 +108,8 @@ VerifyPlanNodeVisitor::visit(BinaryVectorANNS& node) {
}
}
void
VerifyPlanNodeVisitor::visit(RetrievePlanNode& node) {
}
} // namespace milvus::query

21
internal/core/src/segcore/SegmentGrowingImpl.cpp
View File

@ -437,6 +437,27 @@ SegmentGrowingImpl::Insert(int64_t reserved_offset,
do_insert(reserved_offset, size, row_ids.data(), timestamps.data(), columns_data);
}
std::vector<SegOffset>
SegmentGrowingImpl::search_ids(const boost::dynamic_bitset<>& bitset, Timestamp timestamp) const {
std::vector<SegOffset> res_offsets;
for (int i = 0; i < bitset.size(); i++) {
if (bitset[i]) {
SegOffset the_offset(-1);
auto offset = SegOffset(i);
if (record_.timestamps_[offset.get()] < timestamp) {
the_offset = std::max(the_offset, offset);
}
if (the_offset == SegOffset(-1)) {
continue;
}
res_offsets.push_back(the_offset);
}
}
return res_offsets;
}
std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
SegmentGrowingImpl::search_ids(const IdArray& id_array, Timestamp timestamp) const {
Assert(id_array.has_int_id());

3
internal/core/src/segcore/SegmentGrowingImpl.h
View File

@ -182,6 +182,9 @@ class SegmentGrowingImpl : public SegmentGrowing {
std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
search_ids(const IdArray& id_array, Timestamp timestamp) const override;
std::vector<SegOffset>
search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const override;
protected:
int64_t
num_chunk() const override;

40
internal/core/src/segcore/SegmentInterface.cpp
View File

@ -108,7 +108,7 @@ CreateScalarArrayFrom(const void* data_raw, int64_t count, DataType data_type) {
break;
}
case DataType::INT32: {
auto data = reinterpret_cast<const int16_t*>(data_raw);
auto data = reinterpret_cast<const int32_t*>(data_raw);
auto obj = scalar_array->mutable_int_data();
obj->mutable_data()->Add(data, data + count);
break;
@ -192,29 +192,31 @@ SegmentInternalInterface::BulkSubScript(FieldOffset field_offset, const SegOffse
}
std::unique_ptr<proto::segcore::RetrieveResults>
SegmentInternalInterface::GetEntityById(const std::vector<FieldOffset>& field_offsets,
const IdArray& id_array,
Timestamp timestamp) const {
SegmentInternalInterface::Retrieve(const query::RetrievePlan* plan, Timestamp timestamp) const {
std::shared_lock lck(mutex_);
auto results = std::make_unique<proto::segcore::RetrieveResults>();
query::ExecPlanNodeVisitor visitor(*this, timestamp);
auto retrieve_results = visitor.get_retrieve_result(*plan->plan_node_);
retrieve_results.segment_ = (void*)this;
auto [ids_, seg_offsets] = search_ids(id_array, timestamp);
// std::string dbg_log;
// dbg_log += "id_array:" + id_array.DebugString() + "\n";
// dbg_log += "ids:" + ids_->DebugString() + "\n";
// dbg_log += "segment_info:" + this->debug();
// std::cout << dbg_log << std::endl;
results->set_allocated_ids(ids_.release());
for (auto& seg_offset : seg_offsets) {
results->add_offset(seg_offset.get());
for (auto& seg_offset : retrieve_results.result_offsets_) {
results->add_offset(seg_offset);
}
auto fields_data = results->mutable_fields_data();
for (auto field_offset : field_offsets) {
auto col = BulkSubScript(field_offset, seg_offsets.data(), seg_offsets.size());
fields_data->AddAllocated(col.release());
auto ids = results->mutable_ids();
auto pk_offset = plan->schema_.get_primary_key_offset();
for (auto field_offset : plan->field_offsets_) {
auto col = BulkSubScript(field_offset, (SegOffset*)retrieve_results.result_offsets_.data(),
retrieve_results.result_offsets_.size());
auto col_data = col.release();
fields_data->AddAllocated(col_data);
if (pk_offset.has_value() && pk_offset.value() == field_offset) {
auto int_ids = ids->mutable_int_id();
for (int j = 0; j < col_data->scalars().long_data().data_size(); ++j) {
int_ids->add_data(col_data->scalars().long_data().data(j));
}
}
}
return results;
}

11
internal/core/src/segcore/SegmentInterface.h
View File

@ -40,9 +40,7 @@ class SegmentInterface {
Search(const query::Plan* Plan, const query::PlaceholderGroup& placeholder_group, Timestamp timestamp) const = 0;
virtual std::unique_ptr<proto::segcore::RetrieveResults>
GetEntityById(const std::vector<FieldOffset>& field_offsets,
const IdArray& id_array,
Timestamp timestamp) const = 0;
Retrieve(const query::RetrievePlan* Plan, Timestamp timestamp) const = 0;
virtual int64_t
GetMemoryUsageInBytes() const = 0;
@ -88,9 +86,7 @@ class SegmentInternalInterface : public SegmentInterface {
FillTargetEntry(const query::Plan* plan, SearchResult& results) const override;
std::unique_ptr<proto::segcore::RetrieveResults>
GetEntityById(const std::vector<FieldOffset>& field_offsets,
const IdArray& id_array,
Timestamp timestamp) const override;
Retrieve(const query::RetrievePlan* plan, Timestamp timestamp) const override;
virtual std::string
debug() const = 0;
@ -123,6 +119,9 @@ class SegmentInternalInterface : public SegmentInterface {
virtual int64_t
get_active_count(Timestamp ts) const = 0;
virtual std::vector<SegOffset>
search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const = 0;
protected:
// internal API: return chunk_data in span
virtual SpanBase

11
internal/core/src/segcore/SegmentSealedImpl.cpp
View File

@ -449,6 +449,17 @@ SegmentSealedImpl::search_ids(const IdArray& id_array, Timestamp timestamp) cons
return primary_key_index_->do_search_ids(id_array);
}
std::vector<SegOffset>
SegmentSealedImpl::search_ids(const boost::dynamic_bitset<>& bitset, Timestamp timestamp) const {
std::vector<SegOffset> dst_offset;
for (int i = 0; i < bitset.size(); i++) {
if (bitset[i]) {
dst_offset.emplace_back(SegOffset(i));
}
}
return std::move(dst_offset);
}
std::string
SegmentSealedImpl::debug() const {
std::string log_str;

3
internal/core/src/segcore/SegmentSealedImpl.h
View File

@ -126,6 +126,9 @@ class SegmentSealedImpl : public SegmentSealed {
std::pair<std::unique_ptr<IdArray>, std::vector<SegOffset>>
search_ids(const IdArray& id_array, Timestamp timestamp) const override;
std::vector<SegOffset>
search_ids(const boost::dynamic_bitset<>& view, Timestamp timestamp) const override;
// virtual void
// build_index_if_primary_key(FieldId field_id);

44
internal/core/src/segcore/plan_c.cpp
View File

@ -130,23 +130,51 @@ DeletePlaceholderGroup(CPlaceholderGroup cPlaceholder_group) {
// std::cout << "delete placeholder" << std::endl;
}
CStatus
CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output) {
auto col = (milvus::segcore::Collection*)c_col;
try {
milvus::proto::segcore::RetrieveRequest request;
request.ParseFromArray(retrieve_request.proto_blob, retrieve_request.proto_size);
auto plan = milvus::query::CreateRetrievePlan(*col->get_schema(), std::move(request));
*output = plan.release();
// CStatus
// CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output) {
// auto col = (milvus::segcore::Collection*)c_col;
// try {
// milvus::proto::segcore::RetrieveRequest request;
// request.ParseFromArray(retrieve_request.proto_blob, retrieve_request.proto_size);
// auto plan = milvus::query::CreateRetrievePlan(*col->get_schema(), std::move(request));
// *output = plan.release();
//
// auto status = CStatus();
// status.error_code = Success;
// status.error_msg = "";
// return status;
// } catch (std::exception& e) {
// auto status = CStatus();
// status.error_code = UnexpectedError;
// status.error_msg = strdup(e.what());
// return status;
// }
//}
CStatus
CreateRetrievePlanByExpr(CCollection c_col, const char* serialized_expr_plan, int64_t size, CRetrievePlan* res_plan) {
auto col = (milvus::segcore::Collection*)c_col;
try {
auto res = milvus::query::CreateRetrievePlanByExpr(*col->get_schema(), serialized_expr_plan, size);
auto status = CStatus();
status.error_code = Success;
status.error_msg = "";
auto plan = (CRetrievePlan)res.release();
*res_plan = plan;
return status;
} catch (milvus::SegcoreError& e) {
auto status = CStatus();
status.error_code = e.get_error_code();
status.error_msg = strdup(e.what());
*res_plan = nullptr;
return status;
} catch (std::exception& e) {
auto status = CStatus();
status.error_code = UnexpectedError;
status.error_msg = strdup(e.what());
*res_plan = nullptr;
return status;
}
}

3
internal/core/src/segcore/plan_c.h
View File

@ -53,6 +53,9 @@ DeletePlaceholderGroup(CPlaceholderGroup placeholder_group);
CStatus
CreateRetrievePlan(CCollection c_col, CProto retrieve_request, CRetrievePlan* output);
CStatus
CreateRetrievePlanByExpr(CCollection c_col, const char* serialized_expr_plan, int64_t size, CRetrievePlan* res_plan);
void
DeleteRetrievePlan(CRetrievePlan plan);

4
internal/core/src/segcore/segment_c.cpp
View File

@ -225,11 +225,11 @@ DropSealedSegmentIndex(CSegmentInterface c_segment, int64_t field_id) {
}
CProtoResult
GetEntityByIds(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp) {
Retrieve(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp) {
try {
auto segment = (const milvus::segcore::SegmentInterface*)c_segment;
auto plan = (const milvus::query::RetrievePlan*)c_plan;
auto result = segment->GetEntityById(plan->field_offsets_, *plan->ids_, timestamp);
auto result = segment->Retrieve(plan, timestamp);
return milvus::AllocCProtoResult(*result);
} catch (std::exception& e) {
return CProtoResult{milvus::FailureCStatus(UnexpectedError, e.what())};

3
internal/core/src/segcore/segment_c.h
View File

@ -25,6 +25,7 @@ extern "C" {
typedef void* CSegmentInterface;
typedef void* CSearchResult;
typedef void* CRetrieveResult;
////////////////////////////// common interfaces //////////////////////////////
CSegmentInterface
@ -44,7 +45,7 @@ Search(CSegmentInterface c_segment,
CSearchResult* result);
CProtoResult
GetEntityByIds(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp);
Retrieve(CSegmentInterface c_segment, CRetrievePlan c_plan, uint64_t timestamp);
int64_t
GetMemoryUsageInBytes(CSegmentInterface c_segment);

136
internal/core/unittest/test_get_entity_by_ids.cpp
View File

@ -12,6 +12,7 @@
#include <gtest/gtest.h>
#include "test_utils/DataGen.h"
#include "segcore/ScalarIndex.h"
#include "query/ExprImpl.h"
using namespace milvus;
using namespace milvus::segcore;
@ -68,17 +69,79 @@ TEST(GetEntityByIds, AUTOID) {
req_ids_arr->add_data(-1);
std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
auto ids = retrieve_results->ids().int_id();
// auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
// auto ids = retrieve_results->ids().int_id();
// Assert(retrieve_results->fields_data_size() == target_offsets.size());
// FieldOffset field_offset(0);
// auto field0 = retrieve_results->fields_data(0);
// Assert(field0.has_scalars());
// auto field0_data = field0.scalars().long_data();
// for (int i = 0; i < req_size; ++i) {
// auto id = ids.data(i);
// auto index = choose(i);
// ASSERT_EQ(id, dataset.row_ids_[index]);
// auto data = field0_data.data(i);
// ASSERT_EQ(data, i64_col[index]);
// }
//
// auto field1 = retrieve_results->fields_data(1);
// Assert(field1.has_vectors());
// auto field1_data = field1.vectors().float_vector();
// ASSERT_EQ(field1_data.data_size(), DIM * req_size);
//
// for (int i = 0; i < req_size; ++i) {
// for (int d = 0; d < DIM; ++d) {
// auto index = choose(i);
// auto data = field1_data.data(i * DIM + d);
// auto ref = vf_col[index * DIM + d];
// ASSERT_EQ(data, ref);
// }
// }
}
TEST(Retrieve, AUTOID) {
auto schema = std::make_shared<Schema>();
auto fid_64 = schema->AddDebugField("i64", DataType::INT64);
auto DIM = 16;
auto fid_vec = schema->AddDebugField("vector_64", DataType::VECTOR_FLOAT, DIM, MetricType::METRIC_L2);
schema->set_primary_key(FieldOffset(0));
int64_t N = 100;
int64_t req_size = 10;
auto choose = [=](int i) { return i * 3 % N; };
auto dataset = DataGen(schema, N);
auto segment = CreateSealedSegment(schema);
SealedLoader(dataset, *segment);
auto i64_col = dataset.get_col<int64_t>(0);
auto plan = std::make_unique<query::RetrievePlan>(*schema);
auto term_expr = std::make_unique<query::TermExprImpl<int64_t>>();
term_expr->field_offset_ = FieldOffset(0);
term_expr->data_type_ = DataType::INT64;
for (int i = 0; i < req_size; ++i) {
term_expr->terms_.emplace_back(i64_col[choose(i)]);
}
plan->plan_node_ = std::make_unique<query::RetrievePlanNode>();
plan->plan_node_->predicate_ = std::move(term_expr);
std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
plan->field_offsets_ = target_offsets;
auto retrieve_results = segment->Retrieve(plan.get(), 100);
Assert(retrieve_results->fields_data_size() == target_offsets.size());
FieldOffset field_offset(0);
auto field0 = retrieve_results->fields_data(0);
Assert(field0.has_scalars());
auto field0_data = field0.scalars().long_data();
for (int i = 0; i < req_size; ++i) {
auto index = choose(i);
auto data = field0_data.data(i);
}
for (int i = 0; i < req_size; ++i) {
auto id = ids.data(i);
auto index = choose(i);
ASSERT_EQ(id, dataset.row_ids_[index]);
auto data = field0_data.data(i);
ASSERT_EQ(data, i64_col[index]);
}
@ -87,15 +150,6 @@ TEST(GetEntityByIds, AUTOID) {
Assert(field1.has_vectors());
auto field1_data = field1.vectors().float_vector();
ASSERT_EQ(field1_data.data_size(), DIM * req_size);
for (int i = 0; i < req_size; ++i) {
for (int d = 0; d < DIM; ++d) {
auto index = choose(i);
auto data = field1_data.data(i * DIM + d);
auto ref = vf_col[index * DIM + d];
ASSERT_EQ(data, ref);
}
}
}
TEST(GetEntityByIds, PrimaryKey) {
@ -126,32 +180,32 @@ TEST(GetEntityByIds, PrimaryKey) {
req_ids_arr->add_data(-1);
std::vector<FieldOffset> target_offsets{FieldOffset(0), FieldOffset(1)};
auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
auto ids = retrieve_results->ids().int_id();
Assert(retrieve_results->fields_data_size() == target_offsets.size());
FieldOffset field_offset(0);
auto field0 = retrieve_results->fields_data(0);
Assert(field0.has_scalars());
auto field0_data = field0.scalars().long_data();
for (int i = 0; i < req_size; ++i) {
auto id = ids.data(i);
auto index = choose(i);
ASSERT_EQ(id, i64_col[index]);
auto data = field0_data.data(i);
ASSERT_EQ(data, i64_col[index]);
}
auto field1 = retrieve_results->fields_data(1);
Assert(field1.has_vectors());
auto field1_data = field1.vectors().float_vector();
ASSERT_EQ(field1_data.data_size(), DIM * req_size);
for (int i = 0; i < req_size; ++i) {
for (int d = 0; d < DIM; ++d) {
auto index = choose(i);
auto data = field1_data.data(i * DIM + d);
auto ref = vf_col[index * DIM + d];
ASSERT_EQ(data, ref);
}
}
// auto retrieve_results = segment->GetEntityById(target_offsets, *req_ids, 0);
// auto ids = retrieve_results->ids().int_id();
// Assert(retrieve_results->fields_data_size() == target_offsets.size());
// FieldOffset field_offset(0);
// auto field0 = retrieve_results->fields_data(0);
// Assert(field0.has_scalars());
// auto field0_data = field0.scalars().long_data();
// for (int i = 0; i < req_size; ++i) {
// auto id = ids.data(i);
// auto index = choose(i);
// ASSERT_EQ(id, i64_col[index]);
// auto data = field0_data.data(i);
// ASSERT_EQ(data, i64_col[index]);
// }
//
// auto field1 = retrieve_results->fields_data(1);
// Assert(field1.has_vectors());
// auto field1_data = field1.vectors().float_vector();
// ASSERT_EQ(field1_data.data_size(), DIM * req_size);
//
// for (int i = 0; i < req_size; ++i) {
// for (int d = 0; d < DIM; ++d) {
// auto index = choose(i);
// auto data = field1_data.data(i * DIM + d);
// auto ref = vf_col[index * DIM + d];
// ASSERT_EQ(data, ref);
// }
// }
}

5
internal/core/unittest/test_utils/DataGen.h
View File

@ -148,8 +148,11 @@ DataGen(SchemaPtr schema, int64_t N, uint64_t seed = 42) {
x = index++;
}
} else {
int i = 0;
for (auto& x : data) {
x = er() % (2 * N);
x = i;
i++;
}
}
insert_cols(data);
@ -191,7 +194,7 @@ DataGen(SchemaPtr schema, int64_t N, uint64_t seed = 42) {
res.row_ids_.push_back(i);
res.timestamps_.push_back(i);
}
std::shuffle(res.row_ids_.begin(), res.row_ids_.end(), er);
// std::shuffle(res.row_ids_.begin(), res.row_ids_.end(), er);
res.generate_rows(N, schema);
return std::move(res);
}

2
internal/proto/internal.proto
View File

@ -161,7 +161,7 @@ message RetrieveRequest {
int64 dbID = 3;
int64 collectionID = 4;
repeated int64 partitionIDs = 5;
schema.IDs ids = 6;
bytes serialized_expr_plan = 6;
repeated int64 output_fields_id = 7;
uint64 travel_timestamp = 8;
uint64 guarantee_timestamp = 9;

254
internal/proto/internalpb/internal.pb.go
View File

@ -1313,7 +1313,7 @@ type RetrieveRequest struct {
DbID int64 `protobuf:"varint,3,opt,name=dbID,proto3" json:"dbID,omitempty"`
CollectionID int64 `protobuf:"varint,4,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,5,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
Ids *schemapb.IDs `protobuf:"bytes,6,opt,name=ids,proto3" json:"ids,omitempty"`
SerializedExprPlan []byte `protobuf:"bytes,6,opt,name=serialized_expr_plan,json=serializedExprPlan,proto3" json:"serialized_expr_plan,omitempty"`
OutputFieldsId []int64 `protobuf:"varint,7,rep,packed,name=output_fields_id,json=outputFieldsId,proto3" json:"output_fields_id,omitempty"`
TravelTimestamp uint64 `protobuf:"varint,8,opt,name=travel_timestamp,json=travelTimestamp,proto3" json:"travel_timestamp,omitempty"`
GuaranteeTimestamp uint64 `protobuf:"varint,9,opt,name=guarantee_timestamp,json=guaranteeTimestamp,proto3" json:"guarantee_timestamp,omitempty"`
@ -1382,9 +1382,9 @@ func (m *RetrieveRequest) GetPartitionIDs() []int64 {
return nil
}
func (m *RetrieveRequest) GetIds() *schemapb.IDs {
func (m *RetrieveRequest) GetSerializedExprPlan() []byte {
if m != nil {
return m.Ids
return m.SerializedExprPlan
}
return nil
}
@ -2220,128 +2220,128 @@ func init() {
func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
var fileDescriptor_41f4a519b878ee3b = []byte{
// 1959 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x5b, 0x6f, 0x24, 0x47,
0x15, 0xa6, 0xa7, 0xc7, 0x9e, 0x99, 0x33, 0x63, 0x7b, 0xb6, 0xec, 0x6c, 0xda, 0xde, 0xcd, 0xae,
0xd3, 0x09, 0x60, 0xb2, 0x62, 0xbd, 0x38, 0x40, 0x22, 0x84, 0xd8, 0xc4, 0x9e, 0xb0, 0x8c, 0x36,
0x36, 0xa6, 0xbd, 0x89, 0x04, 0x2f, 0xad, 0x9a, 0xee, 0xf2, 0xb8, 0xd9, 0xbe, 0xa5, 0xab, 0xda,
0xbb, 0x93, 0x27, 0x1e, 0x78, 0x02, 0x81, 0x04, 0x12, 0x7f, 0x83, 0x57, 0x9e, 0xb8, 0x88, 0x27,
0x24, 0x7e, 0x01, 0xff, 0x04, 0x21, 0x1e, 0x50, 0x9d, 0xaa, 0xbe, 0xcc, 0x78, 0x6c, 0x66, 0xbd,
0x02, 0x82, 0xe0, 0x6d, 0xea, 0x3b, 0xa7, 0x2e, 0xe7, 0x3b, 0x97, 0x3a, 0x5d, 0x03, 0xab, 0x41,
0x2c, 0x58, 0x16, 0xd3, 0xf0, 0x7e, 0x9a, 0x25, 0x22, 0x21, 0xaf, 0x44, 0x41, 0x78, 0x9e, 0x73,
0x35, 0xba, 0x5f, 0x08, 0xb7, 0x7a, 0x5e, 0x12, 0x45, 0x49, 0xac, 0xe0, 0xad, 0x1e, 0xf7, 0xce,
0x58, 0x44, 0xd5, 0xc8, 0xfe, 0x9d, 0x01, 0x2b, 0x07, 0x49, 0x94, 0x26, 0x31, 0x8b, 0xc5, 0x30,
0x3e, 0x4d, 0xc8, 0x4d, 0x58, 0x8e, 0x13, 0x9f, 0x0d, 0x07, 0x96, 0xb1, 0x6d, 0xec, 0x98, 0x8e,
0x1e, 0x11, 0x02, 0xcd, 0x2c, 0x09, 0x99, 0xd5, 0xd8, 0x36, 0x76, 0x3a, 0x0e, 0xfe, 0x26, 0x0f,
0x01, 0xb8, 0xa0, 0x82, 0xb9, 0x5e, 0xe2, 0x33, 0xcb, 0xdc, 0x36, 0x76, 0x56, 0xf7, 0xb6, 0xef,
0xcf, 0x3d, 0xc5, 0xfd, 0x13, 0xa9, 0x78, 0x90, 0xf8, 0xcc, 0xe9, 0xf0, 0xe2, 0x27, 0x79, 0x0f,
0x80, 0x3d, 0x17, 0x19, 0x75, 0x83, 0xf8, 0x34, 0xb1, 0x9a, 0xdb, 0xe6, 0x4e, 0x77, 0xef, 0xf5,
0xe9, 0x05, 0xf4, 0xe1, 0x1f, 0xb3, 0xc9, 0xc7, 0x34, 0xcc, 0xd9, 0x31, 0x0d, 0x32, 0xa7, 0x83,
0x93, 0xe4, 0x71, 0xed, 0xbf, 0x18, 0xb0, 0x56, 0x1a, 0x80, 0x7b, 0x70, 0xf2, 0x0d, 0x58, 0xc2,
0x2d, 0xd0, 0x82, 0xee, 0xde, 0x9b, 0x97, 0x9c, 0x68, 0xca, 0x6e, 0x47, 0x4d, 0x21, 0x1f, 0xc1,
0x3a, 0xcf, 0x47, 0x5e, 0x21, 0x72, 0x11, 0xe5, 0x56, 0x03, 0x8f, 0xb6, 0xd8, 0x4a, 0xa4, 0xbe,
0x80, 0x3e, 0xd2, 0xdb, 0xb0, 0x2c, 0x57, 0xca, 0x39, 0xb2, 0xd4, 0xdd, 0xbb, 0x35, 0xd7, 0xc8,
0x13, 0x54, 0x71, 0xb4, 0xaa, 0x7d, 0x0b, 0x36, 0x1f, 0x31, 0x31, 0x63, 0x9d, 0xc3, 0x3e, 0xc9,
0x19, 0x17, 0x5a, 0xf8, 0x24, 0x88, 0xd8, 0x93, 0xc0, 0x7b, 0x7a, 0x70, 0x46, 0xe3, 0x98, 0x85,
0x85, 0xf0, 0x35, 0xb8, 0xf5, 0x88, 0xe1, 0x84, 0x80, 0x8b, 0xc0, 0xe3, 0x33, 0xe2, 0x57, 0x60,
0xfd, 0x11, 0x13, 0x03, 0x7f, 0x06, 0xfe, 0x18, 0xda, 0x47, 0xd2, 0xd9, 0x32, 0x0c, 0xbe, 0x0e,
0x2d, 0xea, 0xfb, 0x19, 0xe3, 0x5c, 0xb3, 0x78, 0x7b, 0xee, 0x89, 0xdf, 0x57, 0x3a, 0x4e, 0xa1,
0x3c, 0x2f, 0x4c, 0xec, 0x1f, 0x02, 0x0c, 0xe3, 0x40, 0x1c, 0xd3, 0x8c, 0x46, 0xfc, 0xd2, 0x00,
0x1b, 0x40, 0x8f, 0x0b, 0x9a, 0x09, 0x37, 0x45, 0x3d, 0x4d, 0xf9, 0x02, 0xd1, 0xd0, 0xc5, 0x69,
0x6a, 0x75, 0xfb, 0xfb, 0x00, 0x27, 0x22, 0x0b, 0xe2, 0xf1, 0x87, 0x01, 0x17, 0x72, 0xaf, 0x73,
0xa9, 0x27, 0x8d, 0x30, 0x77, 0x3a, 0x8e, 0x1e, 0xd5, 0xdc, 0xd1, 0x58, 0xdc, 0x1d, 0x0f, 0xa1,
0x5b, 0xd0, 0x7d, 0xc8, 0xc7, 0xe4, 0x01, 0x34, 0x47, 0x94, 0xb3, 0x2b, 0xe9, 0x39, 0xe4, 0xe3,
0x7d, 0xca, 0x99, 0x83, 0x9a, 0xf6, 0x4f, 0x4c, 0x78, 0xf5, 0x20, 0x63, 0x18, 0xfc, 0x61, 0xc8,
0x3c, 0x11, 0x24, 0xb1, 0xe6, 0xfe, 0xc5, 0x57, 0x23, 0xaf, 0x42, 0xcb, 0x1f, 0xb9, 0x31, 0x8d,
0x0a, 0xb2, 0x97, 0xfd, 0xd1, 0x11, 0x8d, 0x18, 0xf9, 0x02, 0xac, 0x7a, 0xe5, 0xfa, 0x12, 0xc1,
0x98, 0xeb, 0x38, 0x33, 0x28, 0x79, 0x13, 0x56, 0x52, 0x9a, 0x89, 0xa0, 0x54, 0x6b, 0xa2, 0xda,
0x34, 0x28, 0x1d, 0xea, 0x8f, 0x86, 0x03, 0x6b, 0x09, 0x9d, 0x85, 0xbf, 0x89, 0x0d, 0xbd, 0x6a,
0xad, 0xe1, 0xc0, 0x5a, 0x46, 0xd9, 0x14, 0x46, 0xb6, 0xa1, 0x5b, 0x2e, 0x34, 0x1c, 0x58, 0x2d,
0x54, 0xa9, 0x43, 0xd2, 0x39, 0xaa, 0x16, 0x59, 0xed, 0x6d, 0x63, 0xa7, 0xe7, 0xe8, 0x11, 0x79,
0x00, 0xeb, 0xe7, 0x41, 0x26, 0x72, 0x1a, 0xea, 0xf8, 0x94, 0xe7, 0xe0, 0x56, 0x07, 0x3d, 0x38,
0x4f, 0x44, 0xf6, 0x60, 0x23, 0x3d, 0x9b, 0xf0, 0xc0, 0x9b, 0x99, 0x02, 0x38, 0x65, 0xae, 0xcc,
0xfe, 0xa3, 0x01, 0xaf, 0x0c, 0xb2, 0x24, 0xfd, 0x4c, 0xb8, 0xa2, 0x20, 0xb9, 0x79, 0x05, 0xc9,
0x4b, 0x17, 0x49, 0xb6, 0x7f, 0xd6, 0x80, 0x9b, 0x2a, 0xa2, 0x8e, 0x0b, 0x62, 0xff, 0x05, 0x56,
0x7c, 0x11, 0xd6, 0xaa, 0x5d, 0x95, 0xc2, 0x7c, 0x33, 0x3e, 0x0f, 0xab, 0xa5, 0x83, 0x95, 0xde,
0xbf, 0x37, 0xa4, 0xec, 0x9f, 0x36, 0x60, 0x43, 0x3a, 0xf5, 0xff, 0x6c, 0x48, 0x36, 0x7e, 0xdf,
0x00, 0xa2, 0xa2, 0x63, 0x18, 0xfb, 0xec, 0xf9, 0x7f, 0x92, 0x8b, 0xd7, 0x00, 0x4e, 0x03, 0x16,
0xfa, 0x75, 0x1e, 0x3a, 0x88, 0xbc, 0x14, 0x07, 0x16, 0xb4, 0x70, 0x91, 0xd2, 0xfe, 0x62, 0x28,
0x6f, 0x13, 0xd5, 0x59, 0xe8, 0xdb, 0xa4, 0xbd, 0xf0, 0x6d, 0x82, 0xd3, 0xf4, 0x6d, 0xf2, 0x6b,
0x13, 0x56, 0x86, 0x31, 0x67, 0x99, 0xf8, 0x5f, 0x0e, 0x24, 0x72, 0x1b, 0x3a, 0x9c, 0x8d, 0x23,
0xd9, 0xe0, 0x0c, 0xb0, 0x58, 0x9b, 0x4e, 0x05, 0x48, 0xa9, 0xa7, 0x2a, 0xeb, 0x70, 0x60, 0x75,
0x94, 0x6b, 0x4b, 0x80, 0xdc, 0x01, 0x10, 0x41, 0xc4, 0xb8, 0xa0, 0x51, 0xaa, 0x2a, 0x72, 0xd3,
0xa9, 0x21, 0xf2, 0x16, 0xc8, 0x92, 0x67, 0xc3, 0x01, 0xb7, 0xba, 0xdb, 0xa6, 0x6c, 0x07, 0xd4,
0x88, 0x7c, 0x15, 0xda, 0x59, 0xf2, 0xcc, 0xf5, 0xa9, 0xa0, 0x56, 0x0f, 0x9d, 0xb7, 0x39, 0x97,
0xec, 0xfd, 0x30, 0x19, 0x39, 0xad, 0x2c, 0x79, 0x36, 0xa0, 0x82, 0xda, 0x7f, 0x35, 0x61, 0xe5,
0x84, 0xd1, 0xcc, 0x3b, 0xbb, 0xbe, 0xc3, 0xbe, 0x04, 0xfd, 0x8c, 0xf1, 0x3c, 0x14, 0x6e, 0x65,
0x96, 0xf2, 0xdc, 0x9a, 0xc2, 0x0f, 0x4a, 0xe3, 0x0a, 0xca, 0xcd, 0x2b, 0x28, 0x6f, 0xce, 0xa1,
0xdc, 0x86, 0x5e, 0x8d, 0x5f, 0x6e, 0x2d, 0xa1, 0xe9, 0x53, 0x18, 0xe9, 0x83, 0xe9, 0xf3, 0x10,
0x3d, 0xd6, 0x71, 0xe4, 0x4f, 0x72, 0x0f, 0x6e, 0xa4, 0x21, 0xf5, 0xd8, 0x59, 0x12, 0xfa, 0x2c,
0x73, 0xc7, 0x59, 0x92, 0xa7, 0xe8, 0xae, 0x9e, 0xd3, 0xaf, 0x09, 0x1e, 0x49, 0x9c, 0xbc, 0x03,
0x6d, 0x9f, 0x87, 0xae, 0x98, 0xa4, 0x0c, 0x5d, 0xb6, 0x7a, 0x89, 0xed, 0x03, 0x1e, 0x3e, 0x99,
0xa4, 0xcc, 0x69, 0xf9, 0xea, 0x07, 0x79, 0x00, 0x1b, 0x9c, 0x65, 0x01, 0x0d, 0x83, 0x4f, 0x99,
0xef, 0xb2, 0xe7, 0x69, 0xe6, 0xa6, 0x21, 0x8d, 0xd1, 0xb3, 0x3d, 0x87, 0x54, 0xb2, 0x0f, 0x9e,
0xa7, 0xd9, 0x71, 0x48, 0x63, 0xb2, 0x03, 0xfd, 0x24, 0x17, 0x69, 0x2e, 0x5c, 0xcc, 0x3e, 0xee,
0x06, 0x3e, 0x3a, 0xda, 0x74, 0x56, 0x15, 0xfe, 0x6d, 0x84, 0x87, 0xbe, 0xa4, 0x56, 0x64, 0xf4,
0x9c, 0x85, 0x6e, 0x19, 0x01, 0x56, 0x77, 0xdb, 0xd8, 0x69, 0x3a, 0x6b, 0x0a, 0x7f, 0x52, 0xc0,
0x64, 0x17, 0xd6, 0xc7, 0x39, 0xcd, 0x68, 0x2c, 0x18, 0xab, 0x69, 0xf7, 0x50, 0x9b, 0x94, 0xa2,
0x72, 0x82, 0xfd, 0x8b, 0x66, 0xe5, 0x7a, 0xe9, 0x25, 0x7e, 0x0d, 0xd7, 0x5f, 0xa7, 0x2f, 0x9c,
0x1b, 0x2f, 0xe6, 0xfc, 0x78, 0xb9, 0x0b, 0xdd, 0x88, 0x89, 0x2c, 0xf0, 0x94, 0x5f, 0x54, 0x1a,
0x83, 0x82, 0x90, 0xfc, 0xbb, 0xd0, 0x8d, 0xf3, 0xc8, 0xfd, 0x24, 0x67, 0x59, 0xc0, 0xb8, 0x4e,
0x65, 0x88, 0xf3, 0xe8, 0x7b, 0x0a, 0x21, 0xeb, 0xb0, 0x24, 0x92, 0xd4, 0x7d, 0xaa, 0x33, 0xb9,
0x29, 0x92, 0xf4, 0x31, 0xf9, 0x26, 0x6c, 0x71, 0x46, 0x43, 0xe6, 0xbb, 0x65, 0x56, 0x72, 0x97,
0x23, 0x17, 0xcc, 0xb7, 0x5a, 0xe8, 0x0a, 0x4b, 0x69, 0x9c, 0x94, 0x0a, 0x27, 0x5a, 0x2e, 0x99,
0x2e, 0x0f, 0x5e, 0x9b, 0xd6, 0xc6, 0xe6, 0x89, 0x54, 0xa2, 0x72, 0xc2, 0xbb, 0x60, 0x8d, 0xc3,
0x64, 0x44, 0x43, 0xf7, 0xc2, 0xae, 0xd8, 0xa5, 0x99, 0xce, 0x4d, 0x25, 0x3f, 0x99, 0xd9, 0x52,
0x9a, 0xc7, 0xc3, 0xc0, 0x63, 0xbe, 0x3b, 0x0a, 0x93, 0x91, 0x05, 0x18, 0x52, 0xa0, 0x20, 0x99,
0xc8, 0x32, 0x94, 0xb4, 0x82, 0xa4, 0xc1, 0x4b, 0xf2, 0x58, 0x60, 0x80, 0x98, 0xce, 0xaa, 0xc2,
0x8f, 0xf2, 0xe8, 0x40, 0xa2, 0xe4, 0x0d, 0x58, 0xd1, 0x9a, 0xc9, 0xe9, 0x29, 0x67, 0x02, 0x23,
0xc3, 0x74, 0x7a, 0x0a, 0xfc, 0x2e, 0x62, 0xf6, 0xdf, 0x1b, 0xb0, 0xe6, 0x48, 0x76, 0xd9, 0x39,
0xfb, 0xaf, 0x2f, 0x08, 0x6f, 0x81, 0x19, 0xf8, 0x1c, 0x1d, 0xdf, 0xdd, 0xb3, 0xa6, 0xcf, 0xad,
0x3f, 0xea, 0x87, 0x03, 0xee, 0x48, 0xa5, 0xb9, 0x29, 0xd9, 0x5a, 0x38, 0x25, 0xdb, 0x2f, 0x94,
0x92, 0x9d, 0x4b, 0x53, 0xf2, 0xb7, 0x66, 0x9d, 0xfe, 0xcf, 0x6a, 0x52, 0x6a, 0x5e, 0x9b, 0x8b,
0xf0, 0xfa, 0x10, 0xba, 0x9a, 0x50, 0xbc, 0x98, 0x96, 0xf0, 0x62, 0xba, 0x33, 0x77, 0x0e, 0x32,
0x2c, 0x2f, 0x25, 0x47, 0xb5, 0x3e, 0x5c, 0xfe, 0x26, 0xdf, 0x82, 0x5b, 0x17, 0x53, 0x35, 0xd3,
0x1c, 0xf9, 0xd6, 0x32, 0xfa, 0x68, 0x73, 0x36, 0x57, 0x0b, 0x12, 0x7d, 0xf2, 0x15, 0xd8, 0xa8,
0x25, 0x6b, 0x35, 0xb1, 0xa5, 0xbe, 0x8e, 0x2a, 0x59, 0x35, 0xe5, 0xaa, 0x74, 0x6d, 0x5f, 0x95,
0xae, 0xf6, 0x9f, 0x0d, 0x58, 0x19, 0xb0, 0x90, 0x89, 0x97, 0x48, 0x9e, 0x39, 0x5d, 0x4e, 0x63,
0x6e, 0x97, 0x33, 0xd5, 0x46, 0x98, 0x57, 0xb7, 0x11, 0xcd, 0x0b, 0x6d, 0xc4, 0xeb, 0xd0, 0x4b,
0xb3, 0x20, 0xa2, 0xd9, 0xc4, 0x7d, 0xca, 0x26, 0x45, 0x02, 0x75, 0x35, 0xf6, 0x98, 0x4d, 0xb8,
0x1d, 0xc3, 0xd6, 0x87, 0x09, 0xf5, 0xf7, 0x69, 0x48, 0x63, 0x8f, 0x69, 0x33, 0xf9, 0xf5, 0x2d,
0xbb, 0x03, 0x50, 0x63, 0xb2, 0x81, 0x1b, 0xd6, 0x10, 0xfb, 0x6f, 0x06, 0x74, 0xe4, 0x86, 0xd8,
0x7c, 0x5f, 0x63, 0xfd, 0xa9, 0xae, 0xab, 0x31, 0xa7, 0xeb, 0x2a, 0xfb, 0xe7, 0x82, 0xae, 0xaa,
0xa1, 0xae, 0x35, 0xc6, 0xcd, 0xe9, 0xc6, 0xf8, 0x2e, 0x74, 0x03, 0x79, 0x20, 0x37, 0xa5, 0xe2,
0x4c, 0xf1, 0xd4, 0x71, 0x00, 0xa1, 0x63, 0x89, 0xc8, 0xce, 0xb9, 0x50, 0xc0, 0xce, 0x79, 0x79,
0xe1, 0xce, 0x59, 0x2f, 0x82, 0x9d, 0xf3, 0x1f, 0x1a, 0x60, 0x69, 0x8a, 0xab, 0x67, 0xa8, 0x8f,
0x52, 0x1f, 0x5f, 0xc3, 0x6e, 0x43, 0xa7, 0x8c, 0x32, 0xfd, 0x0a, 0x54, 0x01, 0x92, 0xd7, 0x43,
0x16, 0x25, 0xd9, 0xe4, 0x24, 0xf8, 0x94, 0x69, 0xc3, 0x6b, 0x88, 0xb4, 0xed, 0x28, 0x8f, 0x9c,
0xe4, 0x19, 0xd7, 0x65, 0xb6, 0x18, 0x4a, 0xdb, 0x3c, 0xfc, 0xde, 0xc1, 0xea, 0x84, 0x96, 0x37,
0x1d, 0x50, 0x90, 0xac, 0x4a, 0x64, 0x13, 0xda, 0x2c, 0xf6, 0x95, 0x74, 0x09, 0xa5, 0x2d, 0x16,
0xfb, 0x28, 0x1a, 0xc2, 0xaa, 0x7e, 0x7e, 0x4a, 0x38, 0x96, 0x5c, 0x5d, 0x68, 0xed, 0x4b, 0xde,
0xfc, 0x0e, 0xf9, 0xf8, 0x58, 0x6b, 0x3a, 0x2b, 0xea, 0x05, 0x4a, 0x0f, 0xc9, 0x07, 0xd0, 0x93,
0xbb, 0x94, 0x0b, 0xb5, 0x16, 0x5e, 0xa8, 0xcb, 0x62, 0xbf, 0x18, 0xd8, 0xbf, 0x34, 0xe0, 0xc6,
0x05, 0x0a, 0xaf, 0x11, 0x47, 0x8f, 0xa1, 0x7d, 0xc2, 0xc6, 0x72, 0x89, 0xe2, 0x51, 0x6d, 0xf7,
0xb2, 0x37, 0xda, 0x4b, 0x1c, 0xe6, 0x94, 0x0b, 0xd8, 0x3f, 0x36, 0x00, 0x30, 0xa0, 0x71, 0x78,
0x21, 0x58, 0x8c, 0xeb, 0x04, 0x8b, 0x6c, 0x39, 0xe5, 0x75, 0x9f, 0xb1, 0x90, 0x8a, 0xaa, 0x3e,
0x71, 0xed, 0x7b, 0x12, 0xe7, 0x91, 0xa3, 0x44, 0x45, 0xd2, 0xda, 0x3f, 0x37, 0x00, 0xb0, 0xc0,
0xaa, 0x63, 0xcc, 0x5e, 0xb1, 0xc6, 0xd5, 0xdf, 0x8a, 0x8d, 0xe9, 0x94, 0xd8, 0x2f, 0x52, 0x82,
0x23, 0x47, 0xe6, 0x3c, 0x1b, 0x4a, 0x8e, 0x2a, 0xe3, 0x75, 0xd6, 0x28, 0x5e, 0x7e, 0x65, 0x40,
0xaf, 0x46, 0x1f, 0x9f, 0xce, 0x5e, 0x63, 0x36, 0x7b, 0xb1, 0x11, 0x94, 0x11, 0xed, 0xf2, 0x5a,
0x90, 0x47, 0x55, 0x90, 0x6f, 0x42, 0x1b, 0x29, 0xa9, 0x45, 0x79, 0xac, 0xa3, 0xfc, 0x1e, 0xdc,
0xc8, 0x98, 0xc7, 0x62, 0x11, 0x4e, 0xdc, 0x28, 0xf1, 0x83, 0xd3, 0x80, 0xf9, 0x18, 0xeb, 0x6d,
0xa7, 0x5f, 0x08, 0x0e, 0x35, 0x6e, 0xff, 0xc9, 0x80, 0x55, 0xd9, 0x3b, 0x4e, 0x8e, 0x12, 0x9f,
0xa9, 0x93, 0xbd, 0x78, 0x04, 0xbd, 0x87, 0xb6, 0x68, 0x7a, 0x54, 0x08, 0xbd, 0xf1, 0xcf, 0x43,
0x88, 0x3b, 0x6d, 0xae, 0xc3, 0x46, 0x52, 0xac, 0xbe, 0xff, 0x17, 0xa1, 0xb8, 0x72, 0xac, 0xbe,
0x3a, 0x15, 0xc5, 0x3f, 0x32, 0xa0, 0x5b, 0x4b, 0x16, 0x59, 0xf2, 0xf5, 0xfd, 0xa0, 0xae, 0x15,
0x03, 0x8b, 0x60, 0xd7, 0xab, 0x5e, 0xf9, 0xc8, 0x06, 0x2c, 0x45, 0x7c, 0xac, 0x3d, 0xde, 0x73,
0xd4, 0x80, 0x6c, 0x41, 0x3b, 0xe2, 0x63, 0xfc, 0x4c, 0xd2, 0x95, 0xb3, 0x1c, 0x4b, 0xb7, 0x55,
0x9d, 0x8d, 0x2a, 0x20, 0x15, 0x60, 0xff, 0xc6, 0x00, 0xa2, 0x1b, 0x87, 0x97, 0x7a, 0x0a, 0xc6,
0x80, 0xad, 0xbf, 0x54, 0x36, 0xb0, 0x0c, 0x4f, 0x61, 0x33, 0x57, 0x9e, 0x79, 0xe1, 0xca, 0xbb,
0x07, 0x37, 0x7c, 0x76, 0x4a, 0x65, 0x8f, 0x33, 0x7b, 0xe4, 0xbe, 0x16, 0x94, 0xad, 0xd8, 0x5b,
0xef, 0x42, 0xa7, 0xfc, 0x07, 0x86, 0xf4, 0xa1, 0x37, 0x8c, 0x03, 0x81, 0xdf, 0x71, 0x41, 0x3c,
0xee, 0x7f, 0x8e, 0x74, 0xa1, 0xf5, 0x1d, 0x46, 0x43, 0x71, 0x36, 0xe9, 0x1b, 0xa4, 0x07, 0xed,
0xf7, 0x47, 0x71, 0x92, 0x45, 0x34, 0xec, 0x37, 0xf6, 0xdf, 0xf9, 0xc1, 0xd7, 0xc6, 0x81, 0x38,
0xcb, 0x47, 0xd2, 0x92, 0x5d, 0x65, 0xda, 0x97, 0x83, 0x44, 0xff, 0xda, 0x2d, 0xbc, 0xb6, 0x8b,
0xd6, 0x96, 0xc3, 0x74, 0x34, 0x5a, 0x46, 0xe4, 0xed, 0x7f, 0x04, 0x00, 0x00, 0xff, 0xff, 0x1b,
0x58, 0x94, 0x0b, 0xa7, 0x1a, 0x00, 0x00,
// 1958 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0x5b, 0x6f, 0x1c, 0x49,
0x15, 0xa6, 0xa7, 0xc7, 0x9e, 0x99, 0xd3, 0x63, 0x67, 0x52, 0xf1, 0x66, 0xdb, 0x4e, 0x36, 0xf1,
0xf6, 0x2e, 0x60, 0x36, 0x22, 0x0e, 0x5e, 0x60, 0x57, 0x08, 0x91, 0x5d, 0x7b, 0x96, 0x30, 0xca,
0xda, 0x98, 0x76, 0x76, 0x25, 0x78, 0x69, 0xd5, 0x74, 0x97, 0xc7, 0x4d, 0xfa, 0xb6, 0x5d, 0xd5,
0x4e, 0x66, 0x9f, 0x10, 0xe2, 0x09, 0x04, 0x12, 0x48, 0xfc, 0x0d, 0x5e, 0x79, 0xe2, 0x22, 0x9e,
0x90, 0xf8, 0x05, 0xfc, 0x13, 0xc4, 0x13, 0xaa, 0x53, 0xd5, 0x97, 0x19, 0x8f, 0x8d, 0xe3, 0x08,
0x58, 0x04, 0x6f, 0x5d, 0xdf, 0x39, 0x75, 0x39, 0xdf, 0xb9, 0xd4, 0x99, 0x1a, 0x58, 0x0d, 0x13,
0xc1, 0xf2, 0x84, 0x46, 0xf7, 0xb3, 0x3c, 0x15, 0x29, 0x79, 0x25, 0x0e, 0xa3, 0xd3, 0x82, 0xab,
0xd1, 0xfd, 0x52, 0xb8, 0xd1, 0xf7, 0xd3, 0x38, 0x4e, 0x13, 0x05, 0x6f, 0xf4, 0xb9, 0x7f, 0xc2,
0x62, 0xaa, 0x46, 0xce, 0xef, 0x0d, 0x58, 0xd9, 0x4b, 0xe3, 0x2c, 0x4d, 0x58, 0x22, 0x46, 0xc9,
0x71, 0x4a, 0x6e, 0xc2, 0x72, 0x92, 0x06, 0x6c, 0x34, 0xb4, 0x8d, 0x4d, 0x63, 0xcb, 0x74, 0xf5,
0x88, 0x10, 0x68, 0xe7, 0x69, 0xc4, 0xec, 0xd6, 0xa6, 0xb1, 0xd5, 0x73, 0xf1, 0x9b, 0x3c, 0x04,
0xe0, 0x82, 0x0a, 0xe6, 0xf9, 0x69, 0xc0, 0x6c, 0x73, 0xd3, 0xd8, 0x5a, 0xdd, 0xd9, 0xbc, 0xbf,
0xf0, 0x14, 0xf7, 0x8f, 0xa4, 0xe2, 0x5e, 0x1a, 0x30, 0xb7, 0xc7, 0xcb, 0x4f, 0xf2, 0x1e, 0x00,
0x7b, 0x2e, 0x72, 0xea, 0x85, 0xc9, 0x71, 0x6a, 0xb7, 0x37, 0xcd, 0x2d, 0x6b, 0xe7, 0xf5, 0xd9,
0x05, 0xf4, 0xe1, 0x1f, 0xb3, 0xe9, 0xc7, 0x34, 0x2a, 0xd8, 0x21, 0x0d, 0x73, 0xb7, 0x87, 0x93,
0xe4, 0x71, 0x9d, 0xbf, 0x1a, 0x70, 0xad, 0x32, 0x00, 0xf7, 0xe0, 0xe4, 0x1b, 0xb0, 0x84, 0x5b,
0xa0, 0x05, 0xd6, 0xce, 0x9b, 0xe7, 0x9c, 0x68, 0xc6, 0x6e, 0x57, 0x4d, 0x21, 0x1f, 0xc1, 0x0d,
0x5e, 0x8c, 0xfd, 0x52, 0xe4, 0x21, 0xca, 0xed, 0x16, 0x1e, 0xed, 0x72, 0x2b, 0x91, 0xe6, 0x02,
0xfa, 0x48, 0x6f, 0xc3, 0xb2, 0x5c, 0xa9, 0xe0, 0xc8, 0x92, 0xb5, 0x73, 0x6b, 0xa1, 0x91, 0x47,
0xa8, 0xe2, 0x6a, 0x55, 0xe7, 0x16, 0xac, 0x3f, 0x62, 0x62, 0xce, 0x3a, 0x97, 0x7d, 0x52, 0x30,
0x2e, 0xb4, 0xf0, 0x49, 0x18, 0xb3, 0x27, 0xa1, 0xff, 0x74, 0xef, 0x84, 0x26, 0x09, 0x8b, 0x4a,
0xe1, 0x6b, 0x70, 0xeb, 0x11, 0xc3, 0x09, 0x21, 0x17, 0xa1, 0xcf, 0xe7, 0xc4, 0xaf, 0xc0, 0x8d,
0x47, 0x4c, 0x0c, 0x83, 0x39, 0xf8, 0x63, 0xe8, 0x1e, 0x48, 0x67, 0xcb, 0x30, 0xf8, 0x3a, 0x74,
0x68, 0x10, 0xe4, 0x8c, 0x73, 0xcd, 0xe2, 0xed, 0x85, 0x27, 0x7e, 0x5f, 0xe9, 0xb8, 0xa5, 0xf2,
0xa2, 0x30, 0x71, 0x7e, 0x08, 0x30, 0x4a, 0x42, 0x71, 0x48, 0x73, 0x1a, 0xf3, 0x73, 0x03, 0x6c,
0x08, 0x7d, 0x2e, 0x68, 0x2e, 0xbc, 0x0c, 0xf5, 0x34, 0xe5, 0x97, 0x88, 0x06, 0x0b, 0xa7, 0xa9,
0xd5, 0x9d, 0xef, 0x03, 0x1c, 0x89, 0x3c, 0x4c, 0x26, 0x1f, 0x86, 0x5c, 0xc8, 0xbd, 0x4e, 0xa5,
0x9e, 0x34, 0xc2, 0xdc, 0xea, 0xb9, 0x7a, 0xd4, 0x70, 0x47, 0xeb, 0xf2, 0xee, 0x78, 0x08, 0x56,
0x49, 0xf7, 0x3e, 0x9f, 0x90, 0x07, 0xd0, 0x1e, 0x53, 0xce, 0x2e, 0xa4, 0x67, 0x9f, 0x4f, 0x76,
0x29, 0x67, 0x2e, 0x6a, 0x3a, 0x3f, 0x35, 0xe1, 0xd5, 0xbd, 0x9c, 0x61, 0xf0, 0x47, 0x11, 0xf3,
0x45, 0x98, 0x26, 0x9a, 0xfb, 0x17, 0x5f, 0x8d, 0xbc, 0x0a, 0x9d, 0x60, 0xec, 0x25, 0x34, 0x2e,
0xc9, 0x5e, 0x0e, 0xc6, 0x07, 0x34, 0x66, 0xe4, 0x0b, 0xb0, 0xea, 0x57, 0xeb, 0x4b, 0x04, 0x63,
0xae, 0xe7, 0xce, 0xa1, 0xe4, 0x4d, 0x58, 0xc9, 0x68, 0x2e, 0xc2, 0x4a, 0xad, 0x8d, 0x6a, 0xb3,
0xa0, 0x74, 0x68, 0x30, 0x1e, 0x0d, 0xed, 0x25, 0x74, 0x16, 0x7e, 0x13, 0x07, 0xfa, 0xf5, 0x5a,
0xa3, 0xa1, 0xbd, 0x8c, 0xb2, 0x19, 0x8c, 0x6c, 0x82, 0x55, 0x2d, 0x34, 0x1a, 0xda, 0x1d, 0x54,
0x69, 0x42, 0xd2, 0x39, 0xaa, 0x16, 0xd9, 0xdd, 0x4d, 0x63, 0xab, 0xef, 0xea, 0x11, 0x79, 0x00,
0x37, 0x4e, 0xc3, 0x5c, 0x14, 0x34, 0xd2, 0xf1, 0x29, 0xcf, 0xc1, 0xed, 0x1e, 0x7a, 0x70, 0x91,
0x88, 0xec, 0xc0, 0x5a, 0x76, 0x32, 0xe5, 0xa1, 0x3f, 0x37, 0x05, 0x70, 0xca, 0x42, 0x99, 0xf3,
0x27, 0x03, 0x5e, 0x19, 0xe6, 0x69, 0xf6, 0x99, 0x70, 0x45, 0x49, 0x72, 0xfb, 0x02, 0x92, 0x97,
0xce, 0x92, 0xec, 0xfc, 0xbc, 0x05, 0x37, 0x55, 0x44, 0x1d, 0x96, 0xc4, 0xfe, 0x0b, 0xac, 0xf8,
0x22, 0x5c, 0xab, 0x77, 0x55, 0x0a, 0x8b, 0xcd, 0xf8, 0x3c, 0xac, 0x56, 0x0e, 0x56, 0x7a, 0xff,
0xde, 0x90, 0x72, 0x7e, 0xd6, 0x82, 0x35, 0xe9, 0xd4, 0xff, 0xb3, 0x21, 0xd9, 0xf8, 0x43, 0x0b,
0x88, 0x8a, 0x8e, 0x51, 0x12, 0xb0, 0xe7, 0xff, 0x49, 0x2e, 0x5e, 0x03, 0x38, 0x0e, 0x59, 0x14,
0x34, 0x79, 0xe8, 0x21, 0xf2, 0x52, 0x1c, 0xd8, 0xd0, 0xc1, 0x45, 0x2a, 0xfb, 0xcb, 0xa1, 0xbc,
0x4d, 0x54, 0x67, 0xa1, 0x6f, 0x93, 0xee, 0xa5, 0x6f, 0x13, 0x9c, 0xa6, 0x6f, 0x93, 0xdf, 0x98,
0xb0, 0x32, 0x4a, 0x38, 0xcb, 0xc5, 0xff, 0x72, 0x20, 0x91, 0xdb, 0xd0, 0xe3, 0x6c, 0x12, 0xcb,
0x06, 0x67, 0x88, 0xc5, 0xda, 0x74, 0x6b, 0x40, 0x4a, 0x7d, 0x55, 0x59, 0x47, 0x43, 0xbb, 0xa7,
0x5c, 0x5b, 0x01, 0xe4, 0x0e, 0x80, 0x08, 0x63, 0xc6, 0x05, 0x8d, 0x33, 0x55, 0x91, 0xdb, 0x6e,
0x03, 0x91, 0xb7, 0x40, 0x9e, 0x3e, 0x1b, 0x0d, 0xb9, 0x6d, 0x6d, 0x9a, 0xb2, 0x1d, 0x50, 0x23,
0xf2, 0x55, 0xe8, 0xe6, 0xe9, 0x33, 0x2f, 0xa0, 0x82, 0xda, 0x7d, 0x74, 0xde, 0xfa, 0x42, 0xb2,
0x77, 0xa3, 0x74, 0xec, 0x76, 0xf2, 0xf4, 0xd9, 0x90, 0x0a, 0xea, 0xfc, 0xcd, 0x84, 0x95, 0x23,
0x46, 0x73, 0xff, 0xe4, 0xea, 0x0e, 0xfb, 0x12, 0x0c, 0x72, 0xc6, 0x8b, 0x48, 0x78, 0xb5, 0x59,
0xca, 0x73, 0xd7, 0x14, 0xbe, 0x57, 0x19, 0x57, 0x52, 0x6e, 0x5e, 0x40, 0x79, 0x7b, 0x01, 0xe5,
0x0e, 0xf4, 0x1b, 0xfc, 0x72, 0x7b, 0x09, 0x4d, 0x9f, 0xc1, 0xc8, 0x00, 0xcc, 0x80, 0x47, 0xe8,
0xb1, 0x9e, 0x2b, 0x3f, 0xc9, 0x3d, 0xb8, 0x9e, 0x45, 0xd4, 0x67, 0x27, 0x69, 0x14, 0xb0, 0xdc,
0x9b, 0xe4, 0x69, 0x91, 0xa1, 0xbb, 0xfa, 0xee, 0xa0, 0x21, 0x78, 0x24, 0x71, 0xf2, 0x0e, 0x74,
0x03, 0x1e, 0x79, 0x62, 0x9a, 0x31, 0x74, 0xd9, 0xea, 0x39, 0xb6, 0x0f, 0x79, 0xf4, 0x64, 0x9a,
0x31, 0xb7, 0x13, 0xa8, 0x0f, 0xf2, 0x00, 0xd6, 0x38, 0xcb, 0x43, 0x1a, 0x85, 0x9f, 0xb2, 0xc0,
0x63, 0xcf, 0xb3, 0xdc, 0xcb, 0x22, 0x9a, 0xa0, 0x67, 0xfb, 0x2e, 0xa9, 0x65, 0x1f, 0x3c, 0xcf,
0xf2, 0xc3, 0x88, 0x26, 0x64, 0x0b, 0x06, 0x69, 0x21, 0xb2, 0x42, 0x78, 0x98, 0x7d, 0xdc, 0x0b,
0x03, 0x74, 0xb4, 0xe9, 0xae, 0x2a, 0xfc, 0xdb, 0x08, 0x8f, 0x02, 0x49, 0xad, 0xc8, 0xe9, 0x29,
0x8b, 0xbc, 0x2a, 0x02, 0x6c, 0x6b, 0xd3, 0xd8, 0x6a, 0xbb, 0xd7, 0x14, 0xfe, 0xa4, 0x84, 0xc9,
0x36, 0xdc, 0x98, 0x14, 0x34, 0xa7, 0x89, 0x60, 0xac, 0xa1, 0xdd, 0x47, 0x6d, 0x52, 0x89, 0xaa,
0x09, 0xce, 0x2f, 0xdb, 0xb5, 0xeb, 0xa5, 0x97, 0xf8, 0x15, 0x5c, 0x7f, 0x95, 0xbe, 0x70, 0x61,
0xbc, 0x98, 0x8b, 0xe3, 0xe5, 0x2e, 0x58, 0x31, 0x13, 0x79, 0xe8, 0x2b, 0xbf, 0xa8, 0x34, 0x06,
0x05, 0x21, 0xf9, 0x77, 0xc1, 0x4a, 0x8a, 0xd8, 0xfb, 0xa4, 0x60, 0x79, 0xc8, 0xb8, 0x4e, 0x65,
0x48, 0x8a, 0xf8, 0x7b, 0x0a, 0x21, 0x37, 0x60, 0x49, 0xa4, 0x99, 0xf7, 0x54, 0x67, 0x72, 0x5b,
0xa4, 0xd9, 0x63, 0xf2, 0x4d, 0xd8, 0xe0, 0x8c, 0x46, 0x2c, 0xf0, 0xaa, 0xac, 0xe4, 0x1e, 0x47,
0x2e, 0x58, 0x60, 0x77, 0xd0, 0x15, 0xb6, 0xd2, 0x38, 0xaa, 0x14, 0x8e, 0xb4, 0x5c, 0x32, 0x5d,
0x1d, 0xbc, 0x31, 0xad, 0x8b, 0xcd, 0x13, 0xa9, 0x45, 0xd5, 0x84, 0x77, 0xc1, 0x9e, 0x44, 0xe9,
0x98, 0x46, 0xde, 0x99, 0x5d, 0xb1, 0x4b, 0x33, 0xdd, 0x9b, 0x4a, 0x7e, 0x34, 0xb7, 0xa5, 0x34,
0x8f, 0x47, 0xa1, 0xcf, 0x02, 0x6f, 0x1c, 0xa5, 0x63, 0x1b, 0x30, 0xa4, 0x40, 0x41, 0x32, 0x91,
0x65, 0x28, 0x69, 0x05, 0x49, 0x83, 0x9f, 0x16, 0x89, 0xc0, 0x00, 0x31, 0xdd, 0x55, 0x85, 0x1f,
0x14, 0xf1, 0x9e, 0x44, 0xc9, 0x1b, 0xb0, 0xa2, 0x35, 0xd3, 0xe3, 0x63, 0xce, 0x04, 0x46, 0x86,
0xe9, 0xf6, 0x15, 0xf8, 0x5d, 0xc4, 0x9c, 0x1f, 0x9b, 0x70, 0xcd, 0x95, 0xec, 0xb2, 0x53, 0xf6,
0x5f, 0x5f, 0x10, 0xce, 0x4b, 0xcc, 0xe5, 0x17, 0x4a, 0xcc, 0xce, 0xa5, 0x13, 0xb3, 0xfb, 0x42,
0x89, 0xd9, 0x3b, 0x37, 0x31, 0x7f, 0x37, 0xe3, 0x84, 0xcf, 0x6a, 0x6a, 0xbe, 0x05, 0x66, 0x18,
0x70, 0x74, 0x8e, 0xb5, 0x63, 0xcf, 0x2e, 0xae, 0x9f, 0x4c, 0x46, 0x43, 0xee, 0x4a, 0x25, 0xf2,
0x10, 0x2c, 0x4d, 0x28, 0x5e, 0x4f, 0x4b, 0x78, 0x3d, 0xdd, 0x59, 0x38, 0x07, 0x19, 0x96, 0x57,
0x93, 0xab, 0x1a, 0x20, 0x2e, 0xbf, 0xc9, 0xb7, 0xe0, 0xd6, 0xd9, 0x84, 0xcd, 0x35, 0x47, 0x81,
0xbd, 0x8c, 0x3e, 0x5a, 0x9f, 0xcf, 0xd8, 0x92, 0xc4, 0x80, 0x7c, 0x05, 0xd6, 0x1a, 0x29, 0x5b,
0x4f, 0xec, 0xa8, 0xdf, 0x48, 0xb5, 0xac, 0x9e, 0x72, 0x51, 0xd2, 0x76, 0x2f, 0x4a, 0x5a, 0xe7,
0x2f, 0x06, 0xac, 0x0c, 0x59, 0xc4, 0xc4, 0x4b, 0xa4, 0xd0, 0x82, 0x5e, 0xa7, 0xb5, 0xb0, 0xd7,
0x99, 0x69, 0x26, 0xcc, 0x8b, 0x9b, 0x89, 0xf6, 0x99, 0x66, 0xe2, 0x75, 0xe8, 0x67, 0x79, 0x18,
0xd3, 0x7c, 0xea, 0x3d, 0x65, 0xd3, 0x32, 0x8d, 0x2c, 0x8d, 0x3d, 0x66, 0x53, 0xee, 0x24, 0xb0,
0xf1, 0x61, 0x4a, 0x83, 0x5d, 0x1a, 0xd1, 0xc4, 0x67, 0xda, 0x4c, 0x7e, 0x75, 0xcb, 0xee, 0x00,
0x34, 0x98, 0x6c, 0xe1, 0x86, 0x0d, 0xc4, 0xf9, 0xbb, 0x01, 0x3d, 0xb9, 0x21, 0xb6, 0xe0, 0x57,
0x58, 0x7f, 0xa6, 0xf7, 0x6a, 0x2d, 0xe8, 0xbd, 0xaa, 0x2e, 0xba, 0xa4, 0xab, 0x6e, 0xab, 0x1b,
0xed, 0x71, 0x7b, 0xb6, 0x3d, 0xbe, 0x0b, 0x56, 0x28, 0x0f, 0xe4, 0x65, 0x54, 0x9c, 0x28, 0x9e,
0x7a, 0x2e, 0x20, 0x74, 0x28, 0x11, 0xd9, 0x3f, 0x97, 0x0a, 0xd8, 0x3f, 0x2f, 0x5f, 0xba, 0x7f,
0xd6, 0x8b, 0x60, 0xff, 0xfc, 0xc7, 0x16, 0xd8, 0x9a, 0xe2, 0xfa, 0x31, 0xea, 0xa3, 0x2c, 0xc0,
0x37, 0xb1, 0xdb, 0xd0, 0xab, 0xa2, 0x4c, 0xbf, 0x05, 0xd5, 0x80, 0xe4, 0x75, 0x9f, 0xc5, 0x69,
0x3e, 0x3d, 0x0a, 0x3f, 0x65, 0xda, 0xf0, 0x06, 0x22, 0x6d, 0x3b, 0x28, 0x62, 0x37, 0x7d, 0xc6,
0x75, 0xb1, 0x2d, 0x87, 0xd2, 0x36, 0x1f, 0x7f, 0xf5, 0x60, 0x75, 0x42, 0xcb, 0xdb, 0x2e, 0x28,
0x48, 0x56, 0x25, 0xb2, 0x0e, 0x5d, 0x96, 0x04, 0x4a, 0xba, 0x84, 0xd2, 0x0e, 0x4b, 0x02, 0x14,
0x8d, 0x60, 0x55, 0x3f, 0x42, 0xa5, 0x1c, 0x0b, 0x2f, 0x56, 0x57, 0x6b, 0xc7, 0x39, 0xe7, 0xe5,
0x6f, 0x9f, 0x4f, 0x0e, 0xb5, 0xa6, 0xbb, 0xa2, 0xde, 0xa1, 0xf4, 0x90, 0x7c, 0x00, 0x7d, 0xb9,
0x4b, 0xb5, 0x50, 0xe7, 0xd2, 0x0b, 0x59, 0x2c, 0x09, 0xca, 0x81, 0xf3, 0x2b, 0x03, 0xae, 0x9f,
0xa1, 0xf0, 0x0a, 0x71, 0xf4, 0x18, 0xba, 0x47, 0x6c, 0x22, 0x97, 0x28, 0x9f, 0xd6, 0xb6, 0xcf,
0x7b, 0xa9, 0x3d, 0xc7, 0x61, 0x6e, 0xb5, 0x80, 0xf3, 0x13, 0x03, 0x00, 0x03, 0x1a, 0x87, 0x67,
0x82, 0xc5, 0xb8, 0x4a, 0xb0, 0xc8, 0xfb, 0x4d, 0x5e, 0xfa, 0x39, 0x8b, 0xa8, 0xa8, 0xeb, 0x13,
0xd7, 0xbe, 0x27, 0x49, 0x11, 0xbb, 0x4a, 0x54, 0x26, 0xad, 0xf3, 0x0b, 0x03, 0x00, 0x0b, 0xac,
0x3a, 0xc6, 0xfc, 0x45, 0x6b, 0x5c, 0xfc, 0x8b, 0xb1, 0x35, 0x9b, 0x12, 0xbb, 0x65, 0x4a, 0x70,
0xe4, 0xc8, 0x5c, 0x64, 0x43, 0xc5, 0x51, 0x6d, 0xbc, 0xce, 0x1a, 0xc5, 0xcb, 0xaf, 0x0d, 0xe8,
0x37, 0xe8, 0xe3, 0xb3, 0xd9, 0x6b, 0xcc, 0x67, 0x2f, 0xb6, 0x83, 0x32, 0xa2, 0x3d, 0xde, 0x08,
0xf2, 0xb8, 0x0e, 0xf2, 0x75, 0xe8, 0x22, 0x25, 0x8d, 0x28, 0x4f, 0x74, 0x94, 0xdf, 0x83, 0xeb,
0x39, 0xf3, 0x59, 0x22, 0xa2, 0xa9, 0x17, 0xa7, 0x41, 0x78, 0x1c, 0xb2, 0x00, 0x63, 0xbd, 0xeb,
0x0e, 0x4a, 0xc1, 0xbe, 0xc6, 0x9d, 0x3f, 0x1b, 0xb0, 0x2a, 0x3b, 0xc8, 0xe9, 0x41, 0x1a, 0x30,
0x75, 0xb2, 0x17, 0x8f, 0xa0, 0xf7, 0xd0, 0x16, 0x4d, 0x8f, 0x0a, 0xa1, 0x37, 0xfe, 0x79, 0x08,
0x71, 0xb7, 0xcb, 0x75, 0xd8, 0x48, 0x8a, 0xd5, 0x2b, 0xc0, 0x65, 0x28, 0xae, 0x1d, 0xab, 0xaf,
0x4e, 0x45, 0xf1, 0x8f, 0x0c, 0xb0, 0x1a, 0xc9, 0x22, 0x4b, 0xbe, 0xbe, 0x1f, 0xd4, 0xb5, 0x62,
0x60, 0x11, 0xb4, 0xfc, 0xfa, 0xad, 0x8f, 0xac, 0xc1, 0x52, 0xcc, 0x27, 0xda, 0xe3, 0x7d, 0x57,
0x0d, 0xc8, 0x06, 0x74, 0x63, 0x3e, 0xc1, 0x1f, 0x4b, 0xba, 0x72, 0x56, 0x63, 0xe9, 0xb6, 0xba,
0xb3, 0x51, 0x05, 0xa4, 0x06, 0x9c, 0xdf, 0x1a, 0x40, 0x74, 0xe3, 0xf0, 0x52, 0x0f, 0xc2, 0x18,
0xb0, 0xcd, 0xf7, 0xca, 0x16, 0x96, 0xe1, 0x19, 0x6c, 0xee, 0xca, 0x33, 0xcf, 0x5c, 0x79, 0xf7,
0xe0, 0x7a, 0xc0, 0x8e, 0xa9, 0xec, 0x71, 0xe6, 0x8f, 0x3c, 0xd0, 0x82, 0xaa, 0x15, 0x7b, 0xeb,
0x5d, 0xe8, 0x55, 0xff, 0xc3, 0x90, 0x01, 0xf4, 0x47, 0x49, 0x28, 0xb0, 0x69, 0x0c, 0x93, 0xc9,
0xe0, 0x73, 0xc4, 0x82, 0xce, 0x77, 0x18, 0x8d, 0xc4, 0xc9, 0x74, 0x60, 0x90, 0x3e, 0x74, 0xdf,
0x1f, 0x27, 0x69, 0x1e, 0xd3, 0x68, 0xd0, 0xda, 0x7d, 0xe7, 0x07, 0x5f, 0x9b, 0x84, 0xe2, 0xa4,
0x18, 0x4b, 0x4b, 0xb6, 0x95, 0x69, 0x5f, 0x0e, 0x53, 0xfd, 0xb5, 0x5d, 0x7a, 0x6d, 0x1b, 0xad,
0xad, 0x86, 0xd9, 0x78, 0xbc, 0x8c, 0xc8, 0xdb, 0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0x99, 0x69,
0x35, 0xab, 0xad, 0x1a, 0x00, 0x00,
}

3
internal/proto/plan.proto
View File

@ -102,6 +102,7 @@ message VectorANNS {
message PlanNode {
oneof node {
VectorANNS vector_anns = 1;
Expr predicates = 2;
}
repeated int64 output_field_ids = 2;
repeated int64 output_field_ids = 3;
}

148
internal/proto/planpb/plan.pb.go
View File

@ -871,8 +871,9 @@ func (m *VectorANNS) GetPlaceholderTag() string {
type PlanNode struct {
// Types that are valid to be assigned to Node:
// *PlanNode_VectorAnns
// *PlanNode_Predicates
Node isPlanNode_Node `protobuf_oneof:"node"`
OutputFieldIds []int64 `protobuf:"varint,2,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"`
OutputFieldIds []int64 `protobuf:"varint,3,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -911,8 +912,14 @@ type PlanNode_VectorAnns struct {
VectorAnns *VectorANNS `protobuf:"bytes,1,opt,name=vector_anns,json=vectorAnns,proto3,oneof"`
}
type PlanNode_Predicates struct {
Predicates *Expr `protobuf:"bytes,2,opt,name=predicates,proto3,oneof"`
}
func (*PlanNode_VectorAnns) isPlanNode_Node() {}
func (*PlanNode_Predicates) isPlanNode_Node() {}
func (m *PlanNode) GetNode() isPlanNode_Node {
if m != nil {
return m.Node
@ -927,6 +934,13 @@ func (m *PlanNode) GetVectorAnns() *VectorANNS {
return nil
}
func (m *PlanNode) GetPredicates() *Expr {
if x, ok := m.GetNode().(*PlanNode_Predicates); ok {
return x.Predicates
}
return nil
}
func (m *PlanNode) GetOutputFieldIds() []int64 {
if m != nil {
return m.OutputFieldIds
@ -938,6 +952,7 @@ func (m *PlanNode) GetOutputFieldIds() []int64 {
func (*PlanNode) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*PlanNode_VectorAnns)(nil),
(*PlanNode_Predicates)(nil),
}
}
@ -962,71 +977,72 @@ func init() {
func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
var fileDescriptor_2d655ab2f7683c23 = []byte{
// 1055 bytes of a gzipped FileDescriptorProto
// 1067 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x72, 0xdb, 0x44,
0x14, 0xb6, 0x2c, 0xdb, 0x91, 0x8e, 0x5c, 0xdb, 0xd1, 0x0d, 0x29, 0xa1, 0x24, 0x88, 0x0e, 0x0d,
0x30, 0x4d, 0x86, 0xb6, 0xa4, 0x33, 0x65, 0x60, 0xf2, 0xd3, 0x12, 0x7b, 0x28, 0x49, 0x10, 0x21,
0x17, 0xdc, 0x68, 0xd6, 0xd2, 0xc6, 0xde, 0xe9, 0x5a, 0xab, 0xac, 0x56, 0xa6, 0xbe, 0xe1, 0x86,
0x27, 0xe0, 0x25, 0xe0, 0x1a, 0x9e, 0x83, 0x07, 0xe0, 0x9e, 0x17, 0x61, 0xf6, 0xac, 0xe2, 0x9f,
0x8e, 0xd3, 0xa6, 0x33, 0xbd, 0x5b, 0x9d, 0x3d, 0x7f, 0xdf, 0x77, 0x7e, 0x56, 0x00, 0x19, 0x27,
0xe9, 0x76, 0x26, 0x85, 0x12, 0xfe, 0xea, 0x88, 0xf1, 0x71, 0x91, 0x9b, 0xaf, 0x6d, 0x7d, 0xf1,
0x7e, 0x33, 0x8f, 0x87, 0x74, 0x44, 0x8c, 0x28, 0xc8, 0xa0, 0x79, 0x44, 0x53, 0x2a, 0x59, 0x7c,
0x4e, 0x78, 0x41, 0xfd, 0x75, 0x70, 0xfa, 0x42, 0xf0, 0x68, 0x4c, 0xf8, 0x9a, 0xb5, 0x69, 0x6d,
0x39, 0xdd, 0x4a, 0xb8, 0xa2, 0x25, 0xe7, 0x84, 0xfb, 0x77, 0xc0, 0x65, 0xa9, 0xda, 0x7d, 0x84,
0xb7, 0xd5, 0x4d, 0x6b, 0xcb, 0xee, 0x56, 0x42, 0x07, 0x45, 0xe5, 0xf5, 0x05, 0x17, 0x44, 0xe1,
0xb5, 0xbd, 0x69, 0x6d, 0x59, 0xfa, 0x1a, 0x45, 0xe7, 0x84, 0x1f, 0xd4, 0xc1, 0x1e, 0x13, 0x1e,
0x50, 0x70, 0x7f, 0x28, 0xa8, 0x9c, 0xf4, 0xd2, 0x0b, 0xe1, 0xfb, 0x50, 0x53, 0x22, 0x7b, 0x81,
0xa1, 0xec, 0x10, 0xcf, 0xfe, 0x06, 0x78, 0x23, 0xaa, 0x24, 0x8b, 0x23, 0x35, 0xc9, 0x28, 0x3a,
0x72, 0x43, 0x30, 0xa2, 0xb3, 0x49, 0x46, 0xfd, 0x8f, 0xe1, 0x56, 0x4e, 0x89, 0x8c, 0x87, 0x51,
0x46, 0x24, 0x19, 0xe5, 0x6b, 0x35, 0x54, 0x69, 0x1a, 0xe1, 0x29, 0xca, 0x82, 0x3f, 0x2c, 0x80,
0x43, 0xc1, 0x8b, 0x51, 0x8a, 0x81, 0x6e, 0x83, 0x73, 0xc1, 0x28, 0x4f, 0x22, 0x96, 0x94, 0xc1,
0x56, 0xf0, 0xbb, 0x97, 0xf8, 0x4f, 0xc0, 0x4d, 0x88, 0x22, 0x26, 0x9a, 0x46, 0xd5, 0x7a, 0x70,
0x67, 0x7b, 0x81, 0xb7, 0x92, 0xb1, 0xa7, 0x44, 0x11, 0x9d, 0x40, 0xe8, 0x24, 0xe5, 0xc9, 0xbf,
0x0b, 0x2d, 0x96, 0x47, 0x99, 0x64, 0x23, 0x22, 0x27, 0xd1, 0x0b, 0x3a, 0xc1, 0x74, 0x9d, 0xb0,
0xc9, 0xf2, 0x53, 0x23, 0xfc, 0x8e, 0x4e, 0xfc, 0x75, 0x70, 0x59, 0x1e, 0x91, 0x42, 0x89, 0xde,
0x53, 0x4c, 0xd6, 0x09, 0x1d, 0x96, 0xef, 0xe3, 0x77, 0xf0, 0xb7, 0x05, 0xad, 0x9f, 0x52, 0x22,
0x27, 0x21, 0x49, 0x07, 0xf4, 0xd9, 0xcb, 0x4c, 0xfa, 0xdf, 0x80, 0x17, 0x63, 0xea, 0x11, 0x4b,
0x2f, 0x04, 0xe6, 0xeb, 0xbd, 0x9a, 0x13, 0x16, 0x79, 0x06, 0x30, 0x84, 0x78, 0x06, 0xf6, 0x53,
0xa8, 0x8a, 0xac, 0x84, 0x72, 0x7b, 0x89, 0xd9, 0x49, 0x86, 0x30, 0xaa, 0x22, 0xf3, 0xbf, 0x84,
0xfa, 0x58, 0x17, 0x1e, 0xf3, 0xf6, 0x1e, 0x6c, 0x2c, 0xd1, 0x9e, 0xef, 0x8f, 0xd0, 0x68, 0x07,
0x7f, 0x56, 0xa1, 0x7d, 0xc0, 0xde, 0x6d, 0xd6, 0xf7, 0xa0, 0xcd, 0xc5, 0x2f, 0x54, 0x46, 0x2c,
0x8d, 0x79, 0x91, 0xb3, 0xb1, 0xa9, 0x86, 0x13, 0xb6, 0x50, 0xdc, 0xbb, 0x92, 0x6a, 0xc5, 0x22,
0xcb, 0x16, 0x14, 0x0d, 0xeb, 0x2d, 0x14, 0xcf, 0x14, 0xf7, 0xc0, 0x33, 0x1e, 0x0d, 0xc4, 0xda,
0xcd, 0x20, 0x02, 0xda, 0x98, 0x71, 0xd8, 0x03, 0xcf, 0x84, 0x32, 0x1e, 0xea, 0x37, 0xf4, 0x80,
0x36, 0x78, 0x0e, 0xfe, 0xb1, 0xc0, 0x3b, 0x14, 0xa3, 0x8c, 0x48, 0xc3, 0xd2, 0x11, 0x74, 0x38,
0xbd, 0x50, 0xd1, 0x5b, 0x53, 0xd5, 0xd2, 0x66, 0x73, 0x1d, 0xdd, 0x83, 0x55, 0xc9, 0x06, 0xc3,
0x45, 0x4f, 0xd5, 0x9b, 0x78, 0x6a, 0xa3, 0xdd, 0xe1, 0xab, 0xfd, 0x62, 0xdf, 0xa0, 0x5f, 0x82,
0xdf, 0x2c, 0x70, 0xce, 0xa8, 0x1c, 0xbd, 0x93, 0x8a, 0x3f, 0x86, 0x06, 0xf2, 0x9a, 0xaf, 0x55,
0x37, 0xed, 0x9b, 0x10, 0x5b, 0xaa, 0x07, 0xbf, 0x5b, 0xe0, 0xe2, 0xcc, 0x60, 0x1a, 0x8f, 0x30,
0x7d, 0x0b, 0xd3, 0xbf, 0xbb, 0xc4, 0xc5, 0x54, 0xd3, 0x9c, 0x4e, 0x32, 0xec, 0xfc, 0xfb, 0x50,
0x8f, 0x87, 0x8c, 0x27, 0x25, 0x67, 0xef, 0x2d, 0x31, 0xd4, 0x36, 0xa1, 0xd1, 0x0a, 0x36, 0x60,
0x14, 0xb6, 0x2c, 0xdb, 0x91, 0x8e, 0x5c, 0xdb, 0xd5, 0x0d, 0x29, 0xa1, 0x24, 0x88, 0x0e, 0x0d,
0x30, 0x4d, 0x86, 0xb6, 0xa4, 0x43, 0x19, 0x98, 0xfc, 0xb4, 0xc4, 0x1e, 0x4a, 0x12, 0x44, 0xc8,
0x05, 0x37, 0x9a, 0xb5, 0xb4, 0xb1, 0x77, 0xba, 0xd6, 0x2a, 0xab, 0x95, 0xa9, 0xaf, 0x79, 0x02,
0x5e, 0x02, 0xae, 0xe1, 0x8e, 0x77, 0xe0, 0x01, 0xb8, 0xe7, 0x45, 0x98, 0x3d, 0xab, 0xf8, 0xa7,
0xe3, 0xa4, 0x61, 0xa6, 0x77, 0xab, 0xb3, 0xe7, 0xef, 0xfb, 0xce, 0xcf, 0x0a, 0x20, 0xe3, 0x24,
0xdd, 0xca, 0xa4, 0x50, 0xc2, 0xbf, 0x3d, 0x62, 0x7c, 0x5c, 0xe4, 0xe6, 0x6b, 0x4b, 0x5f, 0xbc,
0xdb, 0xcc, 0xe3, 0x21, 0x1d, 0x11, 0x23, 0x0a, 0x32, 0x68, 0x1e, 0xd2, 0x94, 0x4a, 0x16, 0x9f,
0x11, 0x5e, 0x50, 0x7f, 0x0d, 0x9c, 0xbe, 0x10, 0x3c, 0x1a, 0x13, 0xbe, 0x6a, 0x6d, 0x58, 0x9b,
0x4e, 0xb7, 0x12, 0xae, 0x68, 0xc9, 0x19, 0xe1, 0xfe, 0x5d, 0x70, 0x59, 0xaa, 0x76, 0x1e, 0xe3,
0x6d, 0x75, 0xc3, 0xda, 0xb4, 0xbb, 0x95, 0xd0, 0x41, 0x51, 0x79, 0x7d, 0xce, 0x05, 0x51, 0x78,
0x6d, 0x6f, 0x58, 0x9b, 0x96, 0xbe, 0x46, 0xd1, 0x19, 0xe1, 0xfb, 0x75, 0xb0, 0xc7, 0x84, 0x07,
0x14, 0xdc, 0xef, 0x0b, 0x2a, 0x27, 0xbd, 0xf4, 0x5c, 0xf8, 0x3e, 0xd4, 0x94, 0xc8, 0x5e, 0x62,
0x28, 0x3b, 0xc4, 0xb3, 0xbf, 0x0e, 0xde, 0x88, 0x2a, 0xc9, 0xe2, 0x48, 0x4d, 0x32, 0x8a, 0x8e,
0xdc, 0x10, 0x8c, 0xe8, 0x74, 0x92, 0x51, 0xff, 0x43, 0xb8, 0x95, 0x53, 0x22, 0xe3, 0x61, 0x94,
0x11, 0x49, 0x46, 0xf9, 0x6a, 0x0d, 0x55, 0x9a, 0x46, 0x78, 0x82, 0xb2, 0xe0, 0x37, 0x0b, 0xe0,
0x40, 0xf0, 0x62, 0x94, 0x62, 0xa0, 0x3b, 0xe0, 0x9c, 0x33, 0xca, 0x93, 0x88, 0x25, 0x65, 0xb0,
0x15, 0xfc, 0xee, 0x25, 0xfe, 0x53, 0x70, 0x13, 0xa2, 0x88, 0x89, 0xa6, 0x51, 0xb5, 0x1e, 0xde,
0xdd, 0x5a, 0xe0, 0xad, 0x64, 0xec, 0x19, 0x51, 0x44, 0x27, 0x10, 0x3a, 0x49, 0x79, 0xf2, 0xef,
0x41, 0x8b, 0xe5, 0x51, 0x26, 0xd9, 0x88, 0xc8, 0x49, 0xf4, 0x92, 0x4e, 0x30, 0x5d, 0x27, 0x6c,
0xb2, 0xfc, 0xc4, 0x08, 0xbf, 0xa5, 0x13, 0x7f, 0x0d, 0x5c, 0x96, 0x47, 0xa4, 0x50, 0xa2, 0xf7,
0x0c, 0x93, 0x75, 0x42, 0x87, 0xe5, 0x7b, 0xf8, 0x1d, 0xfc, 0x69, 0x41, 0xeb, 0xc7, 0x94, 0xc8,
0x49, 0x48, 0xd2, 0x01, 0x7d, 0xfe, 0x2a, 0x93, 0xfe, 0xd7, 0xe0, 0xc5, 0x98, 0x7a, 0xc4, 0xd2,
0x73, 0x81, 0xf9, 0x7a, 0xaf, 0xe7, 0x84, 0x45, 0x9e, 0x01, 0x0c, 0x21, 0x9e, 0x81, 0xfd, 0x18,
0xaa, 0x22, 0x2b, 0xa1, 0xdc, 0x59, 0x62, 0x76, 0x9c, 0x21, 0x8c, 0xaa, 0xc8, 0xfc, 0xcf, 0xa1,
0x3e, 0xd6, 0x85, 0xc7, 0xbc, 0xbd, 0x87, 0xeb, 0x4b, 0xb4, 0xe7, 0xfb, 0x23, 0x34, 0xda, 0xc1,
0xef, 0x55, 0x68, 0xef, 0xb3, 0xb7, 0x9b, 0xf5, 0x7d, 0x68, 0x73, 0xf1, 0x33, 0x95, 0x11, 0x4b,
0x63, 0x5e, 0xe4, 0x6c, 0x6c, 0xaa, 0xe1, 0x84, 0x2d, 0x14, 0xf7, 0x2e, 0xa5, 0x5a, 0xb1, 0xc8,
0xb2, 0x05, 0x45, 0xc3, 0x7a, 0x0b, 0xc5, 0x33, 0xc5, 0x5d, 0xf0, 0x8c, 0x47, 0x03, 0xb1, 0x76,
0x33, 0x88, 0x80, 0x36, 0x66, 0x1c, 0x76, 0xc1, 0x33, 0xa1, 0x8c, 0x87, 0xfa, 0x0d, 0x3d, 0xa0,
0x0d, 0x9e, 0x83, 0xbf, 0x2d, 0xf0, 0x0e, 0xc4, 0x28, 0x23, 0xd2, 0xb0, 0x74, 0x08, 0x1d, 0x4e,
0xcf, 0x55, 0xf4, 0xbf, 0xa9, 0x6a, 0x69, 0xb3, 0xb9, 0x8e, 0xee, 0xc1, 0x6d, 0xc9, 0x06, 0xc3,
0x45, 0x4f, 0xd5, 0x9b, 0x78, 0x6a, 0xa3, 0xdd, 0xc1, 0xeb, 0xfd, 0x62, 0xdf, 0xa0, 0x5f, 0x82,
0x5f, 0x2c, 0x70, 0x4e, 0xa9, 0x1c, 0xbd, 0x95, 0x8a, 0x3f, 0x81, 0x06, 0xf2, 0x9a, 0xaf, 0x56,
0x37, 0xec, 0x9b, 0x10, 0x5b, 0xaa, 0x07, 0xbf, 0x5a, 0xe0, 0xe2, 0xcc, 0x60, 0x1a, 0x8f, 0x31,
0x7d, 0x0b, 0xd3, 0xbf, 0xb7, 0xc4, 0xc5, 0x54, 0xd3, 0x9c, 0x8e, 0x33, 0xec, 0xfc, 0x07, 0x50,
0x8f, 0x87, 0x8c, 0x27, 0x25, 0x67, 0xef, 0x2c, 0x31, 0xd4, 0x36, 0xa1, 0xd1, 0x0a, 0xd6, 0x61,
0xa5, 0xb4, 0xf6, 0x3d, 0x58, 0xe9, 0xa5, 0x63, 0xc2, 0x59, 0xd2, 0xa9, 0xf8, 0x2b, 0x60, 0x1f,
0x0b, 0xd5, 0xb1, 0x82, 0x7f, 0x2d, 0x00, 0x33, 0x12, 0x98, 0xd4, 0xee, 0x5c, 0x52, 0x9f, 0x2c,
0xf1, 0x3d, 0x53, 0x2d, 0x8f, 0x65, 0x5a, 0x9f, 0x43, 0x4d, 0x17, 0xfa, 0x4d, 0x59, 0xa1, 0x92,
0xc6, 0x80, 0xb5, 0x2c, 0xa7, 0xf7, 0x7a, 0x0c, 0xa8, 0x15, 0xec, 0x82, 0x73, 0x15, 0x6b, 0x11,
0x44, 0x0b, 0xe0, 0xb9, 0x18, 0xb0, 0x98, 0xf0, 0xfd, 0x34, 0xe9, 0x58, 0xfe, 0x2d, 0x70, 0xcb,
0xef, 0x13, 0xd9, 0xa9, 0x06, 0x7f, 0xd9, 0x50, 0x43, 0x50, 0x4f, 0xc0, 0x55, 0x54, 0x8e, 0x22,
0xfa, 0x32, 0x93, 0x65, 0xb9, 0xd7, 0x97, 0xc4, 0xbc, 0x6a, 0x10, 0xbd, 0xfe, 0xd5, 0x55, 0xb3,
0x7c, 0x0d, 0x50, 0xe8, 0xd8, 0xc6, 0xd8, 0xc0, 0xfb, 0xe0, 0x75, 0xd5, 0xea, 0x56, 0x42, 0xb7,
0x98, 0xf2, 0xb9, 0x07, 0x5e, 0x9f, 0xcd, 0xec, 0xed, 0x6b, 0x7b, 0x6d, 0x46, 0x6c, 0xb7, 0x12,
0x42, 0x7f, 0x56, 0x91, 0x43, 0x68, 0xc6, 0x66, 0x10, 0x8d, 0x0b, 0xb3, 0x0e, 0x3e, 0x5c, 0xda,
0xae, 0xd3, 0x79, 0xed, 0x56, 0x42, 0x2f, 0x9e, 0x1b, 0xdf, 0xef, 0xa1, 0x63, 0x50, 0x48, 0xbd,
0xf7, 0x8c, 0x23, 0xb3, 0x15, 0x3e, 0xba, 0x0e, 0xcb, 0x74, 0x43, 0x76, 0x2b, 0x61, 0xab, 0x58,
0xdc, 0x99, 0xa7, 0xb0, 0x5a, 0xa2, 0x9a, 0xf3, 0xd7, 0x40, 0x7f, 0xc1, 0xb5, 0xd8, 0xe6, 0x1d,
0xb6, 0xfb, 0x8b, 0xa2, 0x83, 0x06, 0xd4, 0xb4, 0x93, 0xe0, 0x3f, 0x0b, 0xe0, 0x9c, 0xc6, 0x4a,
0xc8, 0xfd, 0xe3, 0xe3, 0x1f, 0xcb, 0x27, 0xc8, 0x28, 0x9b, 0x87, 0x5d, 0x3f, 0x41, 0xc6, 0xdf,
0xc2, 0xe3, 0x58, 0x5d, 0x7c, 0x1c, 0x1f, 0x03, 0x64, 0x92, 0x26, 0x2c, 0x26, 0x8a, 0xe6, 0x6f,
0x6a, 0xb3, 0x39, 0x55, 0xff, 0x2b, 0x80, 0x4b, 0xfd, 0xcc, 0x9b, 0xd5, 0x50, 0xbb, 0xb6, 0xdc,
0xd3, 0x7f, 0x81, 0xd0, 0xbd, 0x9c, 0xfe, 0x16, 0xdc, 0x83, 0x76, 0xc6, 0x49, 0x4c, 0x87, 0x82,
0x27, 0x54, 0x46, 0x8a, 0x0c, 0x90, 0x64, 0x37, 0x6c, 0xcd, 0x89, 0xcf, 0xc8, 0x20, 0xf8, 0x15,
0x9c, 0x53, 0x4e, 0xd2, 0x63, 0x91, 0xe0, 0xae, 0x1e, 0x23, 0xe0, 0x88, 0xa4, 0x69, 0xfe, 0x9a,
0x6d, 0x34, 0xa3, 0x45, 0x77, 0x88, 0xb1, 0xd9, 0x4f, 0xd3, 0xdc, 0xdf, 0x82, 0x8e, 0x28, 0x54,
0x56, 0xa8, 0xe8, 0x8a, 0x0e, 0xb3, 0x99, 0xec, 0xb0, 0x65, 0xe4, 0xdf, 0x1a, 0x56, 0x72, 0xcd,
0x72, 0x2a, 0x12, 0xfa, 0x59, 0x0a, 0x0d, 0xb3, 0x1c, 0x17, 0xe7, 0xa9, 0x0d, 0xde, 0x91, 0xa4,
0x44, 0x51, 0x79, 0x36, 0x24, 0x69, 0xc7, 0xf2, 0x3b, 0xd0, 0x2c, 0x05, 0xcf, 0x2e, 0x0b, 0xc2,
0x3b, 0x55, 0xbf, 0x09, 0xce, 0x73, 0x9a, 0xe7, 0x78, 0x6f, 0xe3, 0xc0, 0xd1, 0x3c, 0x37, 0x97,
0x35, 0xdf, 0x85, 0xba, 0x39, 0xd6, 0xb5, 0xde, 0xb1, 0x50, 0xe6, 0xab, 0x71, 0xf0, 0xf0, 0xe7,
0x2f, 0x06, 0x4c, 0x0d, 0x8b, 0xfe, 0x76, 0x2c, 0x46, 0x3b, 0x06, 0xda, 0x7d, 0x26, 0xca, 0xd3,
0x0e, 0x4b, 0x15, 0x95, 0x29, 0xe1, 0x3b, 0x88, 0x76, 0x47, 0xa3, 0xcd, 0xfa, 0xfd, 0x06, 0x7e,
0x3d, 0xfc, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xda, 0x8a, 0xf0, 0x6c, 0x19, 0x0a, 0x00, 0x00,
0x09, 0xd5, 0xb1, 0x82, 0x7f, 0x2c, 0x00, 0x33, 0x12, 0x98, 0xd4, 0xce, 0x5c, 0x52, 0x1f, 0x2d,
0xf1, 0x3d, 0x53, 0x2d, 0x8f, 0x65, 0x5a, 0x9f, 0x42, 0x4d, 0x17, 0xfa, 0x4d, 0x59, 0xa1, 0x92,
0xc6, 0x80, 0xb5, 0x2c, 0xa7, 0xf7, 0x6a, 0x0c, 0xa8, 0x15, 0xec, 0x80, 0x73, 0x19, 0x6b, 0x11,
0x44, 0x0b, 0xe0, 0x85, 0x18, 0xb0, 0x98, 0xf0, 0xbd, 0x34, 0xe9, 0x58, 0xfe, 0x2d, 0x70, 0xcb,
0xef, 0x63, 0xd9, 0xa9, 0x06, 0x7f, 0xd8, 0x50, 0x43, 0x50, 0x4f, 0xc1, 0x55, 0x54, 0x8e, 0x22,
0xfa, 0x2a, 0x93, 0x65, 0xb9, 0xd7, 0x96, 0xc4, 0xbc, 0x6c, 0x10, 0xbd, 0xfe, 0xd5, 0x65, 0xb3,
0x7c, 0x05, 0x50, 0xe8, 0xd8, 0xc6, 0xd8, 0xc0, 0x7b, 0xef, 0xba, 0x6a, 0x75, 0x2b, 0xa1, 0x5b,
0x4c, 0xf9, 0xdc, 0x05, 0xaf, 0xcf, 0x66, 0xf6, 0xf6, 0x95, 0xbd, 0x36, 0x23, 0xb6, 0x5b, 0x09,
0xa1, 0x3f, 0xab, 0xc8, 0x01, 0x34, 0x63, 0x33, 0x88, 0xc6, 0x85, 0x59, 0x07, 0xef, 0x2f, 0x6d,
0xd7, 0xe9, 0xbc, 0x76, 0x2b, 0xa1, 0x17, 0xcf, 0x8d, 0xef, 0x77, 0xd0, 0x31, 0x28, 0xa4, 0xde,
0x7b, 0xc6, 0x91, 0xd9, 0x0a, 0x1f, 0x5c, 0x85, 0x65, 0xba, 0x21, 0xbb, 0x95, 0xb0, 0x55, 0x2c,
0xee, 0xcc, 0x13, 0xb8, 0x5d, 0xa2, 0x9a, 0xf3, 0xd7, 0x40, 0x7f, 0xc1, 0x95, 0xd8, 0xe6, 0x1d,
0xb6, 0xfb, 0x8b, 0xa2, 0xfd, 0x06, 0xd4, 0xb4, 0x93, 0xe0, 0x5f, 0x0b, 0xe0, 0x8c, 0xc6, 0x4a,
0xc8, 0xbd, 0xa3, 0xa3, 0x1f, 0xca, 0x27, 0xc8, 0x28, 0x9b, 0x87, 0x5d, 0x3f, 0x41, 0xc6, 0xdf,
0xc2, 0xe3, 0x58, 0x5d, 0x7c, 0x1c, 0x9f, 0x00, 0x64, 0x92, 0x26, 0x2c, 0x26, 0x8a, 0xe6, 0x6f,
0x6a, 0xb3, 0x39, 0x55, 0xff, 0x4b, 0x80, 0x0b, 0xfd, 0xcc, 0x9b, 0xd5, 0x50, 0xbb, 0xb2, 0xdc,
0xd3, 0x7f, 0x81, 0xd0, 0xbd, 0x98, 0xfe, 0x16, 0xdc, 0x87, 0x76, 0xc6, 0x49, 0x4c, 0x87, 0x82,
0x27, 0x54, 0x46, 0x8a, 0x0c, 0x90, 0x64, 0x37, 0x6c, 0xcd, 0x89, 0x4f, 0xc9, 0x20, 0xf8, 0xcb,
0x02, 0xe7, 0x84, 0x93, 0xf4, 0x48, 0x24, 0xb8, 0xac, 0xc7, 0x88, 0x38, 0x22, 0x69, 0x9a, 0x5f,
0xb3, 0x8e, 0x66, 0xbc, 0xe8, 0x16, 0x31, 0x36, 0x7b, 0x69, 0x9a, 0xfb, 0x5f, 0x2c, 0xa0, 0xbd,
0x7e, 0x04, 0xb5, 0xe9, 0x1c, 0xde, 0x4d, 0xe8, 0x88, 0x42, 0x65, 0x85, 0x8a, 0x2e, 0xa9, 0xd4,
0x74, 0xd9, 0x9b, 0x76, 0xd8, 0x32, 0xf2, 0x6f, 0x0c, 0xa3, 0xb9, 0xae, 0x50, 0x2a, 0x12, 0xfa,
0x49, 0x0a, 0x0d, 0xb3, 0x58, 0x17, 0x67, 0xb1, 0x0d, 0xde, 0xa1, 0xa4, 0x44, 0x51, 0x79, 0x3a,
0x24, 0x69, 0xc7, 0xf2, 0x3b, 0xd0, 0x2c, 0x05, 0xcf, 0x2f, 0x0a, 0xc2, 0x3b, 0x55, 0xbf, 0x09,
0xce, 0x0b, 0x9a, 0xe7, 0x78, 0x6f, 0xe3, 0xb0, 0xd2, 0x3c, 0x37, 0x97, 0x35, 0xdf, 0x85, 0xba,
0x39, 0xd6, 0xb5, 0xde, 0x91, 0x50, 0xe6, 0xab, 0xb1, 0xff, 0xe8, 0xa7, 0xcf, 0x06, 0x4c, 0x0d,
0x8b, 0xfe, 0x56, 0x2c, 0x46, 0xdb, 0x06, 0xd4, 0x03, 0x26, 0xca, 0xd3, 0x36, 0x4b, 0x15, 0x95,
0x29, 0xe1, 0xdb, 0x88, 0x73, 0x5b, 0xe3, 0xcc, 0xfa, 0xfd, 0x06, 0x7e, 0x3d, 0xfa, 0x2f, 0x00,
0x00, 0xff, 0xff, 0x6e, 0xb0, 0x90, 0xcb, 0x55, 0x0a, 0x00, 0x00,
}

5
internal/proto/segcore.proto
View File

@ -4,11 +4,6 @@ package milvus.proto.segcore;
option go_package = "github.com/milvus-io/milvus/internal/proto/segcorepb";
import "schema.proto";
message RetrieveRequest {
schema.IDs ids = 1;
repeated int64 output_fields_id = 2;
}
message RetrieveResults {
schema.IDs ids = 1;
repeated int64 offset = 2;

100
internal/proto/segcorepb/segcore.pb.go
View File

@ -21,53 +21,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type RetrieveRequest struct {
Ids *schemapb.IDs `protobuf:"bytes,1,opt,name=ids,proto3" json:"ids,omitempty"`
OutputFieldsId []int64 `protobuf:"varint,2,rep,packed,name=output_fields_id,json=outputFieldsId,proto3" json:"output_fields_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RetrieveRequest) Reset() { *m = RetrieveRequest{} }
func (m *RetrieveRequest) String() string { return proto.CompactTextString(m) }
func (*RetrieveRequest) ProtoMessage() {}
func (*RetrieveRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_1d79fce784797357, []int{0}
}
func (m *RetrieveRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RetrieveRequest.Unmarshal(m, b)
}
func (m *RetrieveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RetrieveRequest.Marshal(b, m, deterministic)
}
func (m *RetrieveRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_RetrieveRequest.Merge(m, src)
}
func (m *RetrieveRequest) XXX_Size() int {
return xxx_messageInfo_RetrieveRequest.Size(m)
}
func (m *RetrieveRequest) XXX_DiscardUnknown() {
xxx_messageInfo_RetrieveRequest.DiscardUnknown(m)
}
var xxx_messageInfo_RetrieveRequest proto.InternalMessageInfo
func (m *RetrieveRequest) GetIds() *schemapb.IDs {
if m != nil {
return m.Ids
}
return nil
}
func (m *RetrieveRequest) GetOutputFieldsId() []int64 {
if m != nil {
return m.OutputFieldsId
}
return nil
}
type RetrieveResults struct {
Ids *schemapb.IDs `protobuf:"bytes,1,opt,name=ids,proto3" json:"ids,omitempty"`
Offset []int64 `protobuf:"varint,2,rep,packed,name=offset,proto3" json:"offset,omitempty"`
@ -81,7 +34,7 @@ func (m *RetrieveResults) Reset() { *m = RetrieveResults{} }
func (m *RetrieveResults) String() string { return proto.CompactTextString(m) }
func (*RetrieveResults) ProtoMessage() {}
func (*RetrieveResults) Descriptor() ([]byte, []int) {
return fileDescriptor_1d79fce784797357, []int{1}
return fileDescriptor_1d79fce784797357, []int{0}
}
func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
@ -136,7 +89,7 @@ func (m *LoadFieldMeta) Reset() { *m = LoadFieldMeta{} }
func (m *LoadFieldMeta) String() string { return proto.CompactTextString(m) }
func (*LoadFieldMeta) ProtoMessage() {}
func (*LoadFieldMeta) Descriptor() ([]byte, []int) {
return fileDescriptor_1d79fce784797357, []int{2}
return fileDescriptor_1d79fce784797357, []int{1}
}
func (m *LoadFieldMeta) XXX_Unmarshal(b []byte) error {
@ -191,7 +144,7 @@ func (m *LoadSegmentMeta) Reset() { *m = LoadSegmentMeta{} }
func (m *LoadSegmentMeta) String() string { return proto.CompactTextString(m) }
func (*LoadSegmentMeta) ProtoMessage() {}
func (*LoadSegmentMeta) Descriptor() ([]byte, []int) {
return fileDescriptor_1d79fce784797357, []int{3}
return fileDescriptor_1d79fce784797357, []int{2}
}
func (m *LoadSegmentMeta) XXX_Unmarshal(b []byte) error {
@ -227,7 +180,6 @@ func (m *LoadSegmentMeta) GetTotalSize() int64 {
}
func init() {
proto.RegisterType((*RetrieveRequest)(nil), "milvus.proto.segcore.RetrieveRequest")
proto.RegisterType((*RetrieveResults)(nil), "milvus.proto.segcore.RetrieveResults")
proto.RegisterType((*LoadFieldMeta)(nil), "milvus.proto.segcore.LoadFieldMeta")
proto.RegisterType((*LoadSegmentMeta)(nil), "milvus.proto.segcore.LoadSegmentMeta")
@ -236,28 +188,26 @@ func init() {
func init() { proto.RegisterFile("segcore.proto", fileDescriptor_1d79fce784797357) }
var fileDescriptor_1d79fce784797357 = []byte{
// 357 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x91, 0x41, 0x4b, 0xeb, 0x40,
0x14, 0x85, 0x69, 0xc3, 0x2b, 0xaf, 0xb7, 0xed, 0xeb, 0x23, 0x3c, 0x1e, 0x41, 0x51, 0x4a, 0xba,
0x09, 0x82, 0x09, 0x54, 0x11, 0x5c, 0x09, 0x5a, 0x84, 0x82, 0x6e, 0x52, 0x57, 0x6e, 0xc2, 0x34,
0xb9, 0x4d, 0x07, 0x33, 0x99, 0x98, 0xb9, 0x69, 0x4b, 0x7f, 0x88, 0xbf, 0x57, 0x32, 0x19, 0xb1,
0x85, 0x6e, 0xdc, 0xcd, 0x3d, 0x73, 0xee, 0xf9, 0x4e, 0x32, 0x30, 0x50, 0x98, 0xc6, 0xb2, 0x44,
0xbf, 0x28, 0x25, 0x49, 0xfb, 0x9f, 0xe0, 0xd9, 0xba, 0x52, 0xcd, 0xe4, 0x9b, 0xbb, 0x93, 0xbe,
0x8a, 0x57, 0x28, 0x58, 0xa3, 0xba, 0x29, 0x0c, 0x43, 0xa4, 0x92, 0xe3, 0x1a, 0x43, 0x7c, 0xaf,
0x50, 0x91, 0x7d, 0x01, 0x16, 0x4f, 0x94, 0xd3, 0x1a, 0xb5, 0xbc, 0xde, 0xc4, 0xf1, 0x0f, 0x43,
0x9a, 0xdd, 0xd9, 0x54, 0x85, 0xb5, 0xc9, 0xf6, 0xe0, 0xaf, 0xac, 0xa8, 0xa8, 0x28, 0x5a, 0x72,
0xcc, 0x12, 0x15, 0xf1, 0xc4, 0x69, 0x8f, 0x2c, 0xcf, 0x0a, 0xff, 0x34, 0xfa, 0xa3, 0x96, 0x67,
0x89, 0xfb, 0xd1, 0xda, 0x27, 0xa9, 0x2a, 0x23, 0xf5, 0x23, 0xd2, 0x7f, 0xe8, 0xc8, 0xe5, 0x52,
0x21, 0x99, 0x7c, 0x33, 0xd9, 0x77, 0xd0, 0x33, 0xe8, 0x84, 0x11, 0x73, 0xac, 0x91, 0xe5, 0xf5,
0x26, 0xe7, 0x47, 0xb3, 0x74, 0x97, 0x29, 0x23, 0x16, 0x42, 0xb3, 0x52, 0x9f, 0xdd, 0x35, 0x0c,
0x9e, 0x24, 0x4b, 0xf4, 0xe5, 0x33, 0x12, 0xb3, 0xc7, 0x30, 0x10, 0x3c, 0x8f, 0x88, 0x0b, 0x54,
0xc4, 0x44, 0xa1, 0xfb, 0x59, 0x61, 0x5f, 0xf0, 0xfc, 0xe5, 0x4b, 0xd3, 0x26, 0xb6, 0xdd, 0x33,
0xb5, 0x8d, 0x89, 0x6d, 0xbf, 0x4d, 0xa7, 0xd0, 0x2d, 0xe5, 0x26, 0x8a, 0x65, 0x95, 0x93, 0x63,
0x69, 0xc3, 0xef, 0x52, 0x6e, 0x1e, 0xea, 0xd9, 0x7d, 0x83, 0x61, 0xcd, 0x9d, 0x63, 0x2a, 0x30,
0x27, 0x4d, 0xbe, 0x85, 0x5f, 0x02, 0x89, 0xd5, 0x7f, 0xa4, 0xfe, 0x8a, 0xb1, 0x7f, 0xec, 0x01,
0xfd, 0x83, 0xb6, 0x61, 0xb3, 0x61, 0x9f, 0x01, 0x90, 0x24, 0x96, 0x45, 0x8a, 0xef, 0xd0, 0x94,
0xe9, 0x6a, 0x65, 0xce, 0x77, 0x78, 0x7f, 0xf3, 0x7a, 0x9d, 0x72, 0x5a, 0x55, 0x0b, 0x3f, 0x96,
0x22, 0x68, 0x62, 0x2f, 0xb9, 0x34, 0xa7, 0x80, 0xe7, 0x84, 0x65, 0xce, 0xb2, 0x40, 0x93, 0x02,
0x43, 0x2a, 0x16, 0x8b, 0x8e, 0x16, 0xae, 0x3e, 0x03, 0x00, 0x00, 0xff, 0xff, 0x12, 0x58, 0xd4,
0xce, 0x5a, 0x02, 0x00, 0x00,
// 326 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4b, 0xfb, 0x40,
0x10, 0xc5, 0x69, 0xc3, 0xbf, 0xfc, 0x3b, 0x6d, 0x29, 0x04, 0x91, 0xa0, 0x28, 0xa5, 0xbd, 0x14,
0xc1, 0x04, 0xaa, 0x08, 0x9e, 0x04, 0x2d, 0x82, 0xa0, 0x97, 0xad, 0x27, 0x2f, 0x61, 0x9a, 0x4c,
0xdb, 0xc5, 0x6c, 0xb6, 0x64, 0x27, 0x6d, 0xe9, 0x07, 0xf1, 0xf3, 0xca, 0x6e, 0x22, 0x5a, 0xe8,
0x6d, 0xe7, 0xcd, 0x6f, 0xe6, 0xbd, 0x1d, 0xe8, 0x19, 0x5a, 0x26, 0xba, 0xa0, 0x70, 0x5d, 0x68,
0xd6, 0xfe, 0x89, 0x92, 0xd9, 0xa6, 0x34, 0x55, 0x15, 0xd6, 0xbd, 0xb3, 0xae, 0x49, 0x56, 0xa4,
0xb0, 0x52, 0x87, 0x5f, 0x0d, 0xe8, 0x0b, 0xe2, 0x42, 0xd2, 0x86, 0x04, 0x99, 0x32, 0x63, 0xe3,
0x5f, 0x81, 0x27, 0x53, 0x13, 0x34, 0x06, 0x8d, 0x71, 0x67, 0x12, 0x84, 0x87, 0x5b, 0xaa, 0xe1,
0x97, 0xa9, 0x11, 0x16, 0xf2, 0x4f, 0xa1, 0xa5, 0x17, 0x0b, 0x43, 0x1c, 0x34, 0x07, 0xde, 0xd8,
0x13, 0x75, 0xe5, 0x3f, 0x40, 0x67, 0x21, 0x29, 0x4b, 0x4d, 0x9c, 0x22, 0x63, 0xe0, 0x0d, 0xbc,
0x71, 0x67, 0x72, 0x79, 0x74, 0xd7, 0xb3, 0xe5, 0xa6, 0xc8, 0x28, 0xa0, 0x1a, 0xb1, 0xef, 0xe1,
0x06, 0x7a, 0xaf, 0x1a, 0x53, 0xd7, 0x7c, 0x23, 0x46, 0x7f, 0x04, 0x3d, 0x25, 0xf3, 0x98, 0xa5,
0x22, 0xc3, 0xa8, 0xd6, 0x2e, 0x9f, 0x27, 0xba, 0x4a, 0xe6, 0xef, 0x3f, 0x9a, 0x83, 0x70, 0xf7,
0x07, 0x6a, 0xd6, 0x10, 0xee, 0x7e, 0xa1, 0x73, 0x68, 0x17, 0x7a, 0x1b, 0x27, 0xba, 0xcc, 0x39,
0xf0, 0x1c, 0xf0, 0xbf, 0xd0, 0xdb, 0x27, 0x5b, 0x0f, 0x3f, 0xa1, 0x6f, 0x7d, 0x67, 0xb4, 0x54,
0x94, 0xb3, 0x73, 0xbe, 0x87, 0x7f, 0x8a, 0x18, 0xed, 0x45, 0xec, 0x2f, 0x46, 0xe1, 0xb1, 0xbb,
0x86, 0x07, 0x69, 0x45, 0x35, 0xe1, 0x5f, 0x00, 0xb0, 0x66, 0xcc, 0x62, 0x23, 0xf7, 0x54, 0x87,
0x69, 0x3b, 0x65, 0x26, 0xf7, 0xf4, 0x78, 0xf7, 0x71, 0xbb, 0x94, 0xbc, 0x2a, 0xe7, 0x61, 0xa2,
0x55, 0x54, 0xad, 0xbd, 0x96, 0xba, 0x7e, 0x45, 0x32, 0x67, 0x2a, 0x72, 0xcc, 0x22, 0xe7, 0x14,
0xd5, 0x4e, 0xeb, 0xf9, 0xbc, 0xe5, 0x84, 0x9b, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xd6,
0xac, 0xcc, 0xf1, 0x01, 0x00, 0x00,
}

2
internal/proxy/impl.go
View File

@ -1660,13 +1660,13 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
MsgType: commonpb.MsgType_Retrieve,
SourceID: Params.ProxyID,
},
Ids: ids.IdArray,
ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
},
resultBuf: make(chan []*internalpb.RetrieveResults),
query: queryRequest,
chMgr: node.chMgr,
qc: node.queryCoord,
ids: ids.IdArray,
}
err := node.sched.DqQueue.Enqueue(qt)

19
internal/proxy/plan_parser.go
View File

@ -633,3 +633,22 @@ func CreateQueryPlan(schemaPb *schemapb.CollectionSchema, exprStr string, vector
}
return planNode, nil
}
func CreateExprQueryPlan(schemaPb *schemapb.CollectionSchema, exprStr string) (*planpb.PlanNode, error) {
schema, err := typeutil.CreateSchemaHelper(schemaPb)
if err != nil {
return nil, err
}
expr, err := parseQueryExpr(schema, exprStr)
if err != nil {
return nil, err
}
planNode := &planpb.PlanNode{
Node: &planpb.PlanNode_Predicates{
Predicates: expr,
},
}
return planNode, nil
}

74
internal/proxy/task.go
View File

@ -2012,6 +2012,7 @@ type QueryTask struct {
query *milvuspb.QueryRequest
chMgr channelsMgr
qc types.QueryCoord
ids *schemapb.IDs
}
func (qt *QueryTask) TraceCtx() context.Context {
@ -2105,6 +2106,11 @@ func parseIdsFromExpr(exprStr string, schema *typeutil.SchemaHelper) ([]int64, e
}
}
func IDs2Expr(fieldName string, ids []int64) string {
idsStr := strings.Trim(strings.Join(strings.Fields(fmt.Sprint(ids)), ", "), "[]")
return fieldName + " in [ " + idsStr + " ]"
}
func (qt *QueryTask) PreExecute(ctx context.Context) error {
qt.Base.MsgType = commonpb.MsgType_Retrieve
qt.Base.SourceID = Params.ProxyID
@ -2172,31 +2178,52 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
if err != nil { // err is not nil if collection not exists
return err
}
schemaHelper, err := typeutil.CreateSchemaHelper(schema)
if err != nil {
return err
}
// schemaHelper, err := typeutil.CreateSchemaHelper(schema)
// if err != nil {
// return err
// }
// TODO(dragondriver): necessary to check if partition was loaded into query node?
if qt.Ids == nil {
if qt.query.Expr == "" {
errMsg := "Query expression is empty"
return fmt.Errorf(errMsg)
}
// if qt.Ids == nil {
// if qt.query.Expr == "" {
// errMsg := "Query expression is empty"
// return fmt.Errorf(errMsg)
// }
ids, err := parseIdsFromExpr(qt.query.Expr, schemaHelper)
if err != nil {
return err
}
qt.Base.MsgType = commonpb.MsgType_Retrieve
qt.Ids = &schemapb.IDs{
IdField: &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: ids,
},
},
// ids, err := parseIdsFromExpr(qt.query.Expr, schemaHelper)
// if err != nil {
// return err
// }
// qt.Base.MsgType = commonpb.MsgType_Retrieve
// qt.Ids = &schemapb.IDs{
// IdField: &schemapb.IDs_IntId{
// IntId: &schemapb.LongArray{
// Data: ids,
// },
// },
// }
// }
if qt.ids != nil {
pkField := ""
for _, field := range schema.Fields {
if field.IsPrimaryKey {
pkField = field.Name
}
}
qt.query.Expr = IDs2Expr(pkField, qt.ids.GetIntId().Data)
}
if qt.query.Expr == "" {
errMsg := "Query expression is empty"
return fmt.Errorf(errMsg)
}
plan, err := CreateExprQueryPlan(schema, qt.query.Expr)
if err != nil {
//return errors.New("invalid expression: " + st.query.Dsl)
return err
}
qt.query.OutputFields, err = translateOutputFields(qt.query.OutputFields, schema, true)
if err != nil {
@ -2220,9 +2247,11 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
}
findField = true
qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
plan.OutputFieldIds = append(plan.OutputFieldIds, field.FieldID)
} else {
if field.IsPrimaryKey && !addPrimaryKey {
qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
plan.OutputFieldIds = append(plan.OutputFieldIds, field.FieldID)
addPrimaryKey = true
}
}
@ -2235,6 +2264,11 @@ func (qt *QueryTask) PreExecute(ctx context.Context) error {
}
log.Debug("translate output fields to field ids", zap.Any("OutputFieldsID", qt.OutputFieldsId))
qt.RetrieveRequest.SerializedExprPlan, err = proto.Marshal(plan)
if err != nil {
return err
}
travelTimestamp := qt.query.TravelTimestamp
if travelTimestamp == 0 {
travelTimestamp = qt.BeginTs()

37
internal/querynode/plan.go
View File

@ -23,8 +23,6 @@ import "C"
import (
"errors"
"unsafe"
"github.com/milvus-io/milvus/internal/proto/segcorepb"
)
type SearchPlan struct {
@ -110,19 +108,36 @@ type RetrievePlan struct {
Timestamp uint64
}
func createRetrievePlan(col *Collection, msg *segcorepb.RetrieveRequest, timestamp uint64) (*RetrievePlan, error) {
protoCGo, err := MarshalForCGo(msg)
// func createRetrievePlan(col *Collection, msg *segcorepb.RetrieveRequest, timestamp uint64) (*RetrievePlan, error) {
// protoCGo, err := MarshalForCGo(msg)
// if err != nil {
// return nil, err
// }
// plan := new(RetrievePlan)
// plan.Timestamp = timestamp
// status := C.CreateRetrievePlan(col.collectionPtr, protoCGo.CProto, &plan.cRetrievePlan)
// err2 := HandleCStatus(&status, "create retrieve plan failed")
// if err2 != nil {
// return nil, err2
// }
// return plan, nil
// }
func createRetrievePlanByExpr(col *Collection, expr []byte, timestamp uint64) (*RetrievePlan, error) {
var cPlan C.CRetrievePlan
status := C.CreateRetrievePlanByExpr(col.collectionPtr, (*C.char)(unsafe.Pointer(&expr[0])),
(C.int64_t)(len(expr)), &cPlan)
err := HandleCStatus(&status, "Create retrieve plan by expr failed")
if err != nil {
return nil, err
}
plan := new(RetrievePlan)
plan.Timestamp = timestamp
status := C.CreateRetrievePlan(col.collectionPtr, protoCGo.CProto, &plan.cRetrievePlan)
err2 := HandleCStatus(&status, "create retrieve plan failed")
if err2 != nil {
return nil, err2
var newPlan = &RetrievePlan{
cRetrievePlan: cPlan,
Timestamp: timestamp,
}
return plan, nil
return newPlan, nil
}
func (plan *RetrievePlan) delete() {

8
internal/querynode/query_collection.go
View File

@ -1045,12 +1045,8 @@ func (q *queryCollection) retrieve(msg queryMsg) error {
return err
}
req := &segcorepb.RetrieveRequest{
Ids: retrieveMsg.Ids,
OutputFieldsId: retrieveMsg.OutputFieldsId,
}
plan, err := createRetrievePlan(collection, req, timestamp)
expr := retrieveMsg.SerializedExprPlan
plan, err := createRetrievePlanByExpr(collection, expr, timestamp)
if err != nil {
return err
}

19
internal/querynode/query_node_test.go
View File

@ -120,6 +120,25 @@ func genTestCollectionMeta(collectionID UniqueID, isBinary bool) *etcdpb.Collect
return &collectionMeta
}
func genTestCollectionMetaWithPK(collectionID UniqueID, isBinary bool) *etcdpb.CollectionInfo {
schema := genTestCollectionSchema(collectionID, isBinary, 16)
schema.Fields = append(schema.Fields, &schemapb.FieldSchema{
FieldID: UniqueID(0),
Name: "id",
IsPrimaryKey: true,
DataType: schemapb.DataType_Int64,
})
collectionMeta := etcdpb.CollectionInfo{
ID: collectionID,
Schema: schema,
CreateTime: Timestamp(0),
PartitionIDs: []UniqueID{defaultPartitionID},
}
return &collectionMeta
}
func initTestMeta(t *testing.T, node *QueryNode, collectionID UniqueID, segmentID UniqueID, optional ...bool) {
isBinary := false
if len(optional) > 0 {

2
internal/querynode/segment.go
View File

@ -312,7 +312,7 @@ func (s *Segment) getEntityByIds(plan *RetrievePlan) (*segcorepb.RetrieveResults
if s.segmentPtr == nil {
return nil, errors.New("null seg core pointer")
}
resProto := C.GetEntityByIds(s.segmentPtr, plan.cRetrievePlan, C.uint64_t(plan.Timestamp))
resProto := C.Retrieve(s.segmentPtr, plan.cRetrievePlan, C.uint64_t(plan.Timestamp))
result := new(segcorepb.RetrieveResults)
err := HandleCProtoResult(&resProto, result)
if err != nil {

54
internal/querynode/segment_test.go
View File

@ -23,8 +23,8 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/planpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/proto/segcorepb"
)
//-------------------------------------------------------------------------------------- constructor and destructor
@ -133,7 +133,7 @@ func TestSegment_retrieve(t *testing.T) {
rawData = append(rawData, buf...)
}
bs := make([]byte, 4)
binary.LittleEndian.PutUint32(bs, 1)
binary.LittleEndian.PutUint32(bs, uint32(i+1))
rawData = append(rawData, bs...)
blob := &commonpb.Blob{
Value: rawData,
@ -146,24 +146,58 @@ func TestSegment_retrieve(t *testing.T) {
err = segment.segmentInsert(offset, &ids, &timestamps, &records)
assert.NoError(t, err)
reqIds := &segcorepb.RetrieveRequest{
Ids: &schemapb.IDs{
IdField: &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: []int64{2, 3, 1},
planNode := &planpb.PlanNode{
Node: &planpb.PlanNode_Predicates{
Predicates: &planpb.Expr{
Expr: &planpb.Expr_TermExpr{
TermExpr: &planpb.TermExpr{
ColumnInfo: &planpb.ColumnInfo{
FieldId: 101,
DataType: schemapb.DataType_Int32,
},
Values: []*planpb.GenericValue{
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 1,
},
},
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 2,
},
},
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 3,
},
},
},
},
},
},
},
OutputFieldsId: []int64{100},
OutputFieldIds: []int64{101},
}
plan, err := createRetrievePlan(collection, reqIds, 100)
// reqIds := &segcorepb.RetrieveRequest{
// Ids: &schemapb.IDs{
// IdField: &schemapb.IDs_IntId{
// IntId: &schemapb.LongArray{
// Data: []int64{2, 3, 1},
// },
// },
// },
// OutputFieldsId: []int64{100},
// }
planExpr, err := proto.Marshal(planNode)
assert.NoError(t, err)
plan, err := createRetrievePlanByExpr(collection, planExpr, 100)
defer plan.delete()
assert.NoError(t, err)
res, err := segment.getEntityByIds(plan)
assert.NoError(t, err)
assert.Equal(t, res.Ids.GetIntId().Data, []int64{2, 3, 1})
assert.Equal(t, res.GetFieldsData()[0].GetScalars().Data.(*schemapb.ScalarField_IntData).IntData.Data, []int32{1, 2, 3})
}
func TestSegment_getDeletedCount(t *testing.T) {

6
tests/python_client/testcases/entity/test_query.py
View File

@ -273,8 +273,9 @@ class TestQueryBase:
with pytest.raises(Exception):
connect.query(collection, term_expr)
# TODO(yukun): "not in" is supported now
@pytest.mark.parametrize("expr", [f'{default_int_field_name} inn [1, 2]',
f'{default_int_field_name} not in [1, 2]',
# f'{default_int_field_name} not in [1, 2]',
f'{default_int_field_name} in not [1, 2]'])
@pytest.mark.tags(CaseLabel.L0)
def test_query_expr_wrong_term_keyword(self, connect, collection, expr):
@ -368,7 +369,8 @@ class TestQueryBase:
assert res[index][default_float_field_name] == entities[1]["values"][index]
ut.assert_equal_vector(res[index][ut.default_float_vec_field_name], entities[2]["values"][index])
@pytest.mark.tags(CaseLabel.L0)
# @pytest.mark.tags(CaseLabel.L0)
@pytest.mark.xfail(reason="Need to discuss")
def test_query_expr_repeated_term_array(self, connect, collection):
"""
target: test query with repeated term array on primary field with unique value

7
tests/python_client/testcases/test_query_20.py
View File

@ -202,9 +202,10 @@ class TestQueryBase(TestcaseBase):
error_1 = {ct.err_code: 1, ct.err_msg: f'unexpected token Identifier("inn")'}
collection_w.query(expr_1, check_task=CheckTasks.err_res, check_items=error_1)
expr_2 = f'{ct.default_int64_field_name} not in [1, 2]'
error_2 = {ct.err_code: 1, ct.err_msg: 'not top level term'}
collection_w.query(expr_2, check_task=CheckTasks.err_res, check_items=error_2)
# TODO(yukun): "not in" is supported now
# expr_2 = f'{ct.default_int64_field_name} not in [1, 2]'
# error_2 = {ct.err_code: 1, ct.err_msg: 'not top level term'}
# collection_w.query(expr_2, check_task=CheckTasks.err_res, check_items=error_2)
expr_3 = f'{ct.default_int64_field_name} in not [1, 2]'
error_3 = {ct.err_code: 1, ct.err_msg: 'right operand of the InExpr must be array'}