diff --git a/internal/core/src/pb/milvus.pb.cc b/internal/core/src/pb/milvus.pb.cc index b79338795a..a6d5c3d2df 100644 --- a/internal/core/src/pb/milvus.pb.cc +++ b/internal/core/src/pb/milvus.pb.cc @@ -209,6 +209,14 @@ class FlushRequestDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _FlushRequest_default_instance_; +class QueryRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _QueryRequest_default_instance_; +class QueryResultsDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _QueryResults_default_instance_; class PersistentSegmentInfoDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -840,6 +848,37 @@ static void InitDefaultsscc_info_PlaceholderValue_milvus_2eproto() { ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlaceholderValue_milvus_2eproto = {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_PlaceholderValue_milvus_2eproto}, {}}; +static void InitDefaultsscc_info_QueryRequest_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_QueryRequest_default_instance_; + new (ptr) ::milvus::proto::milvus::QueryRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::QueryRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_QueryRequest_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_QueryRequest_milvus_2eproto}, { + &scc_info_MsgBase_common_2eproto.base,}}; + +static void InitDefaultsscc_info_QueryResults_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_QueryResults_default_instance_; + new (ptr) ::milvus::proto::milvus::QueryResults(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::QueryResults::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_QueryResults_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_QueryResults_milvus_2eproto}, { + &scc_info_Status_common_2eproto.base, + &scc_info_FieldData_schema_2eproto.base,}}; + static void InitDefaultsscc_info_QuerySegmentInfo_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -1083,7 +1122,7 @@ static void InitDefaultsscc_info_StringResponse_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringResponse_milvus_2eproto}, { &scc_info_Status_common_2eproto.base,}}; -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[55]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[57]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; @@ -1477,6 +1516,24 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, db_name_), PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::FlushRequest, collection_names_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, base_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, db_name_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, expr_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, output_fields_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryRequest, partition_names_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryResults, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryResults, status_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::QueryResults, fields_data_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -1599,16 +1656,18 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 365, -1, sizeof(::milvus::proto::milvus::Hits)}, { 373, -1, sizeof(::milvus::proto::milvus::SearchResults)}, { 380, -1, sizeof(::milvus::proto::milvus::FlushRequest)}, - { 388, -1, sizeof(::milvus::proto::milvus::PersistentSegmentInfo)}, - { 398, -1, sizeof(::milvus::proto::milvus::GetPersistentSegmentInfoRequest)}, - { 406, -1, sizeof(::milvus::proto::milvus::GetPersistentSegmentInfoResponse)}, - { 413, -1, sizeof(::milvus::proto::milvus::QuerySegmentInfo)}, - { 425, -1, sizeof(::milvus::proto::milvus::GetQuerySegmentInfoRequest)}, - { 433, -1, sizeof(::milvus::proto::milvus::GetQuerySegmentInfoResponse)}, - { 440, -1, sizeof(::milvus::proto::milvus::DummyRequest)}, - { 446, -1, sizeof(::milvus::proto::milvus::DummyResponse)}, - { 452, -1, sizeof(::milvus::proto::milvus::RegisterLinkRequest)}, - { 457, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)}, + { 388, -1, sizeof(::milvus::proto::milvus::QueryRequest)}, + { 399, -1, sizeof(::milvus::proto::milvus::QueryResults)}, + { 406, -1, sizeof(::milvus::proto::milvus::PersistentSegmentInfo)}, + { 416, -1, sizeof(::milvus::proto::milvus::GetPersistentSegmentInfoRequest)}, + { 424, -1, sizeof(::milvus::proto::milvus::GetPersistentSegmentInfoResponse)}, + { 431, -1, sizeof(::milvus::proto::milvus::QuerySegmentInfo)}, + { 443, -1, sizeof(::milvus::proto::milvus::GetQuerySegmentInfoRequest)}, + { 451, -1, sizeof(::milvus::proto::milvus::GetQuerySegmentInfoResponse)}, + { 458, -1, sizeof(::milvus::proto::milvus::DummyRequest)}, + { 464, -1, sizeof(::milvus::proto::milvus::DummyResponse)}, + { 470, -1, sizeof(::milvus::proto::milvus::RegisterLinkRequest)}, + { 475, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1657,6 +1716,8 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::proto::milvus::_Hits_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_SearchResults_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_FlushRequest_default_instance_), + reinterpret_cast(&::milvus::proto::milvus::_QueryRequest_default_instance_), + reinterpret_cast(&::milvus::proto::milvus::_QueryResults_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_PersistentSegmentInfo_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_GetPersistentSegmentInfoRequest_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_GetPersistentSegmentInfoResponse_default_instance_), @@ -1820,96 +1881,105 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "s\030\001 \001(\0132\033.milvus.proto.common.Status\022\014\n\004" "hits\030\002 \003(\014\"e\n\014FlushRequest\022*\n\004base\030\001 \001(\013" "2\034.milvus.proto.common.MsgBase\022\017\n\007db_nam" - "e\030\002 \001(\t\022\030\n\020collection_names\030\003 \003(\t\"\231\001\n\025Pe" - "rsistentSegmentInfo\022\021\n\tsegmentID\030\001 \001(\003\022\024" - "\n\014collectionID\030\002 \001(\003\022\023\n\013partitionID\030\003 \001(" - "\003\022\020\n\010num_rows\030\004 \001(\003\0220\n\005state\030\005 \001(\0162!.mil" - "vus.proto.common.SegmentState\"u\n\037GetPers" - "istentSegmentInfoRequest\022*\n\004base\030\001 \001(\0132\034" - ".milvus.proto.common.MsgBase\022\016\n\006dbName\030\002" - " \001(\t\022\026\n\016collectionName\030\003 \001(\t\"\212\001\n GetPers" - "istentSegmentInfoResponse\022+\n\006status\030\001 \001(" - "\0132\033.milvus.proto.common.Status\0229\n\005infos\030" - "\002 \003(\0132*.milvus.proto.milvus.PersistentSe" - "gmentInfo\"\231\001\n\020QuerySegmentInfo\022\021\n\tsegmen" - "tID\030\001 \001(\003\022\024\n\014collectionID\030\002 \001(\003\022\023\n\013parti" - "tionID\030\003 \001(\003\022\020\n\010mem_size\030\004 \001(\003\022\020\n\010num_ro" - "ws\030\005 \001(\003\022\022\n\nindex_name\030\006 \001(\t\022\017\n\007indexID\030" - "\007 \001(\003\"p\n\032GetQuerySegmentInfoRequest\022*\n\004b" - "ase\030\001 \001(\0132\034.milvus.proto.common.MsgBase\022" - "\016\n\006dbName\030\002 \001(\t\022\026\n\016collectionName\030\003 \001(\t\"" - "\200\001\n\033GetQuerySegmentInfoResponse\022+\n\006statu" - "s\030\001 \001(\0132\033.milvus.proto.common.Status\0224\n\005" - "infos\030\002 \003(\0132%.milvus.proto.milvus.QueryS" - "egmentInfo\"$\n\014DummyRequest\022\024\n\014request_ty" - "pe\030\001 \001(\t\"!\n\rDummyResponse\022\020\n\010response\030\001 " - "\001(\t\"\025\n\023RegisterLinkRequest\"r\n\024RegisterLi" - "nkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pro" - "to.common.Address\022+\n\006status\030\002 \001(\0132\033.milv" - "us.proto.common.Status*,\n\023ShowCollection" - "sType\022\007\n\003All\020\000\022\014\n\010InMemory\020\001*>\n\017Placehol" - "derType\022\010\n\004None\020\000\022\020\n\014BinaryVector\020d\022\017\n\013F" - "loatVector\020e2\274\026\n\rMilvusService\022_\n\020Create" - "Collection\022,.milvus.proto.milvus.CreateC" - "ollectionRequest\032\033.milvus.proto.common.S" - "tatus\"\000\022[\n\016DropCollection\022*.milvus.proto" - ".milvus.DropCollectionRequest\032\033.milvus.p" - "roto.common.Status\"\000\022_\n\rHasCollection\022)." - "milvus.proto.milvus.HasCollectionRequest" - "\032!.milvus.proto.milvus.BoolResponse\"\000\022[\n" - "\016LoadCollection\022*.milvus.proto.milvus.Lo" - "adCollectionRequest\032\033.milvus.proto.commo" - "n.Status\"\000\022a\n\021ReleaseCollection\022-.milvus" - ".proto.milvus.ReleaseCollectionRequest\032\033" - ".milvus.proto.common.Status\"\000\022w\n\022Describ" - "eCollection\022..milvus.proto.milvus.Descri" - "beCollectionRequest\032/.milvus.proto.milvu" - "s.DescribeCollectionResponse\"\000\022\206\001\n\027GetCo" - "llectionStatistics\0223.milvus.proto.milvus" - ".GetCollectionStatisticsRequest\0324.milvus" - ".proto.milvus.GetCollectionStatisticsRes" - "ponse\"\000\022n\n\017ShowCollections\022+.milvus.prot" - "o.milvus.ShowCollectionsRequest\032,.milvus" - ".proto.milvus.ShowCollectionsResponse\"\000\022" - "]\n\017CreatePartition\022+.milvus.proto.milvus" - ".CreatePartitionRequest\032\033.milvus.proto.c" - "ommon.Status\"\000\022Y\n\rDropPartition\022).milvus" - ".proto.milvus.DropPartitionRequest\032\033.mil" - "vus.proto.common.Status\"\000\022]\n\014HasPartitio" - "n\022(.milvus.proto.milvus.HasPartitionRequ" - "est\032!.milvus.proto.milvus.BoolResponse\"\000" - "\022[\n\016LoadPartitions\022*.milvus.proto.milvus" - ".LoadPartitionsRequest\032\033.milvus.proto.co" - "mmon.Status\"\000\022a\n\021ReleasePartitions\022-.mil" - "vus.proto.milvus.ReleasePartitionsReques" - "t\032\033.milvus.proto.common.Status\"\000\022\203\001\n\026Get" - "PartitionStatistics\0222.milvus.proto.milvu" - "s.GetPartitionStatisticsRequest\0323.milvus" - ".proto.milvus.GetPartitionStatisticsResp" - "onse\"\000\022k\n\016ShowPartitions\022*.milvus.proto." - "milvus.ShowPartitionsRequest\032+.milvus.pr" - "oto.milvus.ShowPartitionsResponse\"\000\022U\n\013C" - "reateIndex\022\'.milvus.proto.milvus.CreateI" - "ndexRequest\032\033.milvus.proto.common.Status" - "\"\000\022h\n\rDescribeIndex\022).milvus.proto.milvu" - "s.DescribeIndexRequest\032*.milvus.proto.mi" - "lvus.DescribeIndexResponse\"\000\022h\n\rGetIndex" - "State\022).milvus.proto.milvus.GetIndexStat" - "eRequest\032*.milvus.proto.milvus.GetIndexS" - "tateResponse\"\000\022\200\001\n\025GetIndexBuildProgress" - "\0221.milvus.proto.milvus.GetIndexBuildProg" - "ressRequest\0322.milvus.proto.milvus.GetInd" - "exBuildProgressResponse\"\000\022Q\n\tDropIndex\022%" - ".milvus.proto.milvus.DropIndexRequest\032\033." - "milvus.proto.common.Status\"\000\022S\n\006Insert\022\"" - ".milvus.proto.milvus.InsertRequest\032#.mil" - "vus.proto.milvus.InsertResponse\"\000\022R\n\006Sea" - "rch\022\".milvus.proto.milvus.SearchRequest\032" - "\".milvus.proto.milvus.SearchResults\"\000\022X\n" - "\010Retrieve\022$.milvus.proto.milvus.Retrieve" - "Request\032$.milvus.proto.milvus.RetrieveRe" - "sults\"\000\022I\n\005Flush\022!.milvus.proto.milvus.F" - "lushRequest\032\033.milvus.proto.common.Status" + "e\030\002 \001(\t\022\030\n\020collection_names\030\003 \003(\t\"\242\001\n\014Qu" + "eryRequest\022*\n\004base\030\001 \001(\0132\034.milvus.proto." + "common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017colle" + "ction_name\030\003 \001(\t\022\014\n\004expr\030\004 \001(\t\022\025\n\routput" + "_fields\030\005 \003(\t\022\027\n\017partition_names\030\006 \003(\t\"p" + "\n\014QueryResults\022+\n\006status\030\001 \001(\0132\033.milvus." + "proto.common.Status\0223\n\013fields_data\030\002 \003(\013" + "2\036.milvus.proto.schema.FieldData\"\231\001\n\025Per" + "sistentSegmentInfo\022\021\n\tsegmentID\030\001 \001(\003\022\024\n" + "\014collectionID\030\002 \001(\003\022\023\n\013partitionID\030\003 \001(\003" + "\022\020\n\010num_rows\030\004 \001(\003\0220\n\005state\030\005 \001(\0162!.milv" + "us.proto.common.SegmentState\"u\n\037GetPersi" + "stentSegmentInfoRequest\022*\n\004base\030\001 \001(\0132\034." + "milvus.proto.common.MsgBase\022\016\n\006dbName\030\002 " + "\001(\t\022\026\n\016collectionName\030\003 \001(\t\"\212\001\n GetPersi" + "stentSegmentInfoResponse\022+\n\006status\030\001 \001(\013" + "2\033.milvus.proto.common.Status\0229\n\005infos\030\002" + " \003(\0132*.milvus.proto.milvus.PersistentSeg" + "mentInfo\"\231\001\n\020QuerySegmentInfo\022\021\n\tsegment" + "ID\030\001 \001(\003\022\024\n\014collectionID\030\002 \001(\003\022\023\n\013partit" + "ionID\030\003 \001(\003\022\020\n\010mem_size\030\004 \001(\003\022\020\n\010num_row" + "s\030\005 \001(\003\022\022\n\nindex_name\030\006 \001(\t\022\017\n\007indexID\030\007" + " \001(\003\"p\n\032GetQuerySegmentInfoRequest\022*\n\004ba" + "se\030\001 \001(\0132\034.milvus.proto.common.MsgBase\022\016" + "\n\006dbName\030\002 \001(\t\022\026\n\016collectionName\030\003 \001(\t\"\200" + "\001\n\033GetQuerySegmentInfoResponse\022+\n\006status" + "\030\001 \001(\0132\033.milvus.proto.common.Status\0224\n\005i" + "nfos\030\002 \003(\0132%.milvus.proto.milvus.QuerySe" + "gmentInfo\"$\n\014DummyRequest\022\024\n\014request_typ" + "e\030\001 \001(\t\"!\n\rDummyResponse\022\020\n\010response\030\001 \001" + "(\t\"\025\n\023RegisterLinkRequest\"r\n\024RegisterLin" + "kResponse\022-\n\007address\030\001 \001(\0132\034.milvus.prot" + "o.common.Address\022+\n\006status\030\002 \001(\0132\033.milvu" + "s.proto.common.Status*,\n\023ShowCollections" + "Type\022\007\n\003All\020\000\022\014\n\010InMemory\020\001*>\n\017Placehold" + "erType\022\010\n\004None\020\000\022\020\n\014BinaryVector\020d\022\017\n\013Fl" + "oatVector\020e2\215\027\n\rMilvusService\022_\n\020CreateC" + "ollection\022,.milvus.proto.milvus.CreateCo" + "llectionRequest\032\033.milvus.proto.common.St" + "atus\"\000\022[\n\016DropCollection\022*.milvus.proto." + "milvus.DropCollectionRequest\032\033.milvus.pr" + "oto.common.Status\"\000\022_\n\rHasCollection\022).m" + "ilvus.proto.milvus.HasCollectionRequest\032" + "!.milvus.proto.milvus.BoolResponse\"\000\022[\n\016" + "LoadCollection\022*.milvus.proto.milvus.Loa" + "dCollectionRequest\032\033.milvus.proto.common" + ".Status\"\000\022a\n\021ReleaseCollection\022-.milvus." + "proto.milvus.ReleaseCollectionRequest\032\033." + "milvus.proto.common.Status\"\000\022w\n\022Describe" + "Collection\022..milvus.proto.milvus.Describ" + "eCollectionRequest\032/.milvus.proto.milvus" + ".DescribeCollectionResponse\"\000\022\206\001\n\027GetCol" + "lectionStatistics\0223.milvus.proto.milvus." + "GetCollectionStatisticsRequest\0324.milvus." + "proto.milvus.GetCollectionStatisticsResp" + "onse\"\000\022n\n\017ShowCollections\022+.milvus.proto" + ".milvus.ShowCollectionsRequest\032,.milvus." + "proto.milvus.ShowCollectionsResponse\"\000\022]" + "\n\017CreatePartition\022+.milvus.proto.milvus." + "CreatePartitionRequest\032\033.milvus.proto.co" + "mmon.Status\"\000\022Y\n\rDropPartition\022).milvus." + "proto.milvus.DropPartitionRequest\032\033.milv" + "us.proto.common.Status\"\000\022]\n\014HasPartition" + "\022(.milvus.proto.milvus.HasPartitionReque" + "st\032!.milvus.proto.milvus.BoolResponse\"\000\022" + "[\n\016LoadPartitions\022*.milvus.proto.milvus." + "LoadPartitionsRequest\032\033.milvus.proto.com" + "mon.Status\"\000\022a\n\021ReleasePartitions\022-.milv" + "us.proto.milvus.ReleasePartitionsRequest" + "\032\033.milvus.proto.common.Status\"\000\022\203\001\n\026GetP" + "artitionStatistics\0222.milvus.proto.milvus" + ".GetPartitionStatisticsRequest\0323.milvus." + "proto.milvus.GetPartitionStatisticsRespo" + "nse\"\000\022k\n\016ShowPartitions\022*.milvus.proto.m" + "ilvus.ShowPartitionsRequest\032+.milvus.pro" + "to.milvus.ShowPartitionsResponse\"\000\022U\n\013Cr" + "eateIndex\022\'.milvus.proto.milvus.CreateIn" + "dexRequest\032\033.milvus.proto.common.Status\"" + "\000\022h\n\rDescribeIndex\022).milvus.proto.milvus" + ".DescribeIndexRequest\032*.milvus.proto.mil" + "vus.DescribeIndexResponse\"\000\022h\n\rGetIndexS" + "tate\022).milvus.proto.milvus.GetIndexState" + "Request\032*.milvus.proto.milvus.GetIndexSt" + "ateResponse\"\000\022\200\001\n\025GetIndexBuildProgress\022" + "1.milvus.proto.milvus.GetIndexBuildProgr" + "essRequest\0322.milvus.proto.milvus.GetInde" + "xBuildProgressResponse\"\000\022Q\n\tDropIndex\022%." + "milvus.proto.milvus.DropIndexRequest\032\033.m" + "ilvus.proto.common.Status\"\000\022S\n\006Insert\022\"." + "milvus.proto.milvus.InsertRequest\032#.milv" + "us.proto.milvus.InsertResponse\"\000\022R\n\006Sear" + "ch\022\".milvus.proto.milvus.SearchRequest\032\"" + ".milvus.proto.milvus.SearchResults\"\000\022X\n\010" + "Retrieve\022$.milvus.proto.milvus.RetrieveR" + "equest\032$.milvus.proto.milvus.RetrieveRes" + "ults\"\000\022I\n\005Flush\022!.milvus.proto.milvus.Fl" + "ushRequest\032\033.milvus.proto.common.Status\"" + "\000\022O\n\005Query\022!.milvus.proto.milvus.QueryRe" + "quest\032!.milvus.proto.milvus.QueryResults" "\"\000\022\211\001\n\030GetPersistentSegmentInfo\0224.milvus" ".proto.milvus.GetPersistentSegmentInfoRe" "quest\0325.milvus.proto.milvus.GetPersisten" @@ -1931,7 +2001,7 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor &::descriptor_table_common_2eproto, &::descriptor_table_schema_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[55] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[57] = { &scc_info_BoolResponse_milvus_2eproto.base, &scc_info_CreateCollectionRequest_milvus_2eproto.base, &scc_info_CreateIndexRequest_milvus_2eproto.base, @@ -1971,6 +2041,8 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_PersistentSegmentInfo_milvus_2eproto.base, &scc_info_PlaceholderGroup_milvus_2eproto.base, &scc_info_PlaceholderValue_milvus_2eproto.base, + &scc_info_QueryRequest_milvus_2eproto.base, + &scc_info_QueryResults_milvus_2eproto.base, &scc_info_QuerySegmentInfo_milvus_2eproto.base, &scc_info_RegisterLinkRequest_milvus_2eproto.base, &scc_info_RegisterLinkResponse_milvus_2eproto.base, @@ -1991,10 +2063,10 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 10233, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 55, 2, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 10593, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 57, 2, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 55, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 57, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -21155,6 +21227,917 @@ void FlushRequest::InternalSwap(FlushRequest* other) { } +// =================================================================== + +void QueryRequest::InitAsDefaultInstance() { + ::milvus::proto::milvus::_QueryRequest_default_instance_._instance.get_mutable()->base_ = const_cast< ::milvus::proto::common::MsgBase*>( + ::milvus::proto::common::MsgBase::internal_default_instance()); +} +class QueryRequest::_Internal { + public: + static const ::milvus::proto::common::MsgBase& base(const QueryRequest* msg); +}; + +const ::milvus::proto::common::MsgBase& +QueryRequest::_Internal::base(const QueryRequest* msg) { + return *msg->base_; +} +void QueryRequest::clear_base() { + if (GetArenaNoVirtual() == nullptr && base_ != nullptr) { + delete base_; + } + base_ = nullptr; +} +QueryRequest::QueryRequest() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.QueryRequest) +} +QueryRequest::QueryRequest(const QueryRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + output_fields_(from.output_fields_), + partition_names_(from.partition_names_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.db_name().empty()) { + db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_); + } + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + expr_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.expr().empty()) { + expr_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.expr_); + } + if (from.has_base()) { + base_ = new ::milvus::proto::common::MsgBase(*from.base_); + } else { + base_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.QueryRequest) +} + +void QueryRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryRequest_milvus_2eproto.base); + db_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + expr_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + base_ = nullptr; +} + +QueryRequest::~QueryRequest() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.QueryRequest) + SharedDtor(); +} + +void QueryRequest::SharedDtor() { + db_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + expr_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete base_; +} + +void QueryRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const QueryRequest& QueryRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryRequest_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void QueryRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.QueryRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + output_fields_.Clear(); + partition_names_.Clear(); + db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + expr_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (GetArenaNoVirtual() == nullptr && base_ != nullptr) { + delete base_; + } + base_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* QueryRequest::_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.common.MsgBase base = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_base(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string db_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_db_name(), ptr, ctx, "milvus.proto.milvus.QueryRequest.db_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collection_name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.proto.milvus.QueryRequest.collection_name"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string expr = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_expr(), ptr, ctx, "milvus.proto.milvus.QueryRequest.expr"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string output_fields = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_output_fields(), ptr, ctx, "milvus.proto.milvus.QueryRequest.output_fields"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 42); + } else goto handle_unusual; + continue; + // repeated string partition_names = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_names(), ptr, ctx, "milvus.proto.milvus.QueryRequest.partition_names"); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 50); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + 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 QueryRequest::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.milvus.QueryRequest) + 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.common.MsgBase base = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_base())); + } else { + goto handle_unusual; + } + break; + } + + // string db_name = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_db_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->db_name().data(), static_cast(this->db_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.QueryRequest.db_name")); + } else { + goto handle_unusual; + } + break; + } + + // string collection_name = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collection_name())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.QueryRequest.collection_name")); + } else { + goto handle_unusual; + } + break; + } + + // string expr = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_expr())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->expr().data(), static_cast(this->expr().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.QueryRequest.expr")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string output_fields = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_output_fields())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->output_fields(this->output_fields_size() - 1).data(), + static_cast(this->output_fields(this->output_fields_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.QueryRequest.output_fields")); + } else { + goto handle_unusual; + } + break; + } + + // repeated string partition_names = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->add_partition_names())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_names(this->partition_names_size() - 1).data(), + static_cast(this->partition_names(this->partition_names_size() - 1).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.QueryRequest.partition_names")); + } 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.milvus.QueryRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.QueryRequest) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void QueryRequest::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.QueryRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.MsgBase base = 1; + if (this->has_base()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::base(this), output); + } + + // string db_name = 2; + if (this->db_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->db_name().data(), static_cast(this->db_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.db_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->db_name(), output); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.collection_name"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->collection_name(), output); + } + + // string expr = 4; + if (this->expr().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->expr().data(), static_cast(this->expr().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.expr"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->expr(), output); + } + + // repeated string output_fields = 5; + for (int i = 0, n = this->output_fields_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->output_fields(i).data(), static_cast(this->output_fields(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.output_fields"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 5, this->output_fields(i), output); + } + + // repeated string partition_names = 6; + for (int i = 0, n = this->partition_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_names(i).data(), static_cast(this->partition_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.partition_names"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( + 6, this->partition_names(i), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.proto.milvus.QueryRequest) +} + +::PROTOBUF_NAMESPACE_ID::uint8* QueryRequest::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.QueryRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.MsgBase base = 1; + if (this->has_base()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::base(this), target); + } + + // string db_name = 2; + if (this->db_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->db_name().data(), static_cast(this->db_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.db_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->db_name(), target); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collection_name().data(), static_cast(this->collection_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.collection_name"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->collection_name(), target); + } + + // string expr = 4; + if (this->expr().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->expr().data(), static_cast(this->expr().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.expr"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 4, this->expr(), target); + } + + // repeated string output_fields = 5; + for (int i = 0, n = this->output_fields_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->output_fields(i).data(), static_cast(this->output_fields(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.output_fields"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(5, this->output_fields(i), target); + } + + // repeated string partition_names = 6; + for (int i = 0, n = this->partition_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->partition_names(i).data(), static_cast(this->partition_names(i).length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.QueryRequest.partition_names"); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + WriteStringToArray(6, this->partition_names(i), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.milvus.QueryRequest) + return target; +} + +size_t QueryRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.QueryRequest) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string output_fields = 5; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->output_fields_size()); + for (int i = 0, n = this->output_fields_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->output_fields(i)); + } + + // repeated string partition_names = 6; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_names_size()); + for (int i = 0, n = this->partition_names_size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->partition_names(i)); + } + + // string db_name = 2; + if (this->db_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->db_name()); + } + + // string collection_name = 3; + if (this->collection_name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collection_name()); + } + + // string expr = 4; + if (this->expr().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->expr()); + } + + // .milvus.proto.common.MsgBase base = 1; + if (this->has_base()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *base_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void QueryRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.QueryRequest) + GOOGLE_DCHECK_NE(&from, this); + const QueryRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.QueryRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.QueryRequest) + MergeFrom(*source); + } +} + +void QueryRequest::MergeFrom(const QueryRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.QueryRequest) + 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_.MergeFrom(from.output_fields_); + partition_names_.MergeFrom(from.partition_names_); + if (from.db_name().size() > 0) { + + db_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.db_name_); + } + if (from.collection_name().size() > 0) { + + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); + } + if (from.expr().size() > 0) { + + expr_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.expr_); + } + if (from.has_base()) { + mutable_base()->::milvus::proto::common::MsgBase::MergeFrom(from.base()); + } +} + +void QueryRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.QueryRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryRequest::CopyFrom(const QueryRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.QueryRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryRequest::IsInitialized() const { + return true; +} + +void QueryRequest::InternalSwap(QueryRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + output_fields_.InternalSwap(CastToBase(&other->output_fields_)); + partition_names_.InternalSwap(CastToBase(&other->partition_names_)); + db_name_.Swap(&other->db_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + expr_.Swap(&other->expr_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(base_, other->base_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata QueryRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void QueryResults::InitAsDefaultInstance() { + ::milvus::proto::milvus::_QueryResults_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::proto::common::Status*>( + ::milvus::proto::common::Status::internal_default_instance()); +} +class QueryResults::_Internal { + public: + static const ::milvus::proto::common::Status& status(const QueryResults* msg); +}; + +const ::milvus::proto::common::Status& +QueryResults::_Internal::status(const QueryResults* msg) { + return *msg->status_; +} +void QueryResults::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +void QueryResults::clear_fields_data() { + fields_data_.Clear(); +} +QueryResults::QueryResults() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.QueryResults) +} +QueryResults::QueryResults(const QueryResults& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + fields_data_(from.fields_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_status()) { + status_ = new ::milvus::proto::common::Status(*from.status_); + } else { + status_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.QueryResults) +} + +void QueryResults::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_QueryResults_milvus_2eproto.base); + status_ = nullptr; +} + +QueryResults::~QueryResults() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.QueryResults) + SharedDtor(); +} + +void QueryResults::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void QueryResults::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const QueryResults& QueryResults::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryResults_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void QueryResults::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.QueryResults) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_data_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* QueryResults::_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.common.Status status = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(mutable_status(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .milvus.proto.schema.FieldData fields_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_fields_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool QueryResults::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.milvus.QueryResults) + 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.common.Status status = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, mutable_status())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .milvus.proto.schema.FieldData fields_data = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_fields_data())); + } 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.milvus.QueryResults) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.QueryResults) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void QueryResults::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.QueryResults) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.Status status = 1; + if (this->has_status()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, _Internal::status(this), output); + } + + // repeated .milvus.proto.schema.FieldData fields_data = 2; + for (unsigned int i = 0, + n = static_cast(this->fields_data_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->fields_data(static_cast(i)), + output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:milvus.proto.milvus.QueryResults) +} + +::PROTOBUF_NAMESPACE_ID::uint8* QueryResults::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.QueryResults) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .milvus.proto.common.Status status = 1; + if (this->has_status()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, _Internal::status(this), target); + } + + // repeated .milvus.proto.schema.FieldData fields_data = 2; + for (unsigned int i = 0, + n = static_cast(this->fields_data_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->fields_data(static_cast(i)), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:milvus.proto.milvus.QueryResults) + return target; +} + +size_t QueryResults::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.QueryResults) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .milvus.proto.schema.FieldData fields_data = 2; + { + unsigned int count = static_cast(this->fields_data_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->fields_data(static_cast(i))); + } + } + + // .milvus.proto.common.Status status = 1; + if (this->has_status()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *status_); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void QueryResults::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.QueryResults) + GOOGLE_DCHECK_NE(&from, this); + const QueryResults* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.QueryResults) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.QueryResults) + MergeFrom(*source); + } +} + +void QueryResults::MergeFrom(const QueryResults& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.QueryResults) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_data_.MergeFrom(from.fields_data_); + if (from.has_status()) { + mutable_status()->::milvus::proto::common::Status::MergeFrom(from.status()); + } +} + +void QueryResults::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.QueryResults) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void QueryResults::CopyFrom(const QueryResults& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.QueryResults) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool QueryResults::IsInitialized() const { + return true; +} + +void QueryResults::InternalSwap(QueryResults* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&fields_data_)->InternalSwap(CastToBase(&other->fields_data_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata QueryResults::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void PersistentSegmentInfo::InitAsDefaultInstance() { @@ -24767,6 +25750,12 @@ template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::SearchResults* Arena::Crea template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::FlushRequest* Arena::CreateMaybeMessage< ::milvus::proto::milvus::FlushRequest >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::milvus::FlushRequest >(arena); } +template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::QueryRequest* Arena::CreateMaybeMessage< ::milvus::proto::milvus::QueryRequest >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::QueryRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::QueryResults* Arena::CreateMaybeMessage< ::milvus::proto::milvus::QueryResults >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::QueryResults >(arena); +} template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::PersistentSegmentInfo* Arena::CreateMaybeMessage< ::milvus::proto::milvus::PersistentSegmentInfo >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::milvus::PersistentSegmentInfo >(arena); } diff --git a/internal/core/src/pb/milvus.pb.h b/internal/core/src/pb/milvus.pb.h index 107a4896a3..e02a4b5768 100644 --- a/internal/core/src/pb/milvus.pb.h +++ b/internal/core/src/pb/milvus.pb.h @@ -50,7 +50,7 @@ struct TableStruct_milvus_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[55] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[57] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -177,6 +177,12 @@ extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_; class PlaceholderValue; class PlaceholderValueDefaultTypeInternal; extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_; +class QueryRequest; +class QueryRequestDefaultTypeInternal; +extern QueryRequestDefaultTypeInternal _QueryRequest_default_instance_; +class QueryResults; +class QueryResultsDefaultTypeInternal; +extern QueryResultsDefaultTypeInternal _QueryResults_default_instance_; class QuerySegmentInfo; class QuerySegmentInfoDefaultTypeInternal; extern QuerySegmentInfoDefaultTypeInternal _QuerySegmentInfo_default_instance_; @@ -268,6 +274,8 @@ template<> ::milvus::proto::milvus::LoadPartitionsRequest* Arena::CreateMaybeMes template<> ::milvus::proto::milvus::PersistentSegmentInfo* Arena::CreateMaybeMessage<::milvus::proto::milvus::PersistentSegmentInfo>(Arena*); template<> ::milvus::proto::milvus::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderGroup>(Arena*); template<> ::milvus::proto::milvus::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::milvus::PlaceholderValue>(Arena*); +template<> ::milvus::proto::milvus::QueryRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::QueryRequest>(Arena*); +template<> ::milvus::proto::milvus::QueryResults* Arena::CreateMaybeMessage<::milvus::proto::milvus::QueryResults>(Arena*); template<> ::milvus::proto::milvus::QuerySegmentInfo* Arena::CreateMaybeMessage<::milvus::proto::milvus::QuerySegmentInfo>(Arena*); template<> ::milvus::proto::milvus::RegisterLinkRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkRequest>(Arena*); template<> ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkResponse>(Arena*); @@ -7849,6 +7857,364 @@ class FlushRequest : }; // ------------------------------------------------------------------- +class QueryRequest : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.QueryRequest) */ { + public: + QueryRequest(); + virtual ~QueryRequest(); + + QueryRequest(const QueryRequest& from); + QueryRequest(QueryRequest&& from) noexcept + : QueryRequest() { + *this = ::std::move(from); + } + + inline QueryRequest& operator=(const QueryRequest& from) { + CopyFrom(from); + return *this; + } + inline QueryRequest& operator=(QueryRequest&& 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 QueryRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const QueryRequest* internal_default_instance() { + return reinterpret_cast( + &_QueryRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(QueryRequest& a, QueryRequest& b) { + a.Swap(&b); + } + inline void Swap(QueryRequest* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline QueryRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + QueryRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const QueryRequest& from); + void MergeFrom(const QueryRequest& 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(QueryRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.QueryRequest"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOutputFieldsFieldNumber = 5, + kPartitionNamesFieldNumber = 6, + kDbNameFieldNumber = 2, + kCollectionNameFieldNumber = 3, + kExprFieldNumber = 4, + kBaseFieldNumber = 1, + }; + // repeated string output_fields = 5; + int output_fields_size() const; + void clear_output_fields(); + const std::string& output_fields(int index) const; + std::string* mutable_output_fields(int index); + void set_output_fields(int index, const std::string& value); + void set_output_fields(int index, std::string&& value); + void set_output_fields(int index, const char* value); + void set_output_fields(int index, const char* value, size_t size); + std::string* add_output_fields(); + void add_output_fields(const std::string& value); + void add_output_fields(std::string&& value); + void add_output_fields(const char* value); + void add_output_fields(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& output_fields() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_output_fields(); + + // repeated string partition_names = 6; + int partition_names_size() const; + void clear_partition_names(); + const std::string& partition_names(int index) const; + std::string* mutable_partition_names(int index); + void set_partition_names(int index, const std::string& value); + void set_partition_names(int index, std::string&& value); + void set_partition_names(int index, const char* value); + void set_partition_names(int index, const char* value, size_t size); + std::string* add_partition_names(); + void add_partition_names(const std::string& value); + void add_partition_names(std::string&& value); + void add_partition_names(const char* value); + void add_partition_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& partition_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_partition_names(); + + // string db_name = 2; + void clear_db_name(); + const std::string& db_name() const; + void set_db_name(const std::string& value); + void set_db_name(std::string&& value); + void set_db_name(const char* value); + void set_db_name(const char* value, size_t size); + std::string* mutable_db_name(); + std::string* release_db_name(); + void set_allocated_db_name(std::string* db_name); + + // string collection_name = 3; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); + + // string expr = 4; + void clear_expr(); + const std::string& expr() const; + void set_expr(const std::string& value); + void set_expr(std::string&& value); + void set_expr(const char* value); + void set_expr(const char* value, size_t size); + std::string* mutable_expr(); + std::string* release_expr(); + void set_allocated_expr(std::string* expr); + + // .milvus.proto.common.MsgBase base = 1; + bool has_base() const; + void clear_base(); + const ::milvus::proto::common::MsgBase& base() const; + ::milvus::proto::common::MsgBase* release_base(); + ::milvus::proto::common::MsgBase* mutable_base(); + void set_allocated_base(::milvus::proto::common::MsgBase* base); + + // @@protoc_insertion_point(class_scope:milvus.proto.milvus.QueryRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField output_fields_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_names_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr db_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr expr_; + ::milvus::proto::common::MsgBase* base_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class QueryResults : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.QueryResults) */ { + public: + QueryResults(); + virtual ~QueryResults(); + + QueryResults(const QueryResults& from); + QueryResults(QueryResults&& from) noexcept + : QueryResults() { + *this = ::std::move(from); + } + + inline QueryResults& operator=(const QueryResults& from) { + CopyFrom(from); + return *this; + } + inline QueryResults& operator=(QueryResults&& 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 QueryResults& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const QueryResults* internal_default_instance() { + return reinterpret_cast( + &_QueryResults_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(QueryResults& a, QueryResults& b) { + a.Swap(&b); + } + inline void Swap(QueryResults* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline QueryResults* New() const final { + return CreateMaybeMessage(nullptr); + } + + QueryResults* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const QueryResults& from); + void MergeFrom(const QueryResults& 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(QueryResults* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.QueryResults"; + } + private: + inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { + return nullptr; + } + inline void* MaybeArenaPtr() const { + return nullptr; + } + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + private: + static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto); + return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages]; + } + + public: + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldsDataFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated .milvus.proto.schema.FieldData fields_data = 2; + int fields_data_size() const; + void clear_fields_data(); + ::milvus::proto::schema::FieldData* mutable_fields_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >* + mutable_fields_data(); + const ::milvus::proto::schema::FieldData& fields_data(int index) const; + ::milvus::proto::schema::FieldData* add_fields_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >& + fields_data() const; + + // .milvus.proto.common.Status status = 1; + bool has_status() const; + void clear_status(); + const ::milvus::proto::common::Status& status() const; + ::milvus::proto::common::Status* release_status(); + ::milvus::proto::common::Status* mutable_status(); + void set_allocated_status(::milvus::proto::common::Status* status); + + // @@protoc_insertion_point(class_scope:milvus.proto.milvus.QueryResults) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData > fields_data_; + ::milvus::proto::common::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + class PersistentSegmentInfo : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.PersistentSegmentInfo) */ { public: @@ -7891,7 +8257,7 @@ class PersistentSegmentInfo : &_PersistentSegmentInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 45; + 47; friend void swap(PersistentSegmentInfo& a, PersistentSegmentInfo& b) { a.Swap(&b); @@ -8050,7 +8416,7 @@ class GetPersistentSegmentInfoRequest : &_GetPersistentSegmentInfoRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 46; + 48; friend void swap(GetPersistentSegmentInfoRequest& a, GetPersistentSegmentInfoRequest& b) { a.Swap(&b); @@ -8210,7 +8576,7 @@ class GetPersistentSegmentInfoResponse : &_GetPersistentSegmentInfoResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 47; + 49; friend void swap(GetPersistentSegmentInfoResponse& a, GetPersistentSegmentInfoResponse& b) { a.Swap(&b); @@ -8357,7 +8723,7 @@ class QuerySegmentInfo : &_QuerySegmentInfo_default_instance_); } static constexpr int kIndexInFileMessages = - 48; + 50; friend void swap(QuerySegmentInfo& a, QuerySegmentInfo& b) { a.Swap(&b); @@ -8536,7 +8902,7 @@ class GetQuerySegmentInfoRequest : &_GetQuerySegmentInfoRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 49; + 51; friend void swap(GetQuerySegmentInfoRequest& a, GetQuerySegmentInfoRequest& b) { a.Swap(&b); @@ -8696,7 +9062,7 @@ class GetQuerySegmentInfoResponse : &_GetQuerySegmentInfoResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 50; + 52; friend void swap(GetQuerySegmentInfoResponse& a, GetQuerySegmentInfoResponse& b) { a.Swap(&b); @@ -8843,7 +9209,7 @@ class DummyRequest : &_DummyRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 51; + 53; friend void swap(DummyRequest& a, DummyRequest& b) { a.Swap(&b); @@ -8980,7 +9346,7 @@ class DummyResponse : &_DummyResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 52; + 54; friend void swap(DummyResponse& a, DummyResponse& b) { a.Swap(&b); @@ -9117,7 +9483,7 @@ class RegisterLinkRequest : &_RegisterLinkRequest_default_instance_); } static constexpr int kIndexInFileMessages = - 53; + 55; friend void swap(RegisterLinkRequest& a, RegisterLinkRequest& b) { a.Swap(&b); @@ -9239,7 +9605,7 @@ class RegisterLinkResponse : &_RegisterLinkResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 54; + 56; friend void swap(RegisterLinkResponse& a, RegisterLinkResponse& b) { a.Swap(&b); @@ -16535,6 +16901,414 @@ FlushRequest::mutable_collection_names() { // ------------------------------------------------------------------- +// QueryRequest + +// .milvus.proto.common.MsgBase base = 1; +inline bool QueryRequest::has_base() const { + return this != internal_default_instance() && base_ != nullptr; +} +inline const ::milvus::proto::common::MsgBase& QueryRequest::base() const { + const ::milvus::proto::common::MsgBase* p = base_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.base) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_MsgBase_default_instance_); +} +inline ::milvus::proto::common::MsgBase* QueryRequest::release_base() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.QueryRequest.base) + + ::milvus::proto::common::MsgBase* temp = base_; + base_ = nullptr; + return temp; +} +inline ::milvus::proto::common::MsgBase* QueryRequest::mutable_base() { + + if (base_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual()); + base_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.base) + return base_; +} +inline void QueryRequest::set_allocated_base(::milvus::proto::common::MsgBase* base) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_); + } + if (base) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + base = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, base, submessage_arena); + } + + } else { + + } + base_ = base; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QueryRequest.base) +} + +// string db_name = 2; +inline void QueryRequest::clear_db_name() { + db_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& QueryRequest::db_name() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.db_name) + return db_name_.GetNoArena(); +} +inline void QueryRequest::set_db_name(const std::string& value) { + + db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.db_name) +} +inline void QueryRequest::set_db_name(std::string&& value) { + + db_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QueryRequest.db_name) +} +inline void QueryRequest::set_db_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QueryRequest.db_name) +} +inline void QueryRequest::set_db_name(const char* value, size_t size) { + + db_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QueryRequest.db_name) +} +inline std::string* QueryRequest::mutable_db_name() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.db_name) + return db_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* QueryRequest::release_db_name() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.QueryRequest.db_name) + + return db_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void QueryRequest::set_allocated_db_name(std::string* db_name) { + if (db_name != nullptr) { + + } else { + + } + db_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), db_name); + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QueryRequest.db_name) +} + +// string collection_name = 3; +inline void QueryRequest::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& QueryRequest::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.collection_name) + return collection_name_.GetNoArena(); +} +inline void QueryRequest::set_collection_name(const std::string& value) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.collection_name) +} +inline void QueryRequest::set_collection_name(std::string&& value) { + + collection_name_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QueryRequest.collection_name) +} +inline void QueryRequest::set_collection_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QueryRequest.collection_name) +} +inline void QueryRequest::set_collection_name(const char* value, size_t size) { + + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QueryRequest.collection_name) +} +inline std::string* QueryRequest::mutable_collection_name() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* QueryRequest::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.QueryRequest.collection_name) + + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void QueryRequest::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { + + } else { + + } + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QueryRequest.collection_name) +} + +// string expr = 4; +inline void QueryRequest::clear_expr() { + expr_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& QueryRequest::expr() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.expr) + return expr_.GetNoArena(); +} +inline void QueryRequest::set_expr(const std::string& value) { + + expr_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.expr) +} +inline void QueryRequest::set_expr(std::string&& value) { + + expr_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.QueryRequest.expr) +} +inline void QueryRequest::set_expr(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + expr_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QueryRequest.expr) +} +inline void QueryRequest::set_expr(const char* value, size_t size) { + + expr_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QueryRequest.expr) +} +inline std::string* QueryRequest::mutable_expr() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.expr) + return expr_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* QueryRequest::release_expr() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.QueryRequest.expr) + + return expr_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void QueryRequest::set_allocated_expr(std::string* expr) { + if (expr != nullptr) { + + } else { + + } + expr_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), expr); + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QueryRequest.expr) +} + +// repeated string output_fields = 5; +inline int QueryRequest::output_fields_size() const { + return output_fields_.size(); +} +inline void QueryRequest::clear_output_fields() { + output_fields_.Clear(); +} +inline const std::string& QueryRequest::output_fields(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.output_fields) + return output_fields_.Get(index); +} +inline std::string* QueryRequest::mutable_output_fields(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.output_fields) + return output_fields_.Mutable(index); +} +inline void QueryRequest::set_output_fields(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.output_fields) + output_fields_.Mutable(index)->assign(value); +} +inline void QueryRequest::set_output_fields(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.output_fields) + output_fields_.Mutable(index)->assign(std::move(value)); +} +inline void QueryRequest::set_output_fields(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + output_fields_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QueryRequest.output_fields) +} +inline void QueryRequest::set_output_fields(int index, const char* value, size_t size) { + output_fields_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QueryRequest.output_fields) +} +inline std::string* QueryRequest::add_output_fields() { + // @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.QueryRequest.output_fields) + return output_fields_.Add(); +} +inline void QueryRequest::add_output_fields(const std::string& value) { + output_fields_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.proto.milvus.QueryRequest.output_fields) +} +inline void QueryRequest::add_output_fields(std::string&& value) { + output_fields_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.proto.milvus.QueryRequest.output_fields) +} +inline void QueryRequest::add_output_fields(const char* value) { + GOOGLE_DCHECK(value != nullptr); + output_fields_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.proto.milvus.QueryRequest.output_fields) +} +inline void QueryRequest::add_output_fields(const char* value, size_t size) { + output_fields_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.QueryRequest.output_fields) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +QueryRequest::output_fields() const { + // @@protoc_insertion_point(field_list:milvus.proto.milvus.QueryRequest.output_fields) + return output_fields_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +QueryRequest::mutable_output_fields() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.QueryRequest.output_fields) + return &output_fields_; +} + +// repeated string partition_names = 6; +inline int QueryRequest::partition_names_size() const { + return partition_names_.size(); +} +inline void QueryRequest::clear_partition_names() { + partition_names_.Clear(); +} +inline const std::string& QueryRequest::partition_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryRequest.partition_names) + return partition_names_.Get(index); +} +inline std::string* QueryRequest::mutable_partition_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryRequest.partition_names) + return partition_names_.Mutable(index); +} +inline void QueryRequest::set_partition_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.partition_names) + partition_names_.Mutable(index)->assign(value); +} +inline void QueryRequest::set_partition_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.proto.milvus.QueryRequest.partition_names) + partition_names_.Mutable(index)->assign(std::move(value)); +} +inline void QueryRequest::set_partition_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.QueryRequest.partition_names) +} +inline void QueryRequest::set_partition_names(int index, const char* value, size_t size) { + partition_names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.QueryRequest.partition_names) +} +inline std::string* QueryRequest::add_partition_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.proto.milvus.QueryRequest.partition_names) + return partition_names_.Add(); +} +inline void QueryRequest::add_partition_names(const std::string& value) { + partition_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.proto.milvus.QueryRequest.partition_names) +} +inline void QueryRequest::add_partition_names(std::string&& value) { + partition_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.proto.milvus.QueryRequest.partition_names) +} +inline void QueryRequest::add_partition_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + partition_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.proto.milvus.QueryRequest.partition_names) +} +inline void QueryRequest::add_partition_names(const char* value, size_t size) { + partition_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.proto.milvus.QueryRequest.partition_names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +QueryRequest::partition_names() const { + // @@protoc_insertion_point(field_list:milvus.proto.milvus.QueryRequest.partition_names) + return partition_names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +QueryRequest::mutable_partition_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.QueryRequest.partition_names) + return &partition_names_; +} + +// ------------------------------------------------------------------- + +// QueryResults + +// .milvus.proto.common.Status status = 1; +inline bool QueryResults::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::proto::common::Status& QueryResults::status() const { + const ::milvus::proto::common::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryResults.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_Status_default_instance_); +} +inline ::milvus::proto::common::Status* QueryResults::release_status() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.QueryResults.status) + + ::milvus::proto::common::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::proto::common::Status* QueryResults::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryResults.status) + return status_; +} +inline void QueryResults::set_allocated_status(::milvus::proto::common::Status* status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); + } + if (status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr; + if (message_arena != submessage_arena) { + status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, status, submessage_arena); + } + + } else { + + } + status_ = status; + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.QueryResults.status) +} + +// repeated .milvus.proto.schema.FieldData fields_data = 2; +inline int QueryResults::fields_data_size() const { + return fields_data_.size(); +} +inline ::milvus::proto::schema::FieldData* QueryResults::mutable_fields_data(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.QueryResults.fields_data) + return fields_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >* +QueryResults::mutable_fields_data() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.QueryResults.fields_data) + return &fields_data_; +} +inline const ::milvus::proto::schema::FieldData& QueryResults::fields_data(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.QueryResults.fields_data) + return fields_data_.Get(index); +} +inline ::milvus::proto::schema::FieldData* QueryResults::add_fields_data() { + // @@protoc_insertion_point(field_add:milvus.proto.milvus.QueryResults.fields_data) + return fields_data_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::schema::FieldData >& +QueryResults::fields_data() const { + // @@protoc_insertion_point(field_list:milvus.proto.milvus.QueryResults.fields_data) + return fields_data_; +} + +// ------------------------------------------------------------------- + // PersistentSegmentInfo // int64 segmentID = 1; @@ -17525,6 +18299,10 @@ inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common:: // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/internal/distributed/proxynode/service.go b/internal/distributed/proxynode/service.go index 27b639d7a8..ada34fcb3f 100644 --- a/internal/distributed/proxynode/service.go +++ b/internal/distributed/proxynode/service.go @@ -395,6 +395,10 @@ func (s *Server) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*co return s.proxynode.Flush(ctx, request) } +func (s *Server) Query(ctx context.Context, request *milvuspb.QueryRequest) (*milvuspb.QueryResults, error) { + return s.proxynode.Query(ctx, request) +} + func (s *Server) GetDdChannel(ctx context.Context, request *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) { return s.proxynode.GetDdChannel(ctx, request) } diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto index 970f0e8cee..b5d6802a23 100644 --- a/internal/proto/milvus.proto +++ b/internal/proto/milvus.proto @@ -34,6 +34,7 @@ service MilvusService { rpc Search(SearchRequest) returns (SearchResults) {} rpc Retrieve(RetrieveRequest) returns (RetrieveResults) {} rpc Flush(FlushRequest) returns (common.Status) {} + rpc Query(QueryRequest) returns (QueryResults) {} rpc GetPersistentSegmentInfo(GetPersistentSegmentInfoRequest) returns (GetPersistentSegmentInfoResponse) {} rpc GetQuerySegmentInfo(GetQuerySegmentInfoRequest) returns (GetQuerySegmentInfoResponse) {} @@ -356,6 +357,20 @@ message FlushRequest { repeated string collection_names = 3; } +message QueryRequest { + common.MsgBase base = 1; + string db_name = 2; + string collection_name = 3; + string expr = 4; + repeated string output_fields = 5; + repeated string partition_names = 6; +} + +message QueryResults { + common.Status status = 1; + repeated schema.FieldData fields_data = 2; +} + message PersistentSegmentInfo { int64 segmentID = 1; int64 collectionID = 2; diff --git a/internal/proto/milvuspb/milvus.pb.go b/internal/proto/milvuspb/milvus.pb.go index 7909560349..2c03f89789 100644 --- a/internal/proto/milvuspb/milvus.pb.go +++ b/internal/proto/milvuspb/milvus.pb.go @@ -2781,6 +2781,132 @@ func (m *FlushRequest) GetCollectionNames() []string { return nil } +type QueryRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"` + CollectionName string `protobuf:"bytes,3,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"` + Expr string `protobuf:"bytes,4,opt,name=expr,proto3" json:"expr,omitempty"` + OutputFields []string `protobuf:"bytes,5,rep,name=output_fields,json=outputFields,proto3" json:"output_fields,omitempty"` + PartitionNames []string `protobuf:"bytes,6,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryRequest) Reset() { *m = QueryRequest{} } +func (m *QueryRequest) String() string { return proto.CompactTextString(m) } +func (*QueryRequest) ProtoMessage() {} +func (*QueryRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_02345ba45cc0e303, []int{45} +} + +func (m *QueryRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryRequest.Unmarshal(m, b) +} +func (m *QueryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryRequest.Marshal(b, m, deterministic) +} +func (m *QueryRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRequest.Merge(m, src) +} +func (m *QueryRequest) XXX_Size() int { + return xxx_messageInfo_QueryRequest.Size(m) +} +func (m *QueryRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRequest proto.InternalMessageInfo + +func (m *QueryRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + +func (m *QueryRequest) GetDbName() string { + if m != nil { + return m.DbName + } + return "" +} + +func (m *QueryRequest) GetCollectionName() string { + if m != nil { + return m.CollectionName + } + return "" +} + +func (m *QueryRequest) GetExpr() string { + if m != nil { + return m.Expr + } + return "" +} + +func (m *QueryRequest) GetOutputFields() []string { + if m != nil { + return m.OutputFields + } + return nil +} + +func (m *QueryRequest) GetPartitionNames() []string { + if m != nil { + return m.PartitionNames + } + return nil +} + +type QueryResults struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + FieldsData []*schemapb.FieldData `protobuf:"bytes,2,rep,name=fields_data,json=fieldsData,proto3" json:"fields_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryResults) Reset() { *m = QueryResults{} } +func (m *QueryResults) String() string { return proto.CompactTextString(m) } +func (*QueryResults) ProtoMessage() {} +func (*QueryResults) Descriptor() ([]byte, []int) { + return fileDescriptor_02345ba45cc0e303, []int{46} +} + +func (m *QueryResults) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_QueryResults.Unmarshal(m, b) +} +func (m *QueryResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_QueryResults.Marshal(b, m, deterministic) +} +func (m *QueryResults) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryResults.Merge(m, src) +} +func (m *QueryResults) XXX_Size() int { + return xxx_messageInfo_QueryResults.Size(m) +} +func (m *QueryResults) XXX_DiscardUnknown() { + xxx_messageInfo_QueryResults.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryResults proto.InternalMessageInfo + +func (m *QueryResults) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *QueryResults) GetFieldsData() []*schemapb.FieldData { + if m != nil { + return m.FieldsData + } + return nil +} + type PersistentSegmentInfo struct { SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"` @@ -2796,7 +2922,7 @@ func (m *PersistentSegmentInfo) Reset() { *m = PersistentSegmentInfo{} } func (m *PersistentSegmentInfo) String() string { return proto.CompactTextString(m) } func (*PersistentSegmentInfo) ProtoMessage() {} func (*PersistentSegmentInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{45} + return fileDescriptor_02345ba45cc0e303, []int{47} } func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error { @@ -2865,7 +2991,7 @@ func (m *GetPersistentSegmentInfoRequest) Reset() { *m = GetPersistentSe func (m *GetPersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetPersistentSegmentInfoRequest) ProtoMessage() {} func (*GetPersistentSegmentInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{46} + return fileDescriptor_02345ba45cc0e303, []int{48} } func (m *GetPersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error { @@ -2919,7 +3045,7 @@ func (m *GetPersistentSegmentInfoResponse) Reset() { *m = GetPersistentS func (m *GetPersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetPersistentSegmentInfoResponse) ProtoMessage() {} func (*GetPersistentSegmentInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{47} + return fileDescriptor_02345ba45cc0e303, []int{49} } func (m *GetPersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error { @@ -2971,7 +3097,7 @@ func (m *QuerySegmentInfo) Reset() { *m = QuerySegmentInfo{} } func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) } func (*QuerySegmentInfo) ProtoMessage() {} func (*QuerySegmentInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{48} + return fileDescriptor_02345ba45cc0e303, []int{50} } func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error { @@ -3054,7 +3180,7 @@ func (m *GetQuerySegmentInfoRequest) Reset() { *m = GetQuerySegmentInfoR func (m *GetQuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetQuerySegmentInfoRequest) ProtoMessage() {} func (*GetQuerySegmentInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{49} + return fileDescriptor_02345ba45cc0e303, []int{51} } func (m *GetQuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error { @@ -3108,7 +3234,7 @@ func (m *GetQuerySegmentInfoResponse) Reset() { *m = GetQuerySegmentInfo func (m *GetQuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetQuerySegmentInfoResponse) ProtoMessage() {} func (*GetQuerySegmentInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{50} + return fileDescriptor_02345ba45cc0e303, []int{52} } func (m *GetQuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error { @@ -3154,7 +3280,7 @@ func (m *DummyRequest) Reset() { *m = DummyRequest{} } func (m *DummyRequest) String() string { return proto.CompactTextString(m) } func (*DummyRequest) ProtoMessage() {} func (*DummyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{51} + return fileDescriptor_02345ba45cc0e303, []int{53} } func (m *DummyRequest) XXX_Unmarshal(b []byte) error { @@ -3193,7 +3319,7 @@ func (m *DummyResponse) Reset() { *m = DummyResponse{} } func (m *DummyResponse) String() string { return proto.CompactTextString(m) } func (*DummyResponse) ProtoMessage() {} func (*DummyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{52} + return fileDescriptor_02345ba45cc0e303, []int{54} } func (m *DummyResponse) XXX_Unmarshal(b []byte) error { @@ -3231,7 +3357,7 @@ func (m *RegisterLinkRequest) Reset() { *m = RegisterLinkRequest{} } func (m *RegisterLinkRequest) String() string { return proto.CompactTextString(m) } func (*RegisterLinkRequest) ProtoMessage() {} func (*RegisterLinkRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{53} + return fileDescriptor_02345ba45cc0e303, []int{55} } func (m *RegisterLinkRequest) XXX_Unmarshal(b []byte) error { @@ -3264,7 +3390,7 @@ func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} } func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) } func (*RegisterLinkResponse) ProtoMessage() {} func (*RegisterLinkResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_02345ba45cc0e303, []int{54} + return fileDescriptor_02345ba45cc0e303, []int{56} } func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error { @@ -3347,6 +3473,8 @@ func init() { proto.RegisterType((*Hits)(nil), "milvus.proto.milvus.Hits") proto.RegisterType((*SearchResults)(nil), "milvus.proto.milvus.SearchResults") proto.RegisterType((*FlushRequest)(nil), "milvus.proto.milvus.FlushRequest") + proto.RegisterType((*QueryRequest)(nil), "milvus.proto.milvus.QueryRequest") + proto.RegisterType((*QueryResults)(nil), "milvus.proto.milvus.QueryResults") proto.RegisterType((*PersistentSegmentInfo)(nil), "milvus.proto.milvus.PersistentSegmentInfo") proto.RegisterType((*GetPersistentSegmentInfoRequest)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoRequest") proto.RegisterType((*GetPersistentSegmentInfoResponse)(nil), "milvus.proto.milvus.GetPersistentSegmentInfoResponse") @@ -3362,154 +3490,158 @@ func init() { func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) } var fileDescriptor_02345ba45cc0e303 = []byte{ - // 2347 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x6f, 0x1c, 0x49, - 0x15, 0x77, 0xcd, 0x78, 0xc6, 0x9e, 0x37, 0x3d, 0xf6, 0xa4, 0xfc, 0x91, 0xd9, 0xc9, 0x97, 0xd3, - 0xbb, 0x61, 0x9d, 0x8f, 0x75, 0x76, 0x9d, 0x0d, 0x01, 0xf1, 0xb9, 0x8e, 0x89, 0x33, 0xca, 0x26, - 0xf2, 0xf6, 0x2c, 0xab, 0x5d, 0x56, 0xd1, 0xa8, 0x67, 0xba, 0xe2, 0x69, 0xa5, 0x3f, 0x86, 0xae, - 0x1e, 0x3b, 0x93, 0x13, 0xd2, 0x22, 0x04, 0x02, 0xb2, 0x07, 0x10, 0x12, 0x1c, 0x10, 0x42, 0xda, - 0x03, 0x27, 0x40, 0x20, 0x21, 0x21, 0x0e, 0x1c, 0xf6, 0xc0, 0x0d, 0xc4, 0xff, 0xc0, 0x0d, 0xfe, - 0x06, 0x50, 0x57, 0x55, 0xf7, 0x74, 0xb7, 0xab, 0xc7, 0xe3, 0xcc, 0x06, 0xdb, 0xb7, 0xee, 0xd7, - 0xaf, 0xaa, 0x5e, 0xfd, 0xea, 0xbd, 0x57, 0xef, 0xa3, 0x41, 0xb1, 0x4d, 0x6b, 0xb7, 0x4f, 0xd7, - 0x7a, 0x9e, 0xeb, 0xbb, 0x78, 0x21, 0xfe, 0xb6, 0xc6, 0x5f, 0xea, 0x4a, 0xc7, 0xb5, 0x6d, 0xd7, - 0xe1, 0xc4, 0xba, 0x42, 0x3b, 0x5d, 0x62, 0xeb, 0xfc, 0x4d, 0xfd, 0x14, 0xc1, 0xe9, 0xdb, 0x1e, - 0xd1, 0x7d, 0x72, 0xdb, 0xb5, 0x2c, 0xd2, 0xf1, 0x4d, 0xd7, 0xd1, 0xc8, 0xb7, 0xfb, 0x84, 0xfa, - 0xf8, 0x75, 0x98, 0x6e, 0xeb, 0x94, 0xd4, 0xd0, 0x0a, 0x5a, 0x2d, 0xaf, 0x9f, 0x5d, 0x4b, 0xcc, - 0x2d, 0xe6, 0xbc, 0x4f, 0x77, 0x36, 0x74, 0x4a, 0x34, 0xc6, 0x89, 0x4f, 0xc3, 0x8c, 0xd1, 0x6e, - 0x39, 0xba, 0x4d, 0x6a, 0xb9, 0x15, 0xb4, 0x5a, 0xd2, 0x8a, 0x46, 0xfb, 0x81, 0x6e, 0x13, 0xfc, - 0x2a, 0xcc, 0x77, 0xa2, 0xf9, 0x39, 0x43, 0x9e, 0x31, 0xcc, 0x0d, 0xc9, 0x8c, 0x71, 0x19, 0x8a, - 0x5c, 0xbe, 0xda, 0xf4, 0x0a, 0x5a, 0x55, 0x34, 0xf1, 0x86, 0xcf, 0x01, 0xd0, 0xae, 0xee, 0x19, - 0xb4, 0xe5, 0xf4, 0xed, 0x5a, 0x61, 0x05, 0xad, 0x16, 0xb4, 0x12, 0xa7, 0x3c, 0xe8, 0xdb, 0xea, - 0x0f, 0x11, 0x2c, 0x6d, 0x7a, 0x6e, 0xef, 0x58, 0x6c, 0x42, 0xfd, 0x0d, 0x82, 0xc5, 0xbb, 0x3a, - 0x3d, 0x1e, 0x88, 0x9e, 0x03, 0xf0, 0x4d, 0x9b, 0xb4, 0xa8, 0xaf, 0xdb, 0x3d, 0x86, 0xea, 0xb4, - 0x56, 0x0a, 0x28, 0xcd, 0x80, 0xa0, 0x7e, 0x00, 0xca, 0x86, 0xeb, 0x5a, 0x1a, 0xa1, 0x3d, 0xd7, - 0xa1, 0x04, 0xdf, 0x80, 0x22, 0xf5, 0x75, 0xbf, 0x4f, 0x85, 0x90, 0x67, 0xa4, 0x42, 0x36, 0x19, - 0x8b, 0x26, 0x58, 0xf1, 0x22, 0x14, 0x76, 0x75, 0xab, 0xcf, 0x65, 0x9c, 0xd5, 0xf8, 0x8b, 0xfa, - 0x21, 0xcc, 0x35, 0x7d, 0xcf, 0x74, 0x76, 0x3e, 0xc3, 0xc9, 0x4b, 0xe1, 0xe4, 0xff, 0x44, 0xf0, - 0xd2, 0x26, 0xa1, 0x1d, 0xcf, 0x6c, 0x1f, 0x13, 0xd5, 0x55, 0x41, 0x19, 0x52, 0x1a, 0x9b, 0x0c, - 0xea, 0xbc, 0x96, 0xa0, 0xa5, 0x0e, 0xa3, 0x90, 0x3e, 0x8c, 0x5f, 0xe6, 0xa0, 0x2e, 0xdb, 0xd4, - 0x24, 0xf0, 0x7d, 0x25, 0xb2, 0xa8, 0x1c, 0x1b, 0x74, 0x29, 0x39, 0x48, 0x78, 0x83, 0xe1, 0x6a, - 0x4d, 0x46, 0x88, 0x0c, 0x2f, 0xbd, 0xab, 0xbc, 0x64, 0x57, 0xeb, 0xb0, 0xb4, 0x6b, 0x7a, 0x7e, - 0x5f, 0xb7, 0x5a, 0x9d, 0xae, 0xee, 0x38, 0xc4, 0x62, 0x38, 0xd1, 0xda, 0xf4, 0x4a, 0x7e, 0xb5, - 0xa4, 0x2d, 0x88, 0x8f, 0xb7, 0xf9, 0xb7, 0x00, 0x2c, 0x8a, 0xdf, 0x84, 0xe5, 0x5e, 0x77, 0x40, - 0xcd, 0xce, 0xbe, 0x41, 0x05, 0x36, 0x68, 0x31, 0xfc, 0x1a, 0x1f, 0xc5, 0xec, 0xfc, 0x6d, 0x57, - 0x37, 0x8e, 0x87, 0x9d, 0x3f, 0x43, 0x50, 0xd3, 0x88, 0x45, 0x74, 0x7a, 0x3c, 0x54, 0x50, 0xfd, - 0x29, 0x82, 0xf3, 0x5b, 0xc4, 0x8f, 0x1d, 0xa6, 0xaf, 0xfb, 0x26, 0xf5, 0xcd, 0x0e, 0x3d, 0x4a, - 0xb1, 0x3e, 0x46, 0x70, 0x21, 0x53, 0xac, 0x49, 0x74, 0xfb, 0x16, 0x14, 0x82, 0x27, 0x5a, 0xcb, - 0xad, 0xe4, 0x57, 0xcb, 0xeb, 0x17, 0xa5, 0x63, 0xee, 0x91, 0xc1, 0x7b, 0x81, 0xcb, 0xd8, 0xd6, - 0x4d, 0x4f, 0xe3, 0xfc, 0xea, 0x5f, 0x11, 0x2c, 0x37, 0xbb, 0xee, 0xde, 0x50, 0xa4, 0x17, 0x01, - 0x50, 0xd2, 0xda, 0xf3, 0x29, 0x6b, 0xc7, 0x5f, 0x86, 0x69, 0x7f, 0xd0, 0x23, 0xcc, 0x51, 0xcc, - 0xad, 0xaf, 0xae, 0x49, 0xee, 0xee, 0xb5, 0x94, 0x90, 0xef, 0x0e, 0x7a, 0x44, 0x63, 0xa3, 0xd4, - 0x5f, 0x21, 0x38, 0xbd, 0x6f, 0x0b, 0x93, 0x80, 0x79, 0x19, 0xaa, 0xa9, 0xe3, 0xe4, 0xb8, 0x96, - 0xb4, 0xf9, 0xe4, 0x79, 0x52, 0x7c, 0x09, 0x62, 0x47, 0xdc, 0x32, 0x0d, 0x5a, 0xcb, 0xaf, 0xe4, - 0x57, 0xf3, 0x5a, 0x25, 0xe6, 0x16, 0x0c, 0xaa, 0xfe, 0x01, 0xc1, 0x32, 0x0f, 0x2e, 0xb6, 0x75, - 0xcf, 0x37, 0x8f, 0xda, 0x41, 0x5f, 0x82, 0xb9, 0x5e, 0x28, 0x07, 0xe7, 0x9b, 0x66, 0x7c, 0x95, - 0x88, 0xca, 0xb4, 0xf5, 0xf7, 0x08, 0x16, 0x83, 0x58, 0xe2, 0x24, 0xc9, 0xfc, 0x3b, 0x04, 0x0b, - 0x77, 0x75, 0x7a, 0x92, 0x44, 0xfe, 0xa3, 0x70, 0xe5, 0x91, 0xcc, 0x47, 0xe9, 0xa2, 0x02, 0xc6, - 0xa4, 0xd0, 0xe1, 0xe5, 0x35, 0x97, 0x90, 0x9a, 0xaa, 0x7f, 0x1a, 0xfa, 0xfc, 0x13, 0x26, 0xf9, - 0x9f, 0x11, 0x9c, 0xdb, 0x22, 0x7e, 0x24, 0xf5, 0xb1, 0xb8, 0x1b, 0xc6, 0xd5, 0x96, 0x67, 0xfc, - 0x66, 0x93, 0x0a, 0x7f, 0x24, 0x37, 0xc8, 0x6f, 0x11, 0x2c, 0x05, 0xee, 0xf7, 0x78, 0x28, 0xc1, - 0x18, 0xb1, 0xa7, 0xfa, 0x0b, 0x71, 0xe7, 0xc5, 0x25, 0x9e, 0x04, 0x3a, 0x89, 0xe2, 0xe5, 0x64, - 0x8a, 0x17, 0x08, 0x17, 0x51, 0x1a, 0x9b, 0xe1, 0x5d, 0x91, 0xa0, 0xa9, 0x3f, 0x42, 0xb0, 0x1c, - 0x46, 0xbe, 0x4d, 0xb2, 0x63, 0x13, 0xc7, 0x7f, 0x7e, 0x3c, 0xd3, 0x68, 0xe4, 0x24, 0x31, 0xeb, - 0x59, 0x28, 0x51, 0xbe, 0x4e, 0x14, 0xd4, 0x0e, 0x09, 0xea, 0x27, 0x08, 0x4e, 0xef, 0x13, 0x67, - 0x12, 0xb0, 0x6a, 0x30, 0x63, 0x3a, 0x06, 0x79, 0x12, 0x49, 0x13, 0xbe, 0x06, 0x5f, 0xda, 0x7d, - 0xd3, 0x32, 0x22, 0x31, 0xc2, 0x57, 0x7c, 0x11, 0x14, 0xe2, 0xe8, 0x6d, 0x8b, 0xb4, 0x18, 0x2f, - 0x3b, 0xd4, 0x59, 0xad, 0xcc, 0x69, 0x8d, 0x80, 0xa4, 0xfe, 0x18, 0xc1, 0x42, 0x70, 0xa6, 0x42, - 0x46, 0xfa, 0x62, 0x31, 0x5b, 0x81, 0x72, 0xec, 0xd0, 0x84, 0xb8, 0x71, 0x92, 0xfa, 0x18, 0x16, - 0x93, 0xe2, 0x4c, 0x82, 0xd9, 0x79, 0x80, 0xe8, 0x44, 0xb8, 0x6e, 0xe5, 0xb5, 0x18, 0x45, 0xfd, - 0x0f, 0x02, 0xcc, 0xc3, 0x0b, 0x06, 0xc6, 0x11, 0x27, 0xd9, 0x8f, 0x4c, 0x62, 0x19, 0x71, 0x0f, - 0x56, 0x62, 0x14, 0xf6, 0x79, 0x13, 0x14, 0xf2, 0xc4, 0xf7, 0xf4, 0x56, 0x4f, 0xf7, 0x74, 0x9b, - 0xa7, 0x38, 0x63, 0x39, 0x9b, 0x32, 0x1b, 0xb6, 0xcd, 0x46, 0xa9, 0x7f, 0x0b, 0x02, 0x13, 0xa1, - 0x94, 0xc7, 0x7d, 0xc7, 0xe7, 0x00, 0x98, 0xd2, 0xf2, 0xcf, 0x05, 0xfe, 0x99, 0x51, 0x98, 0x3b, - 0xff, 0x04, 0x41, 0x95, 0x6d, 0x81, 0xef, 0xa7, 0x17, 0x4c, 0x9b, 0x1a, 0x83, 0x52, 0x63, 0x46, - 0x98, 0xd0, 0x17, 0xa1, 0x28, 0x80, 0xcd, 0x8f, 0x0b, 0xac, 0x18, 0x70, 0xc0, 0x36, 0xd4, 0x5f, - 0x23, 0x58, 0x4a, 0x41, 0x3e, 0x89, 0x46, 0xbf, 0x0b, 0x98, 0xef, 0xd0, 0x18, 0x6e, 0x3b, 0xbc, - 0x7a, 0x2e, 0x49, 0xe3, 0xff, 0x34, 0x48, 0xda, 0x29, 0x33, 0x45, 0xa1, 0xea, 0x3f, 0x10, 0x9c, - 0xdd, 0x22, 0x3e, 0x63, 0xdd, 0x08, 0x7c, 0xc7, 0xb6, 0xe7, 0xee, 0x78, 0x84, 0xd2, 0x93, 0xab, - 0x1f, 0x3f, 0xe3, 0xb1, 0x8a, 0x6c, 0x4b, 0x93, 0xe0, 0x7f, 0x11, 0x14, 0xb6, 0x06, 0x31, 0x5a, - 0x9e, 0xbb, 0x47, 0x85, 0x1e, 0x95, 0x05, 0x4d, 0x73, 0xf7, 0x98, 0x42, 0xf8, 0xae, 0xaf, 0x5b, - 0x9c, 0x41, 0x5c, 0x0c, 0x8c, 0x12, 0x7c, 0x66, 0x36, 0x18, 0x0a, 0x16, 0x4c, 0x4e, 0x4e, 0x2e, - 0xc6, 0x1f, 0x21, 0x58, 0x4a, 0x6d, 0x65, 0x12, 0x6c, 0x6f, 0xf2, 0x48, 0x8a, 0x6f, 0x66, 0x6e, - 0xfd, 0x82, 0x74, 0x4c, 0x6c, 0x31, 0xce, 0xad, 0x7e, 0x8a, 0xa0, 0x1a, 0x64, 0x5b, 0x27, 0xdc, - 0xa1, 0x7d, 0x3f, 0x07, 0x95, 0x86, 0x43, 0x89, 0xe7, 0x1f, 0xff, 0x60, 0x1a, 0x7f, 0x0d, 0xca, - 0x6c, 0x63, 0xb4, 0x65, 0xe8, 0xbe, 0x2e, 0x6e, 0xa3, 0xf3, 0xd2, 0xba, 0xe0, 0x9d, 0x80, 0x6f, - 0x53, 0xf7, 0x75, 0x8d, 0xa3, 0x43, 0x83, 0x67, 0x7c, 0x06, 0x4a, 0x5d, 0x9d, 0x76, 0x5b, 0x8f, - 0xc9, 0x80, 0xd6, 0x8a, 0x2b, 0xf9, 0xd5, 0x8a, 0x36, 0x1b, 0x10, 0xee, 0x91, 0x01, 0x0d, 0xf4, - 0x6a, 0x2e, 0x84, 0x62, 0x12, 0x85, 0xba, 0x00, 0x65, 0xcf, 0xdd, 0x6b, 0x6c, 0xb6, 0xda, 0x64, - 0xc7, 0x74, 0x84, 0xad, 0x02, 0x23, 0x6d, 0x04, 0x94, 0x40, 0x0a, 0xce, 0x40, 0x1c, 0x43, 0x58, - 0xea, 0x2c, 0x23, 0x7c, 0xc3, 0x31, 0xd4, 0x5d, 0xa8, 0x6e, 0x5b, 0x7a, 0x87, 0x74, 0x5d, 0xcb, - 0x20, 0x1e, 0x73, 0xfc, 0xb8, 0x0a, 0x79, 0x5f, 0xdf, 0x11, 0x37, 0x4b, 0xf0, 0x88, 0xbf, 0x20, - 0x4a, 0x30, 0x5c, 0x67, 0x5f, 0x91, 0xba, 0xe0, 0xd8, 0x34, 0xc3, 0xf2, 0x0b, 0x5e, 0x86, 0x22, - 0x2b, 0x44, 0xf3, 0x3b, 0x47, 0xd1, 0xc4, 0x9b, 0xfa, 0x30, 0xb1, 0xee, 0x96, 0xe7, 0xf6, 0x7b, - 0xb8, 0x01, 0x4a, 0x6f, 0x48, 0x0b, 0x40, 0xc8, 0x76, 0xf8, 0x69, 0xa1, 0xb5, 0xc4, 0x50, 0xf5, - 0xdf, 0x39, 0xa8, 0x34, 0x89, 0xee, 0x75, 0xba, 0x27, 0x21, 0xe7, 0x0c, 0x10, 0x37, 0xa8, 0x25, - 0xcc, 0x25, 0x78, 0xc4, 0x57, 0xe1, 0x54, 0x6c, 0x43, 0xad, 0x9d, 0x00, 0xa0, 0x5a, 0x91, 0xf5, - 0x7a, 0xaa, 0xbd, 0x34, 0x70, 0xb7, 0x60, 0xd6, 0xa0, 0x56, 0x8b, 0x1d, 0xd1, 0x0c, 0x3b, 0x22, - 0xf9, 0xfe, 0x36, 0xa9, 0xc5, 0x8e, 0x66, 0xc6, 0xe0, 0x0f, 0xf8, 0x0e, 0x54, 0x28, 0x43, 0x29, - 0x8c, 0xb8, 0x66, 0xc7, 0x0d, 0x0c, 0x14, 0x3e, 0x4e, 0x84, 0x5c, 0xff, 0x45, 0x30, 0xaf, 0x11, - 0xdf, 0x33, 0xc9, 0x2e, 0x39, 0x11, 0x80, 0x5f, 0x81, 0xbc, 0x69, 0x50, 0x06, 0x78, 0x79, 0xbd, - 0x26, 0x35, 0xe9, 0xc6, 0x26, 0xd5, 0x02, 0x26, 0xfc, 0x32, 0x54, 0xdc, 0xbe, 0xdf, 0xeb, 0xfb, - 0x2d, 0x6e, 0xda, 0xcc, 0x92, 0x4b, 0x9a, 0xc2, 0x89, 0xcc, 0xf2, 0x59, 0x0d, 0x2f, 0x86, 0x00, - 0xed, 0x5b, 0x3e, 0x7d, 0x3e, 0x73, 0x16, 0x92, 0xe5, 0xc6, 0x91, 0x2c, 0xe5, 0xa0, 0xf2, 0x87, - 0x75, 0x50, 0xea, 0x3d, 0x98, 0xbe, 0x6b, 0xfa, 0x4c, 0xff, 0x82, 0xdc, 0x01, 0xb1, 0xdc, 0x21, - 0x78, 0xc4, 0x2f, 0x41, 0xe0, 0x23, 0xf8, 0xbc, 0x39, 0x66, 0xb9, 0x33, 0x9e, 0xbb, 0xc7, 0xbc, - 0x1a, 0xeb, 0x3d, 0xba, 0x9e, 0x30, 0xe9, 0x9c, 0x26, 0xde, 0xd4, 0xf7, 0x87, 0x26, 0x37, 0xc1, - 0xfe, 0x31, 0x4c, 0x77, 0x4d, 0x51, 0x68, 0x50, 0x34, 0xf6, 0xac, 0x7e, 0x17, 0x81, 0x72, 0xc7, - 0xea, 0xd3, 0x17, 0x61, 0xcc, 0xb2, 0x72, 0x6e, 0x5e, 0x5a, 0xce, 0x55, 0xff, 0x8e, 0x60, 0x69, - 0x9b, 0x78, 0xd4, 0xa4, 0x3e, 0x71, 0x7c, 0x91, 0xbc, 0x35, 0x9c, 0x47, 0x6e, 0x32, 0x4b, 0x46, - 0xa9, 0x2c, 0xf9, 0xb3, 0xc9, 0x19, 0x83, 0x13, 0x71, 0xfa, 0x36, 0x8f, 0xb7, 0x78, 0xdd, 0x62, - 0xc6, 0xe9, 0xdb, 0x2c, 0x18, 0xbb, 0x15, 0xc6, 0x14, 0x05, 0x66, 0xfc, 0x72, 0xf3, 0x15, 0xf2, - 0x26, 0xa2, 0x8a, 0x9f, 0xf0, 0x8e, 0x83, 0x74, 0x53, 0xcf, 0x8f, 0xf5, 0x32, 0x08, 0x70, 0x53, - 0x50, 0x7f, 0x0e, 0x52, 0xf6, 0x9a, 0xd1, 0x07, 0xf9, 0x39, 0x82, 0x95, 0x6c, 0xa9, 0x26, 0xb9, - 0x2b, 0xbf, 0x0e, 0x05, 0xd3, 0x79, 0xe4, 0x86, 0xb9, 0xc4, 0x15, 0xf9, 0xd5, 0x22, 0x5d, 0x97, - 0x0f, 0x54, 0xff, 0x85, 0xa0, 0xfa, 0x4e, 0x9f, 0x78, 0x83, 0x23, 0x38, 0x7e, 0x9b, 0xd8, 0x2d, - 0x6a, 0x3e, 0x25, 0xe1, 0xf1, 0xdb, 0xc4, 0x6e, 0x9a, 0x4f, 0x49, 0x42, 0x33, 0x0a, 0x49, 0xcd, - 0x48, 0x86, 0x63, 0xc5, 0x11, 0xb9, 0xe2, 0x4c, 0x22, 0x57, 0x54, 0x9f, 0x21, 0xa8, 0x6f, 0x11, - 0x3f, 0xbd, 0xd5, 0xa3, 0x53, 0x8a, 0x8f, 0x11, 0x9c, 0x91, 0x0a, 0x34, 0x89, 0x3e, 0x7c, 0x29, - 0xa9, 0x0f, 0xf2, 0x50, 0x63, 0xdf, 0x92, 0x42, 0x15, 0xde, 0x00, 0x65, 0xb3, 0x6f, 0xdb, 0x83, - 0x10, 0x93, 0x8b, 0xa0, 0x78, 0xfc, 0x91, 0xdf, 0xc4, 0x3c, 0x7e, 0x2a, 0x0b, 0x5a, 0x70, 0xdf, - 0xaa, 0x57, 0xa1, 0x22, 0x86, 0x08, 0xa9, 0xeb, 0x30, 0xeb, 0x89, 0x67, 0xc1, 0x1f, 0xbd, 0xab, - 0x4b, 0xb0, 0xa0, 0x91, 0x9d, 0x40, 0x13, 0xbd, 0xb7, 0x4d, 0xe7, 0xb1, 0x58, 0x26, 0x88, 0x1b, - 0x17, 0x93, 0x74, 0x31, 0xd7, 0xe7, 0x61, 0x46, 0x37, 0x8c, 0x20, 0xfb, 0x1b, 0x79, 0x2c, 0x6f, - 0x71, 0x1e, 0x2d, 0x64, 0x8e, 0x21, 0x97, 0x1b, 0x1b, 0xb9, 0x2b, 0xd7, 0x78, 0x41, 0x2d, 0xd5, - 0x73, 0xc3, 0x33, 0x90, 0x7f, 0xcb, 0xb2, 0xaa, 0x53, 0x58, 0x81, 0xd9, 0x86, 0x73, 0x9f, 0xd8, - 0xae, 0x37, 0xa8, 0xa2, 0x2b, 0x5f, 0x85, 0xf9, 0x54, 0x78, 0x88, 0x67, 0x61, 0xfa, 0x81, 0xeb, - 0x90, 0xea, 0x14, 0xae, 0x82, 0xb2, 0x61, 0x3a, 0xba, 0x37, 0x78, 0x8f, 0x74, 0x7c, 0xd7, 0xab, - 0x1a, 0x78, 0x1e, 0xca, 0x77, 0x2c, 0x57, 0xf7, 0x05, 0x81, 0xac, 0xff, 0x65, 0x19, 0x2a, 0xf7, - 0x99, 0x50, 0x4d, 0xe2, 0xed, 0x9a, 0x1d, 0x82, 0x5b, 0x50, 0x4d, 0xff, 0x8f, 0x83, 0xaf, 0x49, - 0x8f, 0x2f, 0xe3, 0xb7, 0x9d, 0xfa, 0xa8, 0x6d, 0xaa, 0x53, 0xf8, 0x43, 0x98, 0x4b, 0xfe, 0x29, - 0x83, 0xe5, 0xde, 0x42, 0xfa, 0x3b, 0xcd, 0x41, 0x93, 0xb7, 0xa0, 0x92, 0xf8, 0xf1, 0x05, 0x5f, - 0x96, 0xce, 0x2d, 0xfb, 0x39, 0xa6, 0x7e, 0x51, 0xca, 0x1a, 0xff, 0x39, 0x85, 0x4b, 0x9f, 0xec, - 0xff, 0x67, 0x48, 0x2f, 0xfd, 0x49, 0xe0, 0x20, 0xe9, 0x75, 0x38, 0xb5, 0xaf, 0x9d, 0x8f, 0x5f, - 0x93, 0xce, 0x9f, 0xd5, 0xf6, 0x3f, 0x68, 0x89, 0x3d, 0xc0, 0xfb, 0x7f, 0xf0, 0xc0, 0x6b, 0xf2, - 0x13, 0xc8, 0xfa, 0xbd, 0xa5, 0x7e, 0x7d, 0x6c, 0xfe, 0x08, 0xb8, 0xef, 0x21, 0x38, 0x9d, 0xd1, - 0x83, 0xc7, 0x37, 0xa4, 0xd3, 0x8d, 0xfe, 0x91, 0xa0, 0xfe, 0xe6, 0xe1, 0x06, 0x45, 0x82, 0x38, - 0x30, 0x9f, 0x32, 0x30, 0x7c, 0x75, 0x9c, 0xd6, 0x77, 0xb8, 0xee, 0xb5, 0xf1, 0x98, 0xa3, 0xf5, - 0x1e, 0xc2, 0x7c, 0xaa, 0x07, 0x9d, 0xb1, 0x9e, 0xbc, 0x53, 0x7d, 0xd0, 0x81, 0x7e, 0x00, 0x95, - 0x44, 0xb3, 0x38, 0x43, 0xe3, 0x65, 0x0d, 0xe5, 0x83, 0xa6, 0x7e, 0x08, 0x4a, 0xbc, 0xa7, 0x8b, - 0x57, 0xb3, 0x6c, 0x69, 0xdf, 0xc4, 0x87, 0x31, 0xa5, 0x61, 0x3b, 0x68, 0x84, 0x29, 0xed, 0xeb, - 0x72, 0x8d, 0x6f, 0x4a, 0xb1, 0xf9, 0x47, 0x9a, 0xd2, 0xa1, 0x97, 0xf8, 0x08, 0xc1, 0xb2, 0xbc, - 0x25, 0x88, 0xd7, 0xb3, 0x74, 0x33, 0xbb, 0xf9, 0x59, 0xbf, 0x71, 0xa8, 0x31, 0x11, 0x8a, 0x8f, - 0x61, 0x2e, 0xd9, 0x54, 0xcb, 0x40, 0x51, 0xda, 0x2b, 0xac, 0x5f, 0x1d, 0x8b, 0x37, 0x5a, 0xec, - 0x9b, 0x50, 0x8e, 0x35, 0x3c, 0xf0, 0xab, 0x23, 0xf4, 0x38, 0x5e, 0x4f, 0x3b, 0x08, 0xc9, 0x2e, - 0x54, 0x12, 0x45, 0xee, 0x2c, 0x1d, 0x96, 0xf4, 0x1e, 0xea, 0x57, 0xc6, 0x61, 0x8d, 0x36, 0xd0, - 0x85, 0x4a, 0xa2, 0xe4, 0x98, 0xb1, 0x92, 0xac, 0xc2, 0x9a, 0xb1, 0x92, 0xb4, 0x82, 0xa9, 0x4e, - 0xe1, 0xef, 0xc4, 0xaa, 0x9b, 0x89, 0x0a, 0x32, 0x7e, 0x63, 0xe4, 0x3c, 0xb2, 0x02, 0x7a, 0x7d, - 0xfd, 0x30, 0x43, 0x22, 0x11, 0xde, 0x81, 0x52, 0x54, 0xd9, 0xc4, 0x97, 0x32, 0xdd, 0xc2, 0x61, - 0x4e, 0xaa, 0x09, 0x45, 0x5e, 0x5a, 0xc3, 0x6a, 0x46, 0xbb, 0x20, 0x56, 0x82, 0xac, 0xbf, 0x3c, - 0x92, 0x27, 0x92, 0x53, 0x83, 0x22, 0xcf, 0x6f, 0x33, 0x26, 0x4d, 0xd4, 0x9b, 0xea, 0xa3, 0x79, - 0x58, 0x82, 0xac, 0x4e, 0xe1, 0xf7, 0x61, 0x36, 0xac, 0x1a, 0xe0, 0x57, 0x32, 0xcc, 0x3e, 0x51, - 0x56, 0xa9, 0x1f, 0xc4, 0x15, 0xce, 0xdc, 0x80, 0x02, 0x4b, 0x99, 0xb1, 0xdc, 0xc9, 0xc5, 0xd3, - 0xe9, 0x83, 0xd0, 0xfc, 0x01, 0x82, 0x5a, 0x56, 0x3e, 0x86, 0x33, 0xef, 0xb7, 0x51, 0x49, 0x65, - 0xfd, 0xe6, 0x21, 0x47, 0x45, 0x87, 0xf0, 0x14, 0x16, 0x24, 0x59, 0x00, 0xbe, 0x9e, 0x35, 0x5f, - 0x46, 0x02, 0x53, 0x7f, 0x7d, 0xfc, 0x01, 0xd1, 0xda, 0xdb, 0x50, 0x60, 0xd1, 0x7b, 0x06, 0xa4, - 0xf1, 0x64, 0x20, 0xe3, 0xf8, 0x13, 0xc1, 0xbf, 0x3a, 0x85, 0x09, 0x28, 0xf1, 0x50, 0x3e, 0xe3, - 0xea, 0x92, 0x64, 0x01, 0xf5, 0xcb, 0x63, 0x70, 0x86, 0xcb, 0xac, 0xf7, 0x41, 0xd9, 0xf6, 0xdc, - 0x27, 0x83, 0x30, 0x78, 0xfe, 0xff, 0x2c, 0xbb, 0x71, 0xf3, 0x5b, 0x37, 0x76, 0x4c, 0xbf, 0xdb, - 0x6f, 0x07, 0x1a, 0x75, 0x9d, 0xf3, 0xbe, 0x66, 0xba, 0xe2, 0xe9, 0xba, 0xe9, 0xf8, 0xc4, 0x73, - 0x74, 0xeb, 0x3a, 0x9b, 0x4b, 0x50, 0x7b, 0xed, 0x76, 0x91, 0xbd, 0xdf, 0xf8, 0x5f, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x64, 0xcb, 0x0a, 0x02, 0xb3, 0x2f, 0x00, 0x00, + // 2405 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x5d, 0x6f, 0x24, 0x47, + 0xd1, 0xbd, 0xeb, 0x5d, 0x7b, 0x6b, 0x67, 0xed, 0xbd, 0xf6, 0xd7, 0x66, 0xee, 0xcb, 0x37, 0xc9, + 0x11, 0xdf, 0x47, 0x7c, 0x89, 0x2f, 0xc7, 0x81, 0xf8, 0x8c, 0xcf, 0x9c, 0xcf, 0xba, 0xdc, 0xe1, + 0x8c, 0x43, 0x94, 0x10, 0x9d, 0x56, 0xe3, 0x9d, 0x3e, 0xef, 0xe8, 0xe6, 0x63, 0x99, 0x9e, 0xb5, + 0xcf, 0xf7, 0x84, 0x94, 0x08, 0x81, 0x20, 0x97, 0x07, 0x10, 0x12, 0x3c, 0x20, 0x84, 0x94, 0x07, + 0x9e, 0x00, 0x81, 0x84, 0xc4, 0x13, 0x0f, 0x79, 0xe0, 0x0d, 0xc4, 0x6f, 0x80, 0x37, 0xf8, 0x0d, + 0xa0, 0xe9, 0xee, 0x99, 0x9d, 0x99, 0xed, 0x59, 0xaf, 0x6f, 0x73, 0xb1, 0xfd, 0x36, 0x5d, 0x53, + 0x5d, 0x5d, 0x55, 0x5d, 0x55, 0x5d, 0x55, 0xdd, 0xa0, 0x38, 0x96, 0xbd, 0xdb, 0xa5, 0xcb, 0x1d, + 0xdf, 0x0b, 0x3c, 0x3c, 0x93, 0x1c, 0x2d, 0xf3, 0x81, 0xaa, 0xb4, 0x3c, 0xc7, 0xf1, 0x5c, 0x0e, + 0x54, 0x15, 0xda, 0x6a, 0x13, 0xc7, 0xe0, 0x23, 0xed, 0x53, 0x04, 0x0b, 0xb7, 0x7c, 0x62, 0x04, + 0xe4, 0x96, 0x67, 0xdb, 0xa4, 0x15, 0x58, 0x9e, 0xab, 0x93, 0xef, 0x75, 0x09, 0x0d, 0xf0, 0xab, + 0x30, 0xbe, 0x6d, 0x50, 0xd2, 0x40, 0x8b, 0x68, 0xa9, 0xba, 0x72, 0x66, 0x39, 0x45, 0x5b, 0xd0, + 0xbc, 0x47, 0x77, 0x56, 0x0d, 0x4a, 0x74, 0x86, 0x89, 0x17, 0x60, 0xc2, 0xdc, 0x6e, 0xba, 0x86, + 0x43, 0x1a, 0x85, 0x45, 0xb4, 0x54, 0xd1, 0xcb, 0xe6, 0xf6, 0x7d, 0xc3, 0x21, 0xf8, 0x65, 0x98, + 0x6e, 0xc5, 0xf4, 0x39, 0x42, 0x91, 0x21, 0x4c, 0xf5, 0xc0, 0x0c, 0x71, 0x1e, 0xca, 0x9c, 0xbf, + 0xc6, 0xf8, 0x22, 0x5a, 0x52, 0x74, 0x31, 0xc2, 0x67, 0x01, 0x68, 0xdb, 0xf0, 0x4d, 0xda, 0x74, + 0xbb, 0x4e, 0xa3, 0xb4, 0x88, 0x96, 0x4a, 0x7a, 0x85, 0x43, 0xee, 0x77, 0x1d, 0xed, 0xc7, 0x08, + 0xe6, 0xd6, 0x7c, 0xaf, 0x73, 0x2c, 0x84, 0xd0, 0x7e, 0x8b, 0x60, 0xf6, 0x8e, 0x41, 0x8f, 0x87, + 0x46, 0xcf, 0x02, 0x04, 0x96, 0x43, 0x9a, 0x34, 0x30, 0x9c, 0x0e, 0xd3, 0xea, 0xb8, 0x5e, 0x09, + 0x21, 0x5b, 0x21, 0x40, 0x7b, 0x0f, 0x94, 0x55, 0xcf, 0xb3, 0x75, 0x42, 0x3b, 0x9e, 0x4b, 0x09, + 0xbe, 0x0e, 0x65, 0x1a, 0x18, 0x41, 0x97, 0x0a, 0x26, 0x4f, 0x4b, 0x99, 0xdc, 0x62, 0x28, 0xba, + 0x40, 0xc5, 0xb3, 0x50, 0xda, 0x35, 0xec, 0x2e, 0xe7, 0x71, 0x52, 0xe7, 0x03, 0xed, 0x7d, 0x98, + 0xda, 0x0a, 0x7c, 0xcb, 0xdd, 0xf9, 0x0c, 0x89, 0x57, 0x22, 0xe2, 0xff, 0x44, 0xf0, 0xc2, 0x1a, + 0xa1, 0x2d, 0xdf, 0xda, 0x3e, 0x26, 0xa6, 0xab, 0x81, 0xd2, 0x83, 0x6c, 0xac, 0x31, 0x55, 0x17, + 0xf5, 0x14, 0x2c, 0xb3, 0x19, 0xa5, 0xec, 0x66, 0xfc, 0xaa, 0x00, 0xaa, 0x4c, 0xa8, 0x51, 0xd4, + 0xf7, 0xb5, 0xd8, 0xa3, 0x0a, 0x6c, 0xd2, 0xc5, 0xf4, 0x24, 0x11, 0x0d, 0x7a, 0xab, 0x6d, 0x31, + 0x40, 0xec, 0x78, 0x59, 0xa9, 0x8a, 0x12, 0xa9, 0x56, 0x60, 0x6e, 0xd7, 0xf2, 0x83, 0xae, 0x61, + 0x37, 0x5b, 0x6d, 0xc3, 0x75, 0x89, 0xcd, 0xf4, 0x44, 0x1b, 0xe3, 0x8b, 0xc5, 0xa5, 0x8a, 0x3e, + 0x23, 0x7e, 0xde, 0xe2, 0xff, 0x42, 0x65, 0x51, 0xfc, 0x3a, 0xcc, 0x77, 0xda, 0xfb, 0xd4, 0x6a, + 0xf5, 0x4d, 0x2a, 0xb1, 0x49, 0xb3, 0xd1, 0xdf, 0xe4, 0x2c, 0xe6, 0xe7, 0x6f, 0x7a, 0x86, 0x79, + 0x3c, 0xfc, 0xfc, 0x29, 0x82, 0x86, 0x4e, 0x6c, 0x62, 0xd0, 0xe3, 0x61, 0x82, 0xda, 0xcf, 0x10, + 0x9c, 0x5b, 0x27, 0x41, 0x62, 0x33, 0x03, 0x23, 0xb0, 0x68, 0x60, 0xb5, 0xe8, 0x51, 0xb2, 0xf5, + 0x31, 0x82, 0xf3, 0xb9, 0x6c, 0x8d, 0x62, 0xdb, 0x37, 0xa1, 0x14, 0x7e, 0xd1, 0x46, 0x61, 0xb1, + 0xb8, 0x54, 0x5d, 0xb9, 0x20, 0x9d, 0x73, 0x97, 0xec, 0xbf, 0x13, 0x86, 0x8c, 0x4d, 0xc3, 0xf2, + 0x75, 0x8e, 0xaf, 0xfd, 0x15, 0xc1, 0xfc, 0x56, 0xdb, 0xdb, 0xeb, 0xb1, 0xf4, 0x3c, 0x14, 0x94, + 0xf6, 0xf6, 0x62, 0xc6, 0xdb, 0xf1, 0x57, 0x61, 0x3c, 0xd8, 0xef, 0x10, 0x16, 0x28, 0xa6, 0x56, + 0x96, 0x96, 0x25, 0x67, 0xf7, 0x72, 0x86, 0xc9, 0xb7, 0xf7, 0x3b, 0x44, 0x67, 0xb3, 0xb4, 0x5f, + 0x23, 0x58, 0xe8, 0x13, 0x61, 0x14, 0x65, 0x5e, 0x82, 0x7a, 0x66, 0x3b, 0xb9, 0x5e, 0x2b, 0xfa, + 0x74, 0x7a, 0x3f, 0x29, 0xbe, 0x08, 0x89, 0x2d, 0x6e, 0x5a, 0x26, 0x6d, 0x14, 0x17, 0x8b, 0x4b, + 0x45, 0xbd, 0x96, 0x08, 0x0b, 0x26, 0xd5, 0xfe, 0x88, 0x60, 0x9e, 0x27, 0x17, 0x9b, 0x86, 0x1f, + 0x58, 0x47, 0x1d, 0xa0, 0x2f, 0xc2, 0x54, 0x27, 0xe2, 0x83, 0xe3, 0x8d, 0x33, 0xbc, 0x5a, 0x0c, + 0x65, 0xd6, 0xfa, 0x07, 0x04, 0xb3, 0x61, 0x2e, 0x71, 0x92, 0x78, 0xfe, 0x3d, 0x82, 0x99, 0x3b, + 0x06, 0x3d, 0x49, 0x2c, 0xff, 0x49, 0x84, 0xf2, 0x98, 0xe7, 0xa3, 0x0c, 0x51, 0x21, 0x62, 0x9a, + 0xe9, 0xe8, 0xf0, 0x9a, 0x4a, 0x71, 0x4d, 0xb5, 0x3f, 0xf7, 0x62, 0xfe, 0x09, 0xe3, 0xfc, 0x2f, + 0x08, 0xce, 0xae, 0x93, 0x20, 0xe6, 0xfa, 0x58, 0x9c, 0x0d, 0xc3, 0x5a, 0xcb, 0x53, 0x7e, 0xb2, + 0x49, 0x99, 0x3f, 0x92, 0x13, 0xe4, 0x77, 0x08, 0xe6, 0xc2, 0xf0, 0x7b, 0x3c, 0x8c, 0x60, 0x88, + 0xdc, 0x53, 0xfb, 0xa5, 0x38, 0xf3, 0x92, 0x1c, 0x8f, 0xa2, 0x3a, 0x89, 0xe1, 0x15, 0x64, 0x86, + 0x17, 0x32, 0x17, 0x43, 0x36, 0xd6, 0xa2, 0xb3, 0x22, 0x05, 0xd3, 0x7e, 0x82, 0x60, 0x3e, 0xca, + 0x7c, 0xb7, 0xc8, 0x8e, 0x43, 0xdc, 0xe0, 0xd9, 0xf5, 0x99, 0xd5, 0x46, 0x41, 0x92, 0xb3, 0x9e, + 0x81, 0x0a, 0xe5, 0xeb, 0xc4, 0x49, 0x6d, 0x0f, 0xa0, 0x7d, 0x82, 0x60, 0xa1, 0x8f, 0x9d, 0x51, + 0x94, 0xd5, 0x80, 0x09, 0xcb, 0x35, 0xc9, 0xe3, 0x98, 0x9b, 0x68, 0x18, 0xfe, 0xd9, 0xee, 0x5a, + 0xb6, 0x19, 0xb3, 0x11, 0x0d, 0xf1, 0x05, 0x50, 0x88, 0x6b, 0x6c, 0xdb, 0xa4, 0xc9, 0x70, 0xd9, + 0xa6, 0x4e, 0xea, 0x55, 0x0e, 0xdb, 0x08, 0x41, 0xda, 0x47, 0x08, 0x66, 0xc2, 0x3d, 0x15, 0x3c, + 0xd2, 0xe7, 0xab, 0xb3, 0x45, 0xa8, 0x26, 0x36, 0x4d, 0xb0, 0x9b, 0x04, 0x69, 0x8f, 0x60, 0x36, + 0xcd, 0xce, 0x28, 0x3a, 0x3b, 0x07, 0x10, 0xef, 0x08, 0xb7, 0xad, 0xa2, 0x9e, 0x80, 0x68, 0xff, + 0x45, 0x80, 0x79, 0x7a, 0xc1, 0x94, 0x71, 0xc4, 0x45, 0xf6, 0x43, 0x8b, 0xd8, 0x66, 0x32, 0x82, + 0x55, 0x18, 0x84, 0xfd, 0x5e, 0x03, 0x85, 0x3c, 0x0e, 0x7c, 0xa3, 0xd9, 0x31, 0x7c, 0xc3, 0xe1, + 0x25, 0xce, 0x50, 0xc1, 0xa6, 0xca, 0xa6, 0x6d, 0xb2, 0x59, 0xda, 0xdf, 0xc2, 0xc4, 0x44, 0x18, + 0xe5, 0x71, 0x97, 0xf8, 0x2c, 0x00, 0x33, 0x5a, 0xfe, 0xbb, 0xc4, 0x7f, 0x33, 0x08, 0x0b, 0xe7, + 0x9f, 0x20, 0xa8, 0x33, 0x11, 0xb8, 0x3c, 0x9d, 0x90, 0x6c, 0x66, 0x0e, 0xca, 0xcc, 0x19, 0xe0, + 0x42, 0x5f, 0x86, 0xb2, 0x50, 0x6c, 0x71, 0x58, 0xc5, 0x8a, 0x09, 0x07, 0x88, 0xa1, 0xfd, 0x06, + 0xc1, 0x5c, 0x46, 0xe5, 0xa3, 0x58, 0xf4, 0xdb, 0x80, 0xb9, 0x84, 0x66, 0x4f, 0xec, 0xe8, 0xe8, + 0xb9, 0x28, 0xcd, 0xff, 0xb3, 0x4a, 0xd2, 0x4f, 0x59, 0x19, 0x08, 0xd5, 0xfe, 0x81, 0xe0, 0xcc, + 0x3a, 0x09, 0x18, 0xea, 0x6a, 0x18, 0x3b, 0x36, 0x7d, 0x6f, 0xc7, 0x27, 0x94, 0x9e, 0x5c, 0xfb, + 0xf8, 0x39, 0xcf, 0x55, 0x64, 0x22, 0x8d, 0xa2, 0xff, 0x0b, 0xa0, 0xb0, 0x35, 0x88, 0xd9, 0xf4, + 0xbd, 0x3d, 0x2a, 0xec, 0xa8, 0x2a, 0x60, 0xba, 0xb7, 0xc7, 0x0c, 0x22, 0xf0, 0x02, 0xc3, 0xe6, + 0x08, 0xe2, 0x60, 0x60, 0x90, 0xf0, 0x37, 0xf3, 0xc1, 0x88, 0xb1, 0x90, 0x38, 0x39, 0xb9, 0x3a, + 0xfe, 0x00, 0xc1, 0x5c, 0x46, 0x94, 0x51, 0x74, 0x7b, 0x83, 0x67, 0x52, 0x5c, 0x98, 0xa9, 0x95, + 0xf3, 0xd2, 0x39, 0x89, 0xc5, 0x38, 0xb6, 0xf6, 0x29, 0x82, 0x7a, 0x58, 0x6d, 0x9d, 0xf0, 0x80, + 0xf6, 0xc3, 0x02, 0xd4, 0x36, 0x5c, 0x4a, 0xfc, 0xe0, 0xf8, 0x27, 0xd3, 0xf8, 0x1b, 0x50, 0x65, + 0x82, 0xd1, 0xa6, 0x69, 0x04, 0x86, 0x38, 0x8d, 0xce, 0x49, 0xfb, 0x82, 0xb7, 0x43, 0xbc, 0x35, + 0x23, 0x30, 0x74, 0xae, 0x1d, 0x1a, 0x7e, 0xe3, 0xd3, 0x50, 0x69, 0x1b, 0xb4, 0xdd, 0x7c, 0x44, + 0xf6, 0x69, 0xa3, 0xbc, 0x58, 0x5c, 0xaa, 0xe9, 0x93, 0x21, 0xe0, 0x2e, 0xd9, 0xa7, 0xa1, 0x5d, + 0x4d, 0x45, 0xaa, 0x18, 0xc5, 0xa0, 0xce, 0x43, 0xd5, 0xf7, 0xf6, 0x36, 0xd6, 0x9a, 0xdb, 0x64, + 0xc7, 0x72, 0x85, 0xaf, 0x02, 0x03, 0xad, 0x86, 0x90, 0x90, 0x0b, 0x8e, 0x40, 0x5c, 0x53, 0x78, + 0xea, 0x24, 0x03, 0x7c, 0xcb, 0x35, 0xb5, 0x5d, 0xa8, 0x6f, 0xda, 0x46, 0x8b, 0xb4, 0x3d, 0xdb, + 0x24, 0x3e, 0x0b, 0xfc, 0xb8, 0x0e, 0xc5, 0xc0, 0xd8, 0x11, 0x27, 0x4b, 0xf8, 0x89, 0xbf, 0x24, + 0x5a, 0x30, 0xdc, 0x66, 0x5f, 0x92, 0x86, 0xe0, 0x04, 0x99, 0x5e, 0xfb, 0x05, 0xcf, 0x43, 0x99, + 0x35, 0xa2, 0xf9, 0x99, 0xa3, 0xe8, 0x62, 0xa4, 0x3d, 0x48, 0xad, 0xbb, 0xee, 0x7b, 0xdd, 0x0e, + 0xde, 0x00, 0xa5, 0xd3, 0x83, 0x85, 0x4a, 0xc8, 0x0f, 0xf8, 0x59, 0xa6, 0xf5, 0xd4, 0x54, 0xed, + 0x3f, 0x05, 0xa8, 0x6d, 0x11, 0xc3, 0x6f, 0xb5, 0x4f, 0x42, 0xcd, 0x19, 0x6a, 0xdc, 0xa4, 0xb6, + 0x70, 0x97, 0xf0, 0x13, 0x5f, 0x81, 0x53, 0x09, 0x81, 0x9a, 0x3b, 0xa1, 0x82, 0x1a, 0x65, 0x76, + 0xd7, 0x53, 0xef, 0x64, 0x15, 0x77, 0x13, 0x26, 0x4d, 0x6a, 0x37, 0xd9, 0x16, 0x4d, 0xb0, 0x2d, + 0x92, 0xcb, 0xb7, 0x46, 0x6d, 0xb6, 0x35, 0x13, 0x26, 0xff, 0xc0, 0xb7, 0xa1, 0x46, 0x99, 0x96, + 0xa2, 0x8c, 0x6b, 0x72, 0xd8, 0xc4, 0x40, 0xe1, 0xf3, 0x44, 0xca, 0xf5, 0x3f, 0x04, 0xd3, 0x3a, + 0x09, 0x7c, 0x8b, 0xec, 0x92, 0x13, 0xa1, 0xf0, 0xcb, 0x50, 0xb4, 0x4c, 0xca, 0x14, 0x5e, 0x5d, + 0x69, 0x48, 0x5d, 0x7a, 0x63, 0x8d, 0xea, 0x21, 0x12, 0x7e, 0x11, 0x6a, 0x5e, 0x37, 0xe8, 0x74, + 0x83, 0x26, 0x77, 0x6d, 0xe6, 0xc9, 0x15, 0x5d, 0xe1, 0x40, 0xe6, 0xf9, 0xac, 0x87, 0x97, 0xd0, + 0x00, 0xed, 0xda, 0x01, 0x7d, 0x36, 0x77, 0x16, 0x9c, 0x15, 0x86, 0xe1, 0x2c, 0x13, 0xa0, 0x8a, + 0x87, 0x0d, 0x50, 0xda, 0x5d, 0x18, 0xbf, 0x63, 0x05, 0xcc, 0xfe, 0xc2, 0xda, 0x01, 0xb1, 0xda, + 0x21, 0xfc, 0xc4, 0x2f, 0x40, 0x18, 0x23, 0x38, 0xdd, 0x02, 0xf3, 0xdc, 0x09, 0xdf, 0xdb, 0x63, + 0x51, 0x8d, 0xdd, 0x3d, 0x7a, 0xbe, 0x70, 0xe9, 0x82, 0x2e, 0x46, 0xda, 0xbb, 0x3d, 0x97, 0x1b, + 0x41, 0x7e, 0x0c, 0xe3, 0x6d, 0x4b, 0x34, 0x1a, 0x14, 0x9d, 0x7d, 0x6b, 0x1f, 0x22, 0x50, 0x6e, + 0xdb, 0x5d, 0xfa, 0x3c, 0x9c, 0x59, 0xd6, 0xce, 0x2d, 0x4a, 0xdb, 0xb9, 0xda, 0xbf, 0x10, 0x28, + 0x6f, 0x75, 0x89, 0xbf, 0x7f, 0x94, 0x26, 0x8e, 0x61, 0x9c, 0x3c, 0xee, 0xf8, 0xe2, 0xc4, 0x62, + 0xdf, 0xfd, 0x16, 0x5a, 0xea, 0xb7, 0x50, 0x99, 0x6f, 0x94, 0xa5, 0x0d, 0xb0, 0x0f, 0x7b, 0x62, + 0x8e, 0xb0, 0x8f, 0x19, 0xdb, 0x2c, 0x1c, 0xda, 0x36, 0xff, 0x8e, 0x60, 0x6e, 0x93, 0xf8, 0xd4, + 0xa2, 0x01, 0x71, 0x03, 0x51, 0x2a, 0x6f, 0xb8, 0x0f, 0xbd, 0x74, 0x4f, 0x02, 0x65, 0x7a, 0x12, + 0x9f, 0x4d, 0x85, 0x1e, 0xda, 0xbf, 0xdb, 0x75, 0x78, 0x76, 0xcb, 0xbb, 0x44, 0x13, 0x6e, 0xd7, + 0x61, 0xa9, 0xef, 0xcd, 0x28, 0x83, 0x2b, 0xb1, 0x50, 0x2b, 0x0f, 0x96, 0x82, 0xdf, 0x54, 0x0e, + 0xf7, 0x53, 0x7e, 0xbf, 0x23, 0x15, 0xea, 0xd9, 0x4d, 0x6a, 0x1e, 0x84, 0x0d, 0x65, 0x2c, 0xea, + 0x0b, 0x90, 0x31, 0x9d, 0x9c, 0x5b, 0xa7, 0x5f, 0x20, 0x58, 0xcc, 0xe7, 0x6a, 0x94, 0xcc, 0xe4, + 0x9b, 0x50, 0xb2, 0xdc, 0x87, 0x5e, 0x54, 0xb9, 0x5d, 0x96, 0x1f, 0xe4, 0xd2, 0x75, 0xf9, 0x44, + 0xed, 0xdf, 0x08, 0xea, 0xcc, 0x14, 0x8f, 0x60, 0xfb, 0x1d, 0xe2, 0x34, 0xa9, 0xf5, 0x84, 0x44, + 0xdb, 0xef, 0x10, 0x67, 0xcb, 0x7a, 0x42, 0x52, 0x96, 0x51, 0x4a, 0x5b, 0x46, 0x3a, 0xf9, 0x2d, + 0x0f, 0xa8, 0xcc, 0x27, 0x52, 0x95, 0xb9, 0xf6, 0x14, 0x81, 0xba, 0x4e, 0x82, 0xac, 0xa8, 0x47, + 0x67, 0x14, 0x1f, 0x23, 0x38, 0x2d, 0x65, 0x68, 0x14, 0x7b, 0xf8, 0x4a, 0xda, 0x1e, 0xe4, 0x89, + 0x5d, 0xdf, 0x92, 0xc2, 0x14, 0x5e, 0x03, 0x65, 0xad, 0xeb, 0x38, 0x71, 0xec, 0xbd, 0x00, 0x8a, + 0xcf, 0x3f, 0x79, 0xde, 0xc3, 0xb3, 0xd5, 0xaa, 0x80, 0x85, 0xd9, 0x8d, 0x76, 0x05, 0x6a, 0x62, + 0x8a, 0xe0, 0x5a, 0x85, 0x49, 0x5f, 0x7c, 0x0b, 0xfc, 0x78, 0xac, 0xcd, 0xc1, 0x8c, 0x4e, 0x76, + 0x42, 0x4b, 0xf4, 0xdf, 0xb4, 0xdc, 0x47, 0x62, 0x99, 0x30, 0x4b, 0x9f, 0x4d, 0xc3, 0x05, 0xad, + 0x2f, 0xc2, 0x84, 0x61, 0x9a, 0x61, 0xad, 0x3d, 0x70, 0x5b, 0xde, 0xe0, 0x38, 0x7a, 0x84, 0x9c, + 0xd0, 0x5c, 0x61, 0x68, 0xcd, 0x5d, 0xbe, 0xca, 0xdb, 0x97, 0x99, 0x1b, 0x4e, 0x3c, 0x01, 0xc5, + 0x37, 0x6c, 0xbb, 0x3e, 0x86, 0x15, 0x98, 0xdc, 0x70, 0xef, 0x11, 0xc7, 0xf3, 0xf7, 0xeb, 0xe8, + 0xf2, 0xd7, 0x61, 0x3a, 0x93, 0x8c, 0xe3, 0x49, 0x18, 0xbf, 0xef, 0xb9, 0xa4, 0x3e, 0x86, 0xeb, + 0xa0, 0xac, 0x5a, 0xae, 0xe1, 0xef, 0xbf, 0x43, 0x5a, 0x81, 0xe7, 0xd7, 0x4d, 0x3c, 0x0d, 0xd5, + 0xdb, 0xb6, 0x67, 0x04, 0x02, 0x40, 0x56, 0x3e, 0x5a, 0x80, 0xda, 0x3d, 0xc6, 0xd4, 0x16, 0xf1, + 0x77, 0xad, 0x16, 0xc1, 0x4d, 0xa8, 0x67, 0x5f, 0x3f, 0xe1, 0xab, 0xd2, 0xed, 0xcb, 0x79, 0x24, + 0xa5, 0x0e, 0x12, 0x53, 0x1b, 0xc3, 0xef, 0xc3, 0x54, 0xfa, 0x5d, 0x12, 0x96, 0x47, 0x0b, 0xe9, + 0xe3, 0xa5, 0x83, 0x88, 0x37, 0xa1, 0x96, 0x7a, 0x66, 0x84, 0x2f, 0x49, 0x69, 0xcb, 0x9e, 0x22, + 0xa9, 0x17, 0xa4, 0xa8, 0xc9, 0xa7, 0x40, 0x9c, 0xfb, 0xf4, 0x6b, 0x8b, 0x1c, 0xee, 0xa5, 0x4f, + 0x32, 0x0e, 0xe2, 0xde, 0x80, 0x53, 0x7d, 0x8f, 0x27, 0xf0, 0x2b, 0x52, 0xfa, 0x79, 0x8f, 0x2c, + 0x0e, 0x5a, 0x62, 0x0f, 0x70, 0xff, 0x73, 0x1a, 0xbc, 0x2c, 0xdf, 0x81, 0xbc, 0xc7, 0x44, 0xea, + 0xb5, 0xa1, 0xf1, 0x63, 0xc5, 0xfd, 0x00, 0xc1, 0x42, 0xce, 0x8b, 0x07, 0x7c, 0x5d, 0x4a, 0x6e, + 0xf0, 0xb3, 0x0d, 0xf5, 0xf5, 0xc3, 0x4d, 0x8a, 0x19, 0x71, 0x61, 0x3a, 0xe3, 0x60, 0xf8, 0xca, + 0x30, 0x0f, 0x0d, 0xa2, 0x75, 0xaf, 0x0e, 0x87, 0x1c, 0xaf, 0xf7, 0x00, 0xa6, 0x33, 0x37, 0xfe, + 0x39, 0xeb, 0xc9, 0xdf, 0x05, 0x1c, 0xb4, 0xa1, 0xef, 0x41, 0x2d, 0x75, 0x35, 0x9f, 0x63, 0xf1, + 0xb2, 0xeb, 0xfb, 0x83, 0x48, 0x3f, 0x00, 0x25, 0x79, 0x83, 0x8e, 0x97, 0xf2, 0x7c, 0xa9, 0x8f, + 0xf0, 0x61, 0x5c, 0xa9, 0x77, 0xf9, 0x36, 0xc0, 0x95, 0xfa, 0xee, 0x14, 0x87, 0x77, 0xa5, 0x04, + 0xfd, 0x81, 0xae, 0x74, 0xe8, 0x25, 0x3e, 0x40, 0x30, 0x2f, 0xbf, 0x80, 0xc5, 0x2b, 0x79, 0xb6, + 0x99, 0x7f, 0xd5, 0xac, 0x5e, 0x3f, 0xd4, 0x9c, 0x58, 0x8b, 0x8f, 0x60, 0x2a, 0x7d, 0x85, 0x99, + 0xa3, 0x45, 0xe9, 0xcd, 0xac, 0x7a, 0x65, 0x28, 0xdc, 0x78, 0xb1, 0xef, 0x40, 0x35, 0x71, 0xbd, + 0x84, 0x5f, 0x1e, 0x60, 0xc7, 0xc9, 0xee, 0xe5, 0x41, 0x9a, 0x6c, 0x43, 0x2d, 0x75, 0xa5, 0x90, + 0x67, 0xc3, 0x92, 0x9b, 0x1e, 0xf5, 0xf2, 0x30, 0xa8, 0xb1, 0x00, 0x6d, 0xa8, 0xa5, 0x1a, 0xbc, + 0x39, 0x2b, 0xc9, 0xfa, 0xd9, 0x39, 0x2b, 0x49, 0xfb, 0xc5, 0xda, 0x18, 0xfe, 0x7e, 0xa2, 0x97, + 0x9c, 0xea, 0xd7, 0xe3, 0xd7, 0x06, 0xd2, 0x91, 0x5d, 0x57, 0xa8, 0x2b, 0x87, 0x99, 0x12, 0xb3, + 0xf0, 0x16, 0x54, 0xe2, 0x3e, 0x32, 0xbe, 0x98, 0x1b, 0x16, 0x0e, 0xb3, 0x53, 0x5b, 0x50, 0xe6, + 0x8d, 0x4c, 0xac, 0xe5, 0x5c, 0xce, 0x24, 0x1a, 0xbe, 0xea, 0x8b, 0x03, 0x71, 0x62, 0x3e, 0x75, + 0x28, 0xf3, 0x6e, 0x42, 0x0e, 0xd1, 0x54, 0x77, 0x4f, 0x1d, 0x8c, 0xc3, 0xca, 0x58, 0x6d, 0x0c, + 0xbf, 0x0b, 0x93, 0x51, 0x8f, 0x06, 0xbf, 0x94, 0xe3, 0xf6, 0xa9, 0x26, 0x96, 0x7a, 0x10, 0x56, + 0x44, 0x79, 0x03, 0x4a, 0xac, 0x41, 0x81, 0xe5, 0x41, 0x2e, 0xd9, 0xbc, 0x38, 0x48, 0x9b, 0xdf, + 0x86, 0x12, 0xcb, 0x81, 0x73, 0x48, 0x25, 0x1b, 0x10, 0xea, 0x40, 0x94, 0x88, 0xb7, 0x1f, 0x21, + 0x68, 0xe4, 0x15, 0x78, 0x38, 0xf7, 0xc0, 0x1c, 0x54, 0xa5, 0xaa, 0x37, 0x0e, 0x39, 0x2b, 0xde, + 0xd5, 0x27, 0x30, 0x23, 0x29, 0x2b, 0xf0, 0xb5, 0x3c, 0x7a, 0x39, 0x15, 0x91, 0xfa, 0xea, 0xf0, + 0x13, 0xe2, 0xb5, 0x37, 0xa1, 0xc4, 0xca, 0x81, 0x1c, 0xc5, 0x26, 0xab, 0x8b, 0x1c, 0x7b, 0x4a, + 0x55, 0x13, 0xda, 0x18, 0x26, 0xa0, 0x24, 0x6b, 0x83, 0x9c, 0xb3, 0x50, 0x52, 0x56, 0xa8, 0x97, + 0x86, 0xc0, 0x8c, 0x96, 0x59, 0xe9, 0x82, 0xb2, 0xe9, 0x7b, 0x8f, 0xf7, 0xa3, 0x6c, 0xfc, 0xf3, + 0x59, 0x76, 0xf5, 0xc6, 0x77, 0xaf, 0xef, 0x58, 0x41, 0xbb, 0xbb, 0x1d, 0x9a, 0xe8, 0x35, 0x8e, + 0xfb, 0x8a, 0xe5, 0x89, 0xaf, 0x6b, 0x96, 0x1b, 0x10, 0xdf, 0x35, 0xec, 0x6b, 0x8c, 0x96, 0x80, + 0x76, 0xb6, 0xb7, 0xcb, 0x6c, 0x7c, 0xfd, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfc, 0xc8, 0xca, + 0x31, 0x72, 0x31, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3548,6 +3680,7 @@ type MilvusServiceClient interface { Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResults, error) Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error) + Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResults, error) GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error) GetQuerySegmentInfo(ctx context.Context, in *GetQuerySegmentInfoRequest, opts ...grpc.CallOption) (*GetQuerySegmentInfoResponse, error) Dummy(ctx context.Context, in *DummyRequest, opts ...grpc.CallOption) (*DummyResponse, error) @@ -3779,6 +3912,15 @@ func (c *milvusServiceClient) Flush(ctx context.Context, in *FlushRequest, opts return out, nil } +func (c *milvusServiceClient) Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResults, error) { + out := new(QueryResults) + err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/Query", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *milvusServiceClient) GetPersistentSegmentInfo(ctx context.Context, in *GetPersistentSegmentInfoRequest, opts ...grpc.CallOption) (*GetPersistentSegmentInfoResponse, error) { out := new(GetPersistentSegmentInfoResponse) err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo", in, out, opts...) @@ -3841,6 +3983,7 @@ type MilvusServiceServer interface { Search(context.Context, *SearchRequest) (*SearchResults, error) Retrieve(context.Context, *RetrieveRequest) (*RetrieveResults, error) Flush(context.Context, *FlushRequest) (*commonpb.Status, error) + Query(context.Context, *QueryRequest) (*QueryResults, error) GetPersistentSegmentInfo(context.Context, *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error) GetQuerySegmentInfo(context.Context, *GetQuerySegmentInfoRequest) (*GetQuerySegmentInfoResponse, error) Dummy(context.Context, *DummyRequest) (*DummyResponse, error) @@ -3924,6 +4067,9 @@ func (*UnimplementedMilvusServiceServer) Retrieve(ctx context.Context, req *Retr func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented") } +func (*UnimplementedMilvusServiceServer) Query(ctx context.Context, req *QueryRequest) (*QueryResults, error) { + return nil, status.Errorf(codes.Unimplemented, "method Query not implemented") +} func (*UnimplementedMilvusServiceServer) GetPersistentSegmentInfo(ctx context.Context, req *GetPersistentSegmentInfoRequest) (*GetPersistentSegmentInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetPersistentSegmentInfo not implemented") } @@ -4373,6 +4519,24 @@ func _MilvusService_Flush_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _MilvusService_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MilvusServiceServer).Query(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.milvus.MilvusService/Query", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MilvusServiceServer).Query(ctx, req.(*QueryRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _MilvusService_GetPersistentSegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetPersistentSegmentInfoRequest) if err := dec(in); err != nil { @@ -4545,6 +4709,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{ MethodName: "Flush", Handler: _MilvusService_Flush_Handler, }, + { + MethodName: "Query", + Handler: _MilvusService_Query_Handler, + }, { MethodName: "GetPersistentSegmentInfo", Handler: _MilvusService_GetPersistentSegmentInfo_Handler, diff --git a/internal/proxynode/impl.go b/internal/proxynode/impl.go index afeca9c6dc..028627c26c 100644 --- a/internal/proxynode/impl.go +++ b/internal/proxynode/impl.go @@ -1275,6 +1275,10 @@ func (node *ProxyNode) Flush(ctx context.Context, request *milvuspb.FlushRequest return ft.result, nil } +func (node *ProxyNode) Query(ctx context.Context, request *milvuspb.QueryRequest) (*milvuspb.QueryResults, error) { + panic("Not implemented yet") +} + func (node *ProxyNode) GetDdChannel(ctx context.Context, request *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) { panic("implement me") }