diff --git a/docs/developer_guides/chap05_proxy.md b/docs/developer_guides/chap05_proxy.md index 1decc89b01..6689f187ed 100644 --- a/docs/developer_guides/chap05_proxy.md +++ b/docs/developer_guides/chap05_proxy.md @@ -96,6 +96,8 @@ type ProxyNode interface { Insert(req InsertRequest) (InsertResponse, error) Search(req SearchRequest) (SearchResults, error) Flush(req FlushRequest) error + GetPersistentSegmentInfo(req PersistentSegmentInfoRequest) (PersistentSegmentInfoResponse, error) + } ``` @@ -237,6 +239,36 @@ type FlushRequest struct { ``` +* *GetPersistentSegmentInfo* + +```go +type PersistentSegmentInfoRequest struct{ + MsgBase + DbName string + CollectionName string +} +``` + +```go +type PersistentSegmentInfo struct { + SegmentID UniqueID + CollectionID UniqueID + PartitionID UniqueID + OpenTime Timestamp + SealedTime Timestamp + FlushedTime Timestamp + NumRows int64 + MemSize int64 + State SegmentState +} +``` + +```go +type PersistentSegmentInfoResponse struct{ + infos []SegmentInfo +} +``` + #### 6.1 Proxy Instance diff --git a/docs/developer_guides/chap09_data_service.md b/docs/developer_guides/chap09_data_service.md index f5846dd5ec..d92c882841 100644 --- a/docs/developer_guides/chap09_data_service.md +++ b/docs/developer_guides/chap09_data_service.md @@ -20,12 +20,15 @@ type DataService interface { AssignSegmentID(req AssignSegIDRequest) (AssignSegIDResponse, error) ShowSegments(req ShowSegmentRequest) (ShowSegmentResponse, error) GetSegmentStates(req SegmentStatesRequest) (SegmentStatesResponse, error) + GetSegmentInfo(req SegmentInfoRequest) (SegmentInfoResponse, error) + GetInsertBinlogPaths(req InsertBinlogPathRequest) (InsertBinlogPathsResponse, error) GetInsertChannels(req InsertChannelRequest) ([]string, error) GetCollectionStatistics(req CollectionStatsRequest) (CollectionStatsResponse, error) GetPartitionStatistics(req PartitionStatsRequest) (PartitionStatsResponse, error) + } ``` @@ -139,7 +142,37 @@ type SegmentStatesResponse struct { } ``` +* *GetSegmentInfo* +```go +type SegmentInfoRequest struct{ + MsgBase + SegmentIDs [] UniqueID +} +``` + +```go +type SegmentInfo struct { + SegmentID UniqueID + CollectionID UniqueID + PartitionID UniqueID + InsertChannel string + OpenTime Timestamp + SealedTime Timestamp + FlushedTime Timestamp + NumRows int64 + MemSize int64 + State SegmentState + StartPosition []Msgstream.MsgPosition + EndPosition []Msgstream.MsgPosition +} +``` + +```go +type SegmentInfoResponse struct{ + infos []SegmentInfo +} +``` * *GetInsertBinlogPaths* diff --git a/internal/core/src/pb/common.pb.cc b/internal/core/src/pb/common.pb.cc index 11b04de177..f6440ec461 100644 --- a/internal/core/src/pb/common.pb.cc +++ b/internal/core/src/pb/common.pb.cc @@ -150,7 +150,7 @@ static void InitDefaultsscc_info_Status_common_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_common_2eproto}, {}}; static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_common_2eproto[7]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_common_2eproto[3]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_common_2eproto[4]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_common_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_common_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -249,26 +249,28 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE( "PE\020\027\022\021\n\rOUT_OF_MEMORY\020\030\022\024\n\017DD_REQUEST_RA" "CE\020\350\007*N\n\nIndexState\022\010\n\004NONE\020\000\022\014\n\010UNISSUE" "D\020\001\022\016\n\nINPROGRESS\020\002\022\014\n\010FINISHED\020\003\022\n\n\006FAI" - "LED\020\004*\252\005\n\007MsgType\022\t\n\005kNone\020\000\022\025\n\021kCreateC" - "ollection\020d\022\023\n\017kDropCollection\020e\022\022\n\016kHas" - "Collection\020f\022\027\n\023kDescribeCollection\020g\022\024\n" - "\020kShowCollections\020h\022\022\n\016kGetSysConfigs\020i\022" - "\025\n\020kCreatePartition\020\310\001\022\023\n\016kDropPartition" - "\020\311\001\022\022\n\rkHasPartition\020\312\001\022\027\n\022kDescribePart" - "ition\020\313\001\022\024\n\017kShowPartitions\020\314\001\022\021\n\014kShowS" - "egment\020\372\001\022\025\n\020kDescribeSegment\020\373\001\022\021\n\014kCre" - "ateIndex\020\254\002\022\023\n\016kDescribeIndex\020\255\002\022\014\n\007kIns" - "ert\020\220\003\022\014\n\007kDelete\020\221\003\022\013\n\006kFlush\020\222\003\022\014\n\007kSe" - "arch\020\364\003\022\022\n\rkSearchResult\020\365\003\022\023\n\016kGetIndex" - "State\020\366\003\022\035\n\030kGetCollectionStatistics\020\367\003\022" - "\034\n\027kGetPartitionStatistics\020\370\003\022\021\n\014kSegmen" - "tInfo\020\330\004\022\016\n\tkTimeTick\020\260\t\022\024\n\017kQueryNodeSt" - "ats\020\261\t\022\017\n\nkLoadIndex\020\262\t\022\017\n\nkRequestID\020\263\t" - "\022\020\n\013kRequestTSO\020\264\t\022\025\n\020kAllocateSegment\020\265" - "\t\022\027\n\022kSegmentStatistics\020\266\t\022\026\n\021kSegmentFl" - "ushDone\020\267\tBBZ@github.com/zilliztech/milv" - "us-distributed/internal/proto/commonpbb\006" - "proto3" + "LED\020\004*o\n\014SegmentState\022\017\n\013SegmentNone\020\000\022\023" + "\n\017SegmentNotExist\020\001\022\022\n\016SegmentGrowing\020\002\022" + "\021\n\rSegmentSealed\020\003\022\022\n\016SegmentFlushed\020\004*\252" + "\005\n\007MsgType\022\t\n\005kNone\020\000\022\025\n\021kCreateCollecti" + "on\020d\022\023\n\017kDropCollection\020e\022\022\n\016kHasCollect" + "ion\020f\022\027\n\023kDescribeCollection\020g\022\024\n\020kShowC" + "ollections\020h\022\022\n\016kGetSysConfigs\020i\022\025\n\020kCre" + "atePartition\020\310\001\022\023\n\016kDropPartition\020\311\001\022\022\n\r" + "kHasPartition\020\312\001\022\027\n\022kDescribePartition\020\313" + "\001\022\024\n\017kShowPartitions\020\314\001\022\021\n\014kShowSegment\020" + "\372\001\022\025\n\020kDescribeSegment\020\373\001\022\021\n\014kCreateInde" + "x\020\254\002\022\023\n\016kDescribeIndex\020\255\002\022\014\n\007kInsert\020\220\003\022" + "\014\n\007kDelete\020\221\003\022\013\n\006kFlush\020\222\003\022\014\n\007kSearch\020\364\003" + "\022\022\n\rkSearchResult\020\365\003\022\023\n\016kGetIndexState\020\366" + "\003\022\035\n\030kGetCollectionStatistics\020\367\003\022\034\n\027kGet" + "PartitionStatistics\020\370\003\022\021\n\014kSegmentInfo\020\330" + "\004\022\016\n\tkTimeTick\020\260\t\022\024\n\017kQueryNodeStats\020\261\t\022" + "\017\n\nkLoadIndex\020\262\t\022\017\n\nkRequestID\020\263\t\022\020\n\013kRe" + "questTSO\020\264\t\022\025\n\020kAllocateSegment\020\265\t\022\027\n\022kS" + "egmentStatistics\020\266\t\022\026\n\021kSegmentFlushDone" + "\020\267\tBBZ@github.com/zilliztech/milvus-dist" + "ributed/internal/proto/commonpbb\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = { }; @@ -284,7 +286,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once; static bool descriptor_table_common_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = { - &descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 1806, + &descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 1919, &descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 7, 0, schemas, file_default_instances, TableStruct_common_2eproto::offsets, file_level_metadata_common_2eproto, 7, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto, @@ -349,10 +351,27 @@ bool IndexState_IsValid(int value) { } } -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MsgType_descriptor() { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SegmentState_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_common_2eproto); return file_level_enum_descriptors_common_2eproto[2]; } +bool SegmentState_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MsgType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_common_2eproto); + return file_level_enum_descriptors_common_2eproto[3]; +} bool MsgType_IsValid(int value) { switch (value) { case 0: diff --git a/internal/core/src/pb/common.pb.h b/internal/core/src/pb/common.pb.h index b8c275bf3f..5c038a37ff 100644 --- a/internal/core/src/pb/common.pb.h +++ b/internal/core/src/pb/common.pb.h @@ -171,6 +171,34 @@ inline bool IndexState_Parse( return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( IndexState_descriptor(), name, value); } +enum SegmentState : int { + SegmentNone = 0, + SegmentNotExist = 1, + SegmentGrowing = 2, + SegmentSealed = 3, + SegmentFlushed = 4, + SegmentState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + SegmentState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool SegmentState_IsValid(int value); +constexpr SegmentState SegmentState_MIN = SegmentNone; +constexpr SegmentState SegmentState_MAX = SegmentFlushed; +constexpr int SegmentState_ARRAYSIZE = SegmentState_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SegmentState_descriptor(); +template +inline const std::string& SegmentState_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SegmentState_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SegmentState_descriptor(), enum_t_value); +} +inline bool SegmentState_Parse( + const std::string& name, SegmentState* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SegmentState_descriptor(), name, value); +} enum MsgType : int { kNone = 0, kCreateCollection = 100, @@ -1669,6 +1697,11 @@ template <> inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::IndexState>() { return ::milvus::proto::common::IndexState_descriptor(); } +template <> struct is_proto_enum< ::milvus::proto::common::SegmentState> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::SegmentState>() { + return ::milvus::proto::common::SegmentState_descriptor(); +} template <> struct is_proto_enum< ::milvus::proto::common::MsgType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::MsgType>() { diff --git a/internal/core/src/pb/milvus.pb.cc b/internal/core/src/pb/milvus.pb.cc index 01fde23384..6564f46072 100644 --- a/internal/core/src/pb/milvus.pb.cc +++ b/internal/core/src/pb/milvus.pb.cc @@ -21,6 +21,7 @@ extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_MsgBase_common_2eproto; extern PROTOBUF_INTERNAL_EXPORT_common_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_common_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_IndexDescription_milvus_2eproto; +extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PersistentSegmentInfo_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PlaceholderValue_milvus_2eproto; extern PROTOBUF_INTERNAL_EXPORT_schema_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionSchema_schema_2eproto; namespace milvus { @@ -186,6 +187,18 @@ class FlushRequestDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _FlushRequest_default_instance_; +class PersistentSegmentInfoDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PersistentSegmentInfo_default_instance_; +class PersistentSegmentInfoRequestDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PersistentSegmentInfoRequest_default_instance_; +class PersistentSegmentInfoResponseDefaultTypeInternal { + public: + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _PersistentSegmentInfoResponse_default_instance_; class RegisterLinkResponseDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -603,6 +616,51 @@ static void InitDefaultsscc_info_PartitionStatsResponse_milvus_2eproto() { &scc_info_Status_common_2eproto.base, &scc_info_KeyValuePair_common_2eproto.base,}}; +static void InitDefaultsscc_info_PersistentSegmentInfo_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_PersistentSegmentInfo_default_instance_; + new (ptr) ::milvus::proto::milvus::PersistentSegmentInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::PersistentSegmentInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PersistentSegmentInfo_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_PersistentSegmentInfo_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_PersistentSegmentInfoRequest_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_PersistentSegmentInfoRequest_default_instance_; + new (ptr) ::milvus::proto::milvus::PersistentSegmentInfoRequest(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::PersistentSegmentInfoRequest::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_PersistentSegmentInfoRequest_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_PersistentSegmentInfoRequest_milvus_2eproto}, { + &scc_info_MsgBase_common_2eproto.base,}}; + +static void InitDefaultsscc_info_PersistentSegmentInfoResponse_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::proto::milvus::_PersistentSegmentInfoResponse_default_instance_; + new (ptr) ::milvus::proto::milvus::PersistentSegmentInfoResponse(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::proto::milvus::PersistentSegmentInfoResponse::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_PersistentSegmentInfoResponse_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_PersistentSegmentInfoResponse_milvus_2eproto}, { + &scc_info_Status_common_2eproto.base, + &scc_info_PersistentSegmentInfo_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_PlaceholderGroup_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -813,7 +871,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[41]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[44]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_milvus_2eproto[1]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr; @@ -1146,6 +1204,35 @@ 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::PersistentSegmentInfo, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, segmentid_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, collectionid_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, partitionid_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, open_time_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, sealed_time_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, flushed_time_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, num_rows_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, mem_size_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfo, state_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoRequest, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoRequest, base_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoRequest, dbname_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoRequest, collectionname_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoResponse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoResponse, status_), + PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::PersistentSegmentInfoResponse, infos_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::RegisterLinkResponse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -1194,7 +1281,10 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 304, -1, sizeof(::milvus::proto::milvus::Hits)}, { 312, -1, sizeof(::milvus::proto::milvus::SearchResults)}, { 319, -1, sizeof(::milvus::proto::milvus::FlushRequest)}, - { 327, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)}, + { 327, -1, sizeof(::milvus::proto::milvus::PersistentSegmentInfo)}, + { 341, -1, sizeof(::milvus::proto::milvus::PersistentSegmentInfoRequest)}, + { 349, -1, sizeof(::milvus::proto::milvus::PersistentSegmentInfoResponse)}, + { 356, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1238,6 +1328,9 @@ 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::_PersistentSegmentInfo_default_instance_), + reinterpret_cast(&::milvus::proto::milvus::_PersistentSegmentInfoRequest_default_instance_), + reinterpret_cast(&::milvus::proto::milvus::_PersistentSegmentInfoResponse_default_instance_), reinterpret_cast(&::milvus::proto::milvus::_RegisterLinkResponse_default_instance_), }; @@ -1361,76 +1454,92 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE( "\0132\033.milvus.proto.common.Status\022\014\n\004hits\030\002" " \003(\014\"e\n\014FlushRequest\022*\n\004base\030\001 \001(\0132\034.mil" "vus.proto.common.MsgBase\022\017\n\007db_name\030\002 \001(" - "\t\022\030\n\020collection_names\030\003 \003(\t\"r\n\024RegisterL" - "inkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pr" - "oto.common.Address\022+\n\006status\030\002 \001(\0132\033.mil" - "vus.proto.common.Status*@\n\017PlaceholderTy" - "pe\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTO" - "R_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateCol" - "lection\022,.milvus.proto.milvus.CreateColl" - "ectionRequest\032\033.milvus.proto.common.Stat" - "us\"\000\022[\n\016DropCollection\022*.milvus.proto.mi" - "lvus.DropCollectionRequest\032\033.milvus.prot" - "o.common.Status\"\000\022_\n\rHasCollection\022).mil" - "vus.proto.milvus.HasCollectionRequest\032!." - "milvus.proto.milvus.BoolResponse\"\000\022[\n\016Lo" - "adCollection\022*.milvus.proto.milvus.LoadC" - "ollectionRequest\032\033.milvus.proto.common.S" - "tatus\"\000\022a\n\021ReleaseCollection\022-.milvus.pr" - "oto.milvus.ReleaseCollectionRequest\032\033.mi" - "lvus.proto.common.Status\"\000\022w\n\022DescribeCo" - "llection\022..milvus.proto.milvus.DescribeC" - "ollectionRequest\032/.milvus.proto.milvus.D" - "escribeCollectionResponse\"\000\022v\n\027GetCollec" - "tionStatistics\022+.milvus.proto.milvus.Col" - "lectionStatsRequest\032,.milvus.proto.milvu" - "s.CollectionStatsResponse\"\000\022l\n\017ShowColle" - "ctions\022*.milvus.proto.milvus.ShowCollect" - "ionRequest\032+.milvus.proto.milvus.ShowCol" - "lectionResponse\"\000\022]\n\017CreatePartition\022+.m" - "ilvus.proto.milvus.CreatePartitionReques" - "t\032\033.milvus.proto.common.Status\"\000\022Y\n\rDrop" - "Partition\022).milvus.proto.milvus.DropPart" - "itionRequest\032\033.milvus.proto.common.Statu" - "s\"\000\022]\n\014HasPartition\022(.milvus.proto.milvu" - "s.HasPartitionRequest\032!.milvus.proto.mil" - "vus.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.m" - "ilvus.proto.milvus.LoadPartitonRequest\032\033" - ".milvus.proto.common.Status\"\000\022`\n\021Release" - "Partitions\022,.milvus.proto.milvus.Release" - "PartitionRequest\032\033.milvus.proto.common.S" - "tatus\"\000\022s\n\026GetPartitionStatistics\022*.milv" - "us.proto.milvus.PartitionStatsRequest\032+." - "milvus.proto.milvus.PartitionStatsRespon" - "se\"\000\022i\n\016ShowPartitions\022).milvus.proto.mi" - "lvus.ShowPartitionRequest\032*.milvus.proto" - ".milvus.ShowPartitionResponse\"\000\022U\n\013Creat" - "eIndex\022\'.milvus.proto.milvus.CreateIndex" - "Request\032\033.milvus.proto.common.Status\"\000\022h" - "\n\rDescribeIndex\022).milvus.proto.milvus.De" - "scribeIndexRequest\032*.milvus.proto.milvus" - ".DescribeIndexResponse\"\000\022b\n\rGetIndexStat" - "e\022&.milvus.proto.milvus.IndexStateReques" - "t\032\'.milvus.proto.milvus.IndexStateRespon" - "se\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Ins" - "ertRequest\032#.milvus.proto.milvus.InsertR" - "esponse\"\000\022R\n\006Search\022\".milvus.proto.milvu" - "s.SearchRequest\032\".milvus.proto.milvus.Se" - "archResults\"\000\022I\n\005Flush\022!.milvus.proto.mi" - "lvus.FlushRequest\032\033.milvus.proto.common." - "Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto." - "common.Empty\032#.milvus.proto.milvus.Strin" - "gResponse\"\0002g\n\014ProxyService\022W\n\014RegisterL" - "ink\022\032.milvus.proto.common.Empty\032).milvus" - ".proto.milvus.RegisterLinkResponse\"\000BBZ@" - "github.com/zilliztech/milvus-distributed" - "/internal/proto/milvuspbb\006proto3" + "\t\022\030\n\020collection_names\030\003 \003(\t\"\351\001\n\025Persiste" + "ntSegmentInfo\022\021\n\tsegmentID\030\001 \001(\003\022\024\n\014coll" + "ectionID\030\002 \001(\003\022\023\n\013partitionID\030\003 \001(\003\022\021\n\to" + "pen_time\030\004 \001(\004\022\023\n\013sealed_time\030\005 \001(\004\022\024\n\014f" + "lushed_time\030\006 \001(\004\022\020\n\010num_rows\030\007 \001(\003\022\020\n\010m" + "em_size\030\010 \001(\003\0220\n\005state\030\t \001(\0162!.milvus.pr" + "oto.common.SegmentState\"r\n\034PersistentSeg" + "mentInfoRequest\022*\n\004base\030\001 \001(\0132\034.milvus.p" + "roto.common.MsgBase\022\016\n\006dbName\030\002 \001(\t\022\026\n\016c" + "ollectionName\030\003 \001(\t\"\207\001\n\035PersistentSegmen" + "tInfoResponse\022+\n\006status\030\001 \001(\0132\033.milvus.p" + "roto.common.Status\0229\n\005infos\030\002 \003(\0132*.milv" + "us.proto.milvus.PersistentSegmentInfo\"r\n" + "\024RegisterLinkResponse\022-\n\007address\030\001 \001(\0132\034" + ".milvus.proto.common.Address\022+\n\006status\030\002" + " \001(\0132\033.milvus.proto.common.Status*@\n\017Pla" + "ceholderType\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020" + "d\022\020\n\014VECTOR_FLOAT\020e2\365\021\n\rMilvusService\022_\n" + "\020CreateCollection\022,.milvus.proto.milvus." + "CreateCollectionRequest\032\033.milvus.proto.c" + "ommon.Status\"\000\022[\n\016DropCollection\022*.milvu" + "s.proto.milvus.DropCollectionRequest\032\033.m" + "ilvus.proto.common.Status\"\000\022_\n\rHasCollec" + "tion\022).milvus.proto.milvus.HasCollection" + "Request\032!.milvus.proto.milvus.BoolRespon" + "se\"\000\022[\n\016LoadCollection\022*.milvus.proto.mi" + "lvus.LoadCollectionRequest\032\033.milvus.prot" + "o.common.Status\"\000\022a\n\021ReleaseCollection\022-" + ".milvus.proto.milvus.ReleaseCollectionRe" + "quest\032\033.milvus.proto.common.Status\"\000\022w\n\022" + "DescribeCollection\022..milvus.proto.milvus" + ".DescribeCollectionRequest\032/.milvus.prot" + "o.milvus.DescribeCollectionResponse\"\000\022v\n" + "\027GetCollectionStatistics\022+.milvus.proto." + "milvus.CollectionStatsRequest\032,.milvus.p" + "roto.milvus.CollectionStatsResponse\"\000\022l\n" + "\017ShowCollections\022*.milvus.proto.milvus.S" + "howCollectionRequest\032+.milvus.proto.milv" + "us.ShowCollectionResponse\"\000\022]\n\017CreatePar" + "tition\022+.milvus.proto.milvus.CreateParti" + "tionRequest\032\033.milvus.proto.common.Status" + "\"\000\022Y\n\rDropPartition\022).milvus.proto.milvu" + "s.DropPartitionRequest\032\033.milvus.proto.co" + "mmon.Status\"\000\022]\n\014HasPartition\022(.milvus.p" + "roto.milvus.HasPartitionRequest\032!.milvus" + ".proto.milvus.BoolResponse\"\000\022Y\n\016LoadPart" + "itions\022(.milvus.proto.milvus.LoadPartito" + "nRequest\032\033.milvus.proto.common.Status\"\000\022" + "`\n\021ReleasePartitions\022,.milvus.proto.milv" + "us.ReleasePartitionRequest\032\033.milvus.prot" + "o.common.Status\"\000\022s\n\026GetPartitionStatist" + "ics\022*.milvus.proto.milvus.PartitionStats" + "Request\032+.milvus.proto.milvus.PartitionS" + "tatsResponse\"\000\022i\n\016ShowPartitions\022).milvu" + "s.proto.milvus.ShowPartitionRequest\032*.mi" + "lvus.proto.milvus.ShowPartitionResponse\"" + "\000\022U\n\013CreateIndex\022\'.milvus.proto.milvus.C" + "reateIndexRequest\032\033.milvus.proto.common." + "Status\"\000\022h\n\rDescribeIndex\022).milvus.proto" + ".milvus.DescribeIndexRequest\032*.milvus.pr" + "oto.milvus.DescribeIndexResponse\"\000\022b\n\rGe" + "tIndexState\022&.milvus.proto.milvus.IndexS" + "tateRequest\032\'.milvus.proto.milvus.IndexS" + "tateResponse\"\000\022S\n\006Insert\022\".milvus.proto." + "milvus.InsertRequest\032#.milvus.proto.milv" + "us.InsertResponse\"\000\022R\n\006Search\022\".milvus.p" + "roto.milvus.SearchRequest\032\".milvus.proto" + ".milvus.SearchResults\"\000\022I\n\005Flush\022!.milvu" + "s.proto.milvus.FlushRequest\032\033.milvus.pro" + "to.common.Status\"\000\022Q\n\014GetDdChannel\022\032.mil" + "vus.proto.common.Empty\032#.milvus.proto.mi" + "lvus.StringResponse\"\000\022\203\001\n\030GetPersistentS" + "egmentInfo\0221.milvus.proto.milvus.Persist" + "entSegmentInfoRequest\0322.milvus.proto.mil" + "vus.PersistentSegmentInfoResponse\"\0002g\n\014P" + "roxyService\022W\n\014RegisterLink\022\032.milvus.pro" + "to.common.Empty\032).milvus.proto.milvus.Re" + "gisterLinkResponse\"\000BBZ@github.com/zilli" + "ztech/milvus-distributed/internal/proto/" + "milvuspbb\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = { &::descriptor_table_common_2eproto, &::descriptor_table_schema_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[41] = { +static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[44] = { &scc_info_BoolResponse_milvus_2eproto.base, &scc_info_CollectionStatsRequest_milvus_2eproto.base, &scc_info_CollectionStatsResponse_milvus_2eproto.base, @@ -1458,6 +1567,9 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_LoadPartitonRequest_milvus_2eproto.base, &scc_info_PartitionStatsRequest_milvus_2eproto.base, &scc_info_PartitionStatsResponse_milvus_2eproto.base, + &scc_info_PersistentSegmentInfo_milvus_2eproto.base, + &scc_info_PersistentSegmentInfoRequest_milvus_2eproto.base, + &scc_info_PersistentSegmentInfoResponse_milvus_2eproto.base, &scc_info_PlaceholderGroup_milvus_2eproto.base, &scc_info_PlaceholderValue_milvus_2eproto.base, &scc_info_RegisterLinkResponse_milvus_2eproto.base, @@ -1476,10 +1588,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", 7312, - &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 41, 2, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7936, + &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 44, 2, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, - file_level_metadata_milvus_2eproto, 41, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, + file_level_metadata_milvus_2eproto, 44, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, }; // Force running AddDescriptors() at dynamic initialization time. @@ -17520,6 +17632,1317 @@ void FlushRequest::InternalSwap(FlushRequest* other) { } +// =================================================================== + +void PersistentSegmentInfo::InitAsDefaultInstance() { +} +class PersistentSegmentInfo::_Internal { + public: +}; + +PersistentSegmentInfo::PersistentSegmentInfo() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.PersistentSegmentInfo) +} +PersistentSegmentInfo::PersistentSegmentInfo(const PersistentSegmentInfo& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&segmentid_, &from.segmentid_, + static_cast(reinterpret_cast(&state_) - + reinterpret_cast(&segmentid_)) + sizeof(state_)); + // @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.PersistentSegmentInfo) +} + +void PersistentSegmentInfo::SharedCtor() { + ::memset(&segmentid_, 0, static_cast( + reinterpret_cast(&state_) - + reinterpret_cast(&segmentid_)) + sizeof(state_)); +} + +PersistentSegmentInfo::~PersistentSegmentInfo() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.PersistentSegmentInfo) + SharedDtor(); +} + +void PersistentSegmentInfo::SharedDtor() { +} + +void PersistentSegmentInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PersistentSegmentInfo& PersistentSegmentInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PersistentSegmentInfo_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void PersistentSegmentInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.PersistentSegmentInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&segmentid_, 0, static_cast( + reinterpret_cast(&state_) - + reinterpret_cast(&segmentid_)) + sizeof(state_)); + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* PersistentSegmentInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + CHK_(ptr); + switch (tag >> 3) { + // int64 segmentID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + segmentid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 collectionID = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + collectionid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 partitionID = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + partitionid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 open_time = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + open_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 sealed_time = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + sealed_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 flushed_time = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + flushed_time_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 num_rows = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + num_rows_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 mem_size = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + mem_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .milvus.proto.common.SegmentState state = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + CHK_(ptr); + set_state(static_cast<::milvus::proto::common::SegmentState>(val)); + } 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 PersistentSegmentInfo::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.PersistentSegmentInfo) + for (;;) { + ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // int64 segmentID = 1; + case 1: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &segmentid_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 collectionID = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &collectionid_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 partitionID = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &partitionid_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 open_time = 4; + case 4: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &open_time_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 sealed_time = 5; + case 5: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &sealed_time_))); + } else { + goto handle_unusual; + } + break; + } + + // uint64 flushed_time = 6; + case 6: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (48 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>( + input, &flushed_time_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 num_rows = 7; + case 7: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (56 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &num_rows_))); + } else { + goto handle_unusual; + } + break; + } + + // int64 mem_size = 8; + case 8: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (64 & 0xFF)) { + + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( + input, &mem_size_))); + } else { + goto handle_unusual; + } + break; + } + + // .milvus.proto.common.SegmentState state = 9; + case 9: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (72 & 0xFF)) { + int value = 0; + DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< + int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + set_state(static_cast< ::milvus::proto::common::SegmentState >(value)); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:milvus.proto.milvus.PersistentSegmentInfo) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.PersistentSegmentInfo) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PersistentSegmentInfo::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.PersistentSegmentInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 segmentID = 1; + if (this->segmentid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->segmentid(), output); + } + + // int64 collectionID = 2; + if (this->collectionid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->collectionid(), output); + } + + // int64 partitionID = 3; + if (this->partitionid() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->partitionid(), output); + } + + // uint64 open_time = 4; + if (this->open_time() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(4, this->open_time(), output); + } + + // uint64 sealed_time = 5; + if (this->sealed_time() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(5, this->sealed_time(), output); + } + + // uint64 flushed_time = 6; + if (this->flushed_time() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(6, this->flushed_time(), output); + } + + // int64 num_rows = 7; + if (this->num_rows() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(7, this->num_rows(), output); + } + + // int64 mem_size = 8; + if (this->mem_size() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(8, this->mem_size(), output); + } + + // .milvus.proto.common.SegmentState state = 9; + if (this->state() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum( + 9, this->state(), 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.PersistentSegmentInfo) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PersistentSegmentInfo::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.PersistentSegmentInfo) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 segmentID = 1; + if (this->segmentid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->segmentid(), target); + } + + // int64 collectionID = 2; + if (this->collectionid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->collectionid(), target); + } + + // int64 partitionID = 3; + if (this->partitionid() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->partitionid(), target); + } + + // uint64 open_time = 4; + if (this->open_time() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(4, this->open_time(), target); + } + + // uint64 sealed_time = 5; + if (this->sealed_time() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(5, this->sealed_time(), target); + } + + // uint64 flushed_time = 6; + if (this->flushed_time() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->flushed_time(), target); + } + + // int64 num_rows = 7; + if (this->num_rows() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->num_rows(), target); + } + + // int64 mem_size = 8; + if (this->mem_size() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->mem_size(), target); + } + + // .milvus.proto.common.SegmentState state = 9; + if (this->state() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 9, this->state(), 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.PersistentSegmentInfo) + return target; +} + +size_t PersistentSegmentInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.PersistentSegmentInfo) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 segmentID = 1; + if (this->segmentid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->segmentid()); + } + + // int64 collectionID = 2; + if (this->collectionid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->collectionid()); + } + + // int64 partitionID = 3; + if (this->partitionid() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->partitionid()); + } + + // uint64 open_time = 4; + if (this->open_time() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->open_time()); + } + + // uint64 sealed_time = 5; + if (this->sealed_time() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->sealed_time()); + } + + // uint64 flushed_time = 6; + if (this->flushed_time() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->flushed_time()); + } + + // int64 num_rows = 7; + if (this->num_rows() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->num_rows()); + } + + // int64 mem_size = 8; + if (this->mem_size() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->mem_size()); + } + + // .milvus.proto.common.SegmentState state = 9; + if (this->state() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->state()); + } + + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PersistentSegmentInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.PersistentSegmentInfo) + GOOGLE_DCHECK_NE(&from, this); + const PersistentSegmentInfo* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.PersistentSegmentInfo) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.PersistentSegmentInfo) + MergeFrom(*source); + } +} + +void PersistentSegmentInfo::MergeFrom(const PersistentSegmentInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.PersistentSegmentInfo) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.segmentid() != 0) { + set_segmentid(from.segmentid()); + } + if (from.collectionid() != 0) { + set_collectionid(from.collectionid()); + } + if (from.partitionid() != 0) { + set_partitionid(from.partitionid()); + } + if (from.open_time() != 0) { + set_open_time(from.open_time()); + } + if (from.sealed_time() != 0) { + set_sealed_time(from.sealed_time()); + } + if (from.flushed_time() != 0) { + set_flushed_time(from.flushed_time()); + } + if (from.num_rows() != 0) { + set_num_rows(from.num_rows()); + } + if (from.mem_size() != 0) { + set_mem_size(from.mem_size()); + } + if (from.state() != 0) { + set_state(from.state()); + } +} + +void PersistentSegmentInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.PersistentSegmentInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PersistentSegmentInfo::CopyFrom(const PersistentSegmentInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.PersistentSegmentInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PersistentSegmentInfo::IsInitialized() const { + return true; +} + +void PersistentSegmentInfo::InternalSwap(PersistentSegmentInfo* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(segmentid_, other->segmentid_); + swap(collectionid_, other->collectionid_); + swap(partitionid_, other->partitionid_); + swap(open_time_, other->open_time_); + swap(sealed_time_, other->sealed_time_); + swap(flushed_time_, other->flushed_time_); + swap(num_rows_, other->num_rows_); + swap(mem_size_, other->mem_size_); + swap(state_, other->state_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PersistentSegmentInfo::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PersistentSegmentInfoRequest::InitAsDefaultInstance() { + ::milvus::proto::milvus::_PersistentSegmentInfoRequest_default_instance_._instance.get_mutable()->base_ = const_cast< ::milvus::proto::common::MsgBase*>( + ::milvus::proto::common::MsgBase::internal_default_instance()); +} +class PersistentSegmentInfoRequest::_Internal { + public: + static const ::milvus::proto::common::MsgBase& base(const PersistentSegmentInfoRequest* msg); +}; + +const ::milvus::proto::common::MsgBase& +PersistentSegmentInfoRequest::_Internal::base(const PersistentSegmentInfoRequest* msg) { + return *msg->base_; +} +void PersistentSegmentInfoRequest::clear_base() { + if (GetArenaNoVirtual() == nullptr && base_ != nullptr) { + delete base_; + } + base_ = nullptr; +} +PersistentSegmentInfoRequest::PersistentSegmentInfoRequest() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.PersistentSegmentInfoRequest) +} +PersistentSegmentInfoRequest::PersistentSegmentInfoRequest(const PersistentSegmentInfoRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + dbname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.dbname().empty()) { + dbname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dbname_); + } + collectionname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collectionname().empty()) { + collectionname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collectionname_); + } + if (from.has_base()) { + base_ = new ::milvus::proto::common::MsgBase(*from.base_); + } else { + base_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.PersistentSegmentInfoRequest) +} + +void PersistentSegmentInfoRequest::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PersistentSegmentInfoRequest_milvus_2eproto.base); + dbname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collectionname_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + base_ = nullptr; +} + +PersistentSegmentInfoRequest::~PersistentSegmentInfoRequest() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.PersistentSegmentInfoRequest) + SharedDtor(); +} + +void PersistentSegmentInfoRequest::SharedDtor() { + dbname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collectionname_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete base_; +} + +void PersistentSegmentInfoRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PersistentSegmentInfoRequest& PersistentSegmentInfoRequest::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PersistentSegmentInfoRequest_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void PersistentSegmentInfoRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dbname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collectionname_.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* PersistentSegmentInfoRequest::_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 dbName = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_dbname(), ptr, ctx, "milvus.proto.milvus.PersistentSegmentInfoRequest.dbName"); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string collectionName = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collectionname(), ptr, ctx, "milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName"); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag & 7) == 4 || tag == 0) { + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} +#else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +bool PersistentSegmentInfoRequest::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.PersistentSegmentInfoRequest) + 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 dbName = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_dbname())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dbname().data(), static_cast(this->dbname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.dbName")); + } else { + goto handle_unusual; + } + break; + } + + // string collectionName = 3; + case 3: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( + input, this->mutable_collectionname())); + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collectionname().data(), static_cast(this->collectionname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName")); + } 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.PersistentSegmentInfoRequest) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.PersistentSegmentInfoRequest) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PersistentSegmentInfoRequest::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + ::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 dbName = 2; + if (this->dbname().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dbname().data(), static_cast(this->dbname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.dbName"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->dbname(), output); + } + + // string collectionName = 3; + if (this->collectionname().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collectionname().data(), static_cast(this->collectionname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName"); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->collectionname(), 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.PersistentSegmentInfoRequest) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PersistentSegmentInfoRequest::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + ::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 dbName = 2; + if (this->dbname().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->dbname().data(), static_cast(this->dbname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.dbName"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 2, this->dbname(), target); + } + + // string collectionName = 3; + if (this->collectionname().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->collectionname().data(), static_cast(this->collectionname().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName"); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( + 3, this->collectionname(), 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.PersistentSegmentInfoRequest) + return target; +} + +size_t PersistentSegmentInfoRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string dbName = 2; + if (this->dbname().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->dbname()); + } + + // string collectionName = 3; + if (this->collectionname().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->collectionname()); + } + + // .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 PersistentSegmentInfoRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + GOOGLE_DCHECK_NE(&from, this); + const PersistentSegmentInfoRequest* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.PersistentSegmentInfoRequest) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.PersistentSegmentInfoRequest) + MergeFrom(*source); + } +} + +void PersistentSegmentInfoRequest::MergeFrom(const PersistentSegmentInfoRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.dbname().size() > 0) { + + dbname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dbname_); + } + if (from.collectionname().size() > 0) { + + collectionname_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collectionname_); + } + if (from.has_base()) { + mutable_base()->::milvus::proto::common::MsgBase::MergeFrom(from.base()); + } +} + +void PersistentSegmentInfoRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PersistentSegmentInfoRequest::CopyFrom(const PersistentSegmentInfoRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.PersistentSegmentInfoRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PersistentSegmentInfoRequest::IsInitialized() const { + return true; +} + +void PersistentSegmentInfoRequest::InternalSwap(PersistentSegmentInfoRequest* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + dbname_.Swap(&other->dbname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + collectionname_.Swap(&other->collectionname_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + GetArenaNoVirtual()); + swap(base_, other->base_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PersistentSegmentInfoRequest::GetMetadata() const { + return GetMetadataStatic(); +} + + +// =================================================================== + +void PersistentSegmentInfoResponse::InitAsDefaultInstance() { + ::milvus::proto::milvus::_PersistentSegmentInfoResponse_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::proto::common::Status*>( + ::milvus::proto::common::Status::internal_default_instance()); +} +class PersistentSegmentInfoResponse::_Internal { + public: + static const ::milvus::proto::common::Status& status(const PersistentSegmentInfoResponse* msg); +}; + +const ::milvus::proto::common::Status& +PersistentSegmentInfoResponse::_Internal::status(const PersistentSegmentInfoResponse* msg) { + return *msg->status_; +} +void PersistentSegmentInfoResponse::clear_status() { + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; +} +PersistentSegmentInfoResponse::PersistentSegmentInfoResponse() + : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { + SharedCtor(); + // @@protoc_insertion_point(constructor:milvus.proto.milvus.PersistentSegmentInfoResponse) +} +PersistentSegmentInfoResponse::PersistentSegmentInfoResponse(const PersistentSegmentInfoResponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + _internal_metadata_(nullptr), + infos_(from.infos_) { + _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.PersistentSegmentInfoResponse) +} + +void PersistentSegmentInfoResponse::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PersistentSegmentInfoResponse_milvus_2eproto.base); + status_ = nullptr; +} + +PersistentSegmentInfoResponse::~PersistentSegmentInfoResponse() { + // @@protoc_insertion_point(destructor:milvus.proto.milvus.PersistentSegmentInfoResponse) + SharedDtor(); +} + +void PersistentSegmentInfoResponse::SharedDtor() { + if (this != internal_default_instance()) delete status_; +} + +void PersistentSegmentInfoResponse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} +const PersistentSegmentInfoResponse& PersistentSegmentInfoResponse::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PersistentSegmentInfoResponse_milvus_2eproto.base); + return *internal_default_instance(); +} + + +void PersistentSegmentInfoResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + infos_.Clear(); + if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { + delete status_; + } + status_ = nullptr; + _internal_metadata_.Clear(); +} + +#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER +const char* PersistentSegmentInfoResponse::_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.milvus.PersistentSegmentInfo infos = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(add_infos(), 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 PersistentSegmentInfoResponse::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.PersistentSegmentInfoResponse) + 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.milvus.PersistentSegmentInfo infos = 2; + case 2: { + if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { + DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage( + input, add_infos())); + } 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.PersistentSegmentInfoResponse) + return true; +failure: + // @@protoc_insertion_point(parse_failure:milvus.proto.milvus.PersistentSegmentInfoResponse) + return false; +#undef DO_ +} +#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER + +void PersistentSegmentInfoResponse::SerializeWithCachedSizes( + ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + ::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.milvus.PersistentSegmentInfo infos = 2; + for (unsigned int i = 0, + n = static_cast(this->infos_size()); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, + this->infos(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.PersistentSegmentInfoResponse) +} + +::PROTOBUF_NAMESPACE_ID::uint8* PersistentSegmentInfoResponse::InternalSerializeWithCachedSizesToArray( + ::PROTOBUF_NAMESPACE_ID::uint8* target) const { + // @@protoc_insertion_point(serialize_to_array_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + ::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.milvus.PersistentSegmentInfo infos = 2; + for (unsigned int i = 0, + n = static_cast(this->infos_size()); i < n; i++) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, this->infos(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.PersistentSegmentInfoResponse) + return target; +} + +size_t PersistentSegmentInfoResponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + 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.milvus.PersistentSegmentInfo infos = 2; + { + unsigned int count = static_cast(this->infos_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + this->infos(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 PersistentSegmentInfoResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + GOOGLE_DCHECK_NE(&from, this); + const PersistentSegmentInfoResponse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.proto.milvus.PersistentSegmentInfoResponse) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.proto.milvus.PersistentSegmentInfoResponse) + MergeFrom(*source); + } +} + +void PersistentSegmentInfoResponse::MergeFrom(const PersistentSegmentInfoResponse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + infos_.MergeFrom(from.infos_); + if (from.has_status()) { + mutable_status()->::milvus::proto::common::Status::MergeFrom(from.status()); + } +} + +void PersistentSegmentInfoResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PersistentSegmentInfoResponse::CopyFrom(const PersistentSegmentInfoResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.proto.milvus.PersistentSegmentInfoResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PersistentSegmentInfoResponse::IsInitialized() const { + return true; +} + +void PersistentSegmentInfoResponse::InternalSwap(PersistentSegmentInfoResponse* other) { + using std::swap; + _internal_metadata_.Swap(&other->_internal_metadata_); + CastToBase(&infos_)->InternalSwap(CastToBase(&other->infos_)); + swap(status_, other->status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PersistentSegmentInfoResponse::GetMetadata() const { + return GetMetadataStatic(); +} + + // =================================================================== void RegisterLinkResponse::InitAsDefaultInstance() { @@ -17984,6 +19407,15 @@ 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::PersistentSegmentInfo* Arena::CreateMaybeMessage< ::milvus::proto::milvus::PersistentSegmentInfo >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::PersistentSegmentInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::PersistentSegmentInfoRequest* Arena::CreateMaybeMessage< ::milvus::proto::milvus::PersistentSegmentInfoRequest >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::PersistentSegmentInfoRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::PersistentSegmentInfoResponse* Arena::CreateMaybeMessage< ::milvus::proto::milvus::PersistentSegmentInfoResponse >(Arena* arena) { + return Arena::CreateInternal< ::milvus::proto::milvus::PersistentSegmentInfoResponse >(arena); +} template<> PROTOBUF_NOINLINE ::milvus::proto::milvus::RegisterLinkResponse* Arena::CreateMaybeMessage< ::milvus::proto::milvus::RegisterLinkResponse >(Arena* arena) { return Arena::CreateInternal< ::milvus::proto::milvus::RegisterLinkResponse >(arena); } diff --git a/internal/core/src/pb/milvus.pb.h b/internal/core/src/pb/milvus.pb.h index 9cc8cc3ee4..6c38da3dab 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[41] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[44] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -141,6 +141,15 @@ extern PartitionStatsRequestDefaultTypeInternal _PartitionStatsRequest_default_i class PartitionStatsResponse; class PartitionStatsResponseDefaultTypeInternal; extern PartitionStatsResponseDefaultTypeInternal _PartitionStatsResponse_default_instance_; +class PersistentSegmentInfo; +class PersistentSegmentInfoDefaultTypeInternal; +extern PersistentSegmentInfoDefaultTypeInternal _PersistentSegmentInfo_default_instance_; +class PersistentSegmentInfoRequest; +class PersistentSegmentInfoRequestDefaultTypeInternal; +extern PersistentSegmentInfoRequestDefaultTypeInternal _PersistentSegmentInfoRequest_default_instance_; +class PersistentSegmentInfoResponse; +class PersistentSegmentInfoResponseDefaultTypeInternal; +extern PersistentSegmentInfoResponseDefaultTypeInternal _PersistentSegmentInfoResponse_default_instance_; class PlaceholderGroup; class PlaceholderGroupDefaultTypeInternal; extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_; @@ -214,6 +223,9 @@ template<> ::milvus::proto::milvus::LoadCollectionRequest* Arena::CreateMaybeMes template<> ::milvus::proto::milvus::LoadPartitonRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::LoadPartitonRequest>(Arena*); template<> ::milvus::proto::milvus::PartitionStatsRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::PartitionStatsRequest>(Arena*); template<> ::milvus::proto::milvus::PartitionStatsResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::PartitionStatsResponse>(Arena*); +template<> ::milvus::proto::milvus::PersistentSegmentInfo* Arena::CreateMaybeMessage<::milvus::proto::milvus::PersistentSegmentInfo>(Arena*); +template<> ::milvus::proto::milvus::PersistentSegmentInfoRequest* Arena::CreateMaybeMessage<::milvus::proto::milvus::PersistentSegmentInfoRequest>(Arena*); +template<> ::milvus::proto::milvus::PersistentSegmentInfoResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::PersistentSegmentInfoResponse>(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::RegisterLinkResponse* Arena::CreateMaybeMessage<::milvus::proto::milvus::RegisterLinkResponse>(Arena*); @@ -6742,6 +6754,500 @@ class FlushRequest : }; // ------------------------------------------------------------------- +class PersistentSegmentInfo : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.PersistentSegmentInfo) */ { + public: + PersistentSegmentInfo(); + virtual ~PersistentSegmentInfo(); + + PersistentSegmentInfo(const PersistentSegmentInfo& from); + PersistentSegmentInfo(PersistentSegmentInfo&& from) noexcept + : PersistentSegmentInfo() { + *this = ::std::move(from); + } + + inline PersistentSegmentInfo& operator=(const PersistentSegmentInfo& from) { + CopyFrom(from); + return *this; + } + inline PersistentSegmentInfo& operator=(PersistentSegmentInfo&& 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 PersistentSegmentInfo& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PersistentSegmentInfo* internal_default_instance() { + return reinterpret_cast( + &_PersistentSegmentInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(PersistentSegmentInfo& a, PersistentSegmentInfo& b) { + a.Swap(&b); + } + inline void Swap(PersistentSegmentInfo* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PersistentSegmentInfo* New() const final { + return CreateMaybeMessage(nullptr); + } + + PersistentSegmentInfo* 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 PersistentSegmentInfo& from); + void MergeFrom(const PersistentSegmentInfo& 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(PersistentSegmentInfo* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.PersistentSegmentInfo"; + } + 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 { + kSegmentIDFieldNumber = 1, + kCollectionIDFieldNumber = 2, + kPartitionIDFieldNumber = 3, + kOpenTimeFieldNumber = 4, + kSealedTimeFieldNumber = 5, + kFlushedTimeFieldNumber = 6, + kNumRowsFieldNumber = 7, + kMemSizeFieldNumber = 8, + kStateFieldNumber = 9, + }; + // int64 segmentID = 1; + void clear_segmentid(); + ::PROTOBUF_NAMESPACE_ID::int64 segmentid() const; + void set_segmentid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 collectionID = 2; + void clear_collectionid(); + ::PROTOBUF_NAMESPACE_ID::int64 collectionid() const; + void set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 partitionID = 3; + void clear_partitionid(); + ::PROTOBUF_NAMESPACE_ID::int64 partitionid() const; + void set_partitionid(::PROTOBUF_NAMESPACE_ID::int64 value); + + // uint64 open_time = 4; + void clear_open_time(); + ::PROTOBUF_NAMESPACE_ID::uint64 open_time() const; + void set_open_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 sealed_time = 5; + void clear_sealed_time(); + ::PROTOBUF_NAMESPACE_ID::uint64 sealed_time() const; + void set_sealed_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // uint64 flushed_time = 6; + void clear_flushed_time(); + ::PROTOBUF_NAMESPACE_ID::uint64 flushed_time() const; + void set_flushed_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + + // int64 num_rows = 7; + void clear_num_rows(); + ::PROTOBUF_NAMESPACE_ID::int64 num_rows() const; + void set_num_rows(::PROTOBUF_NAMESPACE_ID::int64 value); + + // int64 mem_size = 8; + void clear_mem_size(); + ::PROTOBUF_NAMESPACE_ID::int64 mem_size() const; + void set_mem_size(::PROTOBUF_NAMESPACE_ID::int64 value); + + // .milvus.proto.common.SegmentState state = 9; + void clear_state(); + ::milvus::proto::common::SegmentState state() const; + void set_state(::milvus::proto::common::SegmentState value); + + // @@protoc_insertion_point(class_scope:milvus.proto.milvus.PersistentSegmentInfo) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::int64 segmentid_; + ::PROTOBUF_NAMESPACE_ID::int64 collectionid_; + ::PROTOBUF_NAMESPACE_ID::int64 partitionid_; + ::PROTOBUF_NAMESPACE_ID::uint64 open_time_; + ::PROTOBUF_NAMESPACE_ID::uint64 sealed_time_; + ::PROTOBUF_NAMESPACE_ID::uint64 flushed_time_; + ::PROTOBUF_NAMESPACE_ID::int64 num_rows_; + ::PROTOBUF_NAMESPACE_ID::int64 mem_size_; + int state_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class PersistentSegmentInfoRequest : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.PersistentSegmentInfoRequest) */ { + public: + PersistentSegmentInfoRequest(); + virtual ~PersistentSegmentInfoRequest(); + + PersistentSegmentInfoRequest(const PersistentSegmentInfoRequest& from); + PersistentSegmentInfoRequest(PersistentSegmentInfoRequest&& from) noexcept + : PersistentSegmentInfoRequest() { + *this = ::std::move(from); + } + + inline PersistentSegmentInfoRequest& operator=(const PersistentSegmentInfoRequest& from) { + CopyFrom(from); + return *this; + } + inline PersistentSegmentInfoRequest& operator=(PersistentSegmentInfoRequest&& 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 PersistentSegmentInfoRequest& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PersistentSegmentInfoRequest* internal_default_instance() { + return reinterpret_cast( + &_PersistentSegmentInfoRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(PersistentSegmentInfoRequest& a, PersistentSegmentInfoRequest& b) { + a.Swap(&b); + } + inline void Swap(PersistentSegmentInfoRequest* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PersistentSegmentInfoRequest* New() const final { + return CreateMaybeMessage(nullptr); + } + + PersistentSegmentInfoRequest* 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 PersistentSegmentInfoRequest& from); + void MergeFrom(const PersistentSegmentInfoRequest& 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(PersistentSegmentInfoRequest* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.PersistentSegmentInfoRequest"; + } + 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 { + kDbNameFieldNumber = 2, + kCollectionNameFieldNumber = 3, + kBaseFieldNumber = 1, + }; + // string dbName = 2; + void clear_dbname(); + const std::string& dbname() const; + void set_dbname(const std::string& value); + void set_dbname(std::string&& value); + void set_dbname(const char* value); + void set_dbname(const char* value, size_t size); + std::string* mutable_dbname(); + std::string* release_dbname(); + void set_allocated_dbname(std::string* dbname); + + // string collectionName = 3; + void clear_collectionname(); + const std::string& collectionname() const; + void set_collectionname(const std::string& value); + void set_collectionname(std::string&& value); + void set_collectionname(const char* value); + void set_collectionname(const char* value, size_t size); + std::string* mutable_collectionname(); + std::string* release_collectionname(); + void set_allocated_collectionname(std::string* collectionname); + + // .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.PersistentSegmentInfoRequest) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dbname_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collectionname_; + ::milvus::proto::common::MsgBase* base_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + +class PersistentSegmentInfoResponse : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.PersistentSegmentInfoResponse) */ { + public: + PersistentSegmentInfoResponse(); + virtual ~PersistentSegmentInfoResponse(); + + PersistentSegmentInfoResponse(const PersistentSegmentInfoResponse& from); + PersistentSegmentInfoResponse(PersistentSegmentInfoResponse&& from) noexcept + : PersistentSegmentInfoResponse() { + *this = ::std::move(from); + } + + inline PersistentSegmentInfoResponse& operator=(const PersistentSegmentInfoResponse& from) { + CopyFrom(from); + return *this; + } + inline PersistentSegmentInfoResponse& operator=(PersistentSegmentInfoResponse&& 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 PersistentSegmentInfoResponse& default_instance(); + + static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY + static inline const PersistentSegmentInfoResponse* internal_default_instance() { + return reinterpret_cast( + &_PersistentSegmentInfoResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(PersistentSegmentInfoResponse& a, PersistentSegmentInfoResponse& b) { + a.Swap(&b); + } + inline void Swap(PersistentSegmentInfoResponse* other) { + if (other == this) return; + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PersistentSegmentInfoResponse* New() const final { + return CreateMaybeMessage(nullptr); + } + + PersistentSegmentInfoResponse* 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 PersistentSegmentInfoResponse& from); + void MergeFrom(const PersistentSegmentInfoResponse& 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(PersistentSegmentInfoResponse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "milvus.proto.milvus.PersistentSegmentInfoResponse"; + } + 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 { + kInfosFieldNumber = 2, + kStatusFieldNumber = 1, + }; + // repeated .milvus.proto.milvus.PersistentSegmentInfo infos = 2; + int infos_size() const; + void clear_infos(); + ::milvus::proto::milvus::PersistentSegmentInfo* mutable_infos(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::PersistentSegmentInfo >* + mutable_infos(); + const ::milvus::proto::milvus::PersistentSegmentInfo& infos(int index) const; + ::milvus::proto::milvus::PersistentSegmentInfo* add_infos(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::PersistentSegmentInfo >& + infos() 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.PersistentSegmentInfoResponse) + private: + class _Internal; + + ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::PersistentSegmentInfo > infos_; + ::milvus::proto::common::Status* status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_milvus_2eproto; +}; +// ------------------------------------------------------------------- + class RegisterLinkResponse : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.milvus.RegisterLinkResponse) */ { public: @@ -6784,7 +7290,7 @@ class RegisterLinkResponse : &_RegisterLinkResponse_default_instance_); } static constexpr int kIndexInFileMessages = - 40; + 43; friend void swap(RegisterLinkResponse& a, RegisterLinkResponse& b) { a.Swap(&b); @@ -12686,6 +13192,366 @@ FlushRequest::mutable_collection_names() { // ------------------------------------------------------------------- +// PersistentSegmentInfo + +// int64 segmentID = 1; +inline void PersistentSegmentInfo::clear_segmentid() { + segmentid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PersistentSegmentInfo::segmentid() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.segmentID) + return segmentid_; +} +inline void PersistentSegmentInfo::set_segmentid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + segmentid_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.segmentID) +} + +// int64 collectionID = 2; +inline void PersistentSegmentInfo::clear_collectionid() { + collectionid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PersistentSegmentInfo::collectionid() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.collectionID) + return collectionid_; +} +inline void PersistentSegmentInfo::set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + collectionid_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.collectionID) +} + +// int64 partitionID = 3; +inline void PersistentSegmentInfo::clear_partitionid() { + partitionid_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PersistentSegmentInfo::partitionid() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.partitionID) + return partitionid_; +} +inline void PersistentSegmentInfo::set_partitionid(::PROTOBUF_NAMESPACE_ID::int64 value) { + + partitionid_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.partitionID) +} + +// uint64 open_time = 4; +inline void PersistentSegmentInfo::clear_open_time() { + open_time_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 PersistentSegmentInfo::open_time() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.open_time) + return open_time_; +} +inline void PersistentSegmentInfo::set_open_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + open_time_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.open_time) +} + +// uint64 sealed_time = 5; +inline void PersistentSegmentInfo::clear_sealed_time() { + sealed_time_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 PersistentSegmentInfo::sealed_time() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.sealed_time) + return sealed_time_; +} +inline void PersistentSegmentInfo::set_sealed_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + sealed_time_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.sealed_time) +} + +// uint64 flushed_time = 6; +inline void PersistentSegmentInfo::clear_flushed_time() { + flushed_time_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 PersistentSegmentInfo::flushed_time() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.flushed_time) + return flushed_time_; +} +inline void PersistentSegmentInfo::set_flushed_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + flushed_time_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.flushed_time) +} + +// int64 num_rows = 7; +inline void PersistentSegmentInfo::clear_num_rows() { + num_rows_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PersistentSegmentInfo::num_rows() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.num_rows) + return num_rows_; +} +inline void PersistentSegmentInfo::set_num_rows(::PROTOBUF_NAMESPACE_ID::int64 value) { + + num_rows_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.num_rows) +} + +// int64 mem_size = 8; +inline void PersistentSegmentInfo::clear_mem_size() { + mem_size_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 PersistentSegmentInfo::mem_size() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.mem_size) + return mem_size_; +} +inline void PersistentSegmentInfo::set_mem_size(::PROTOBUF_NAMESPACE_ID::int64 value) { + + mem_size_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.mem_size) +} + +// .milvus.proto.common.SegmentState state = 9; +inline void PersistentSegmentInfo::clear_state() { + state_ = 0; +} +inline ::milvus::proto::common::SegmentState PersistentSegmentInfo::state() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfo.state) + return static_cast< ::milvus::proto::common::SegmentState >(state_); +} +inline void PersistentSegmentInfo::set_state(::milvus::proto::common::SegmentState value) { + + state_ = value; + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfo.state) +} + +// ------------------------------------------------------------------- + +// PersistentSegmentInfoRequest + +// .milvus.proto.common.MsgBase base = 1; +inline bool PersistentSegmentInfoRequest::has_base() const { + return this != internal_default_instance() && base_ != nullptr; +} +inline const ::milvus::proto::common::MsgBase& PersistentSegmentInfoRequest::base() const { + const ::milvus::proto::common::MsgBase* p = base_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfoRequest.base) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_MsgBase_default_instance_); +} +inline ::milvus::proto::common::MsgBase* PersistentSegmentInfoRequest::release_base() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.PersistentSegmentInfoRequest.base) + + ::milvus::proto::common::MsgBase* temp = base_; + base_ = nullptr; + return temp; +} +inline ::milvus::proto::common::MsgBase* PersistentSegmentInfoRequest::mutable_base() { + + if (base_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::MsgBase>(GetArenaNoVirtual()); + base_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.PersistentSegmentInfoRequest.base) + return base_; +} +inline void PersistentSegmentInfoRequest::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.PersistentSegmentInfoRequest.base) +} + +// string dbName = 2; +inline void PersistentSegmentInfoRequest::clear_dbname() { + dbname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PersistentSegmentInfoRequest::dbname() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) + return dbname_.GetNoArena(); +} +inline void PersistentSegmentInfoRequest::set_dbname(const std::string& value) { + + dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) +} +inline void PersistentSegmentInfoRequest::set_dbname(std::string&& value) { + + dbname_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) +} +inline void PersistentSegmentInfoRequest::set_dbname(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) +} +inline void PersistentSegmentInfoRequest::set_dbname(const char* value, size_t size) { + + dbname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) +} +inline std::string* PersistentSegmentInfoRequest::mutable_dbname() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) + return dbname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PersistentSegmentInfoRequest::release_dbname() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) + + return dbname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PersistentSegmentInfoRequest::set_allocated_dbname(std::string* dbname) { + if (dbname != nullptr) { + + } else { + + } + dbname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dbname); + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.PersistentSegmentInfoRequest.dbName) +} + +// string collectionName = 3; +inline void PersistentSegmentInfoRequest::clear_collectionname() { + collectionname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline const std::string& PersistentSegmentInfoRequest::collectionname() const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) + return collectionname_.GetNoArena(); +} +inline void PersistentSegmentInfoRequest::set_collectionname(const std::string& value) { + + collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) +} +inline void PersistentSegmentInfoRequest::set_collectionname(std::string&& value) { + + collectionname_.SetNoArena( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); + // @@protoc_insertion_point(field_set_rvalue:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) +} +inline void PersistentSegmentInfoRequest::set_collectionname(const char* value) { + GOOGLE_DCHECK(value != nullptr); + + collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) +} +inline void PersistentSegmentInfoRequest::set_collectionname(const char* value, size_t size) { + + collectionname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + ::std::string(reinterpret_cast(value), size)); + // @@protoc_insertion_point(field_set_pointer:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) +} +inline std::string* PersistentSegmentInfoRequest::mutable_collectionname() { + + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) + return collectionname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline std::string* PersistentSegmentInfoRequest::release_collectionname() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) + + return collectionname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} +inline void PersistentSegmentInfoRequest::set_allocated_collectionname(std::string* collectionname) { + if (collectionname != nullptr) { + + } else { + + } + collectionname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collectionname); + // @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.PersistentSegmentInfoRequest.collectionName) +} + +// ------------------------------------------------------------------- + +// PersistentSegmentInfoResponse + +// .milvus.proto.common.Status status = 1; +inline bool PersistentSegmentInfoResponse::has_status() const { + return this != internal_default_instance() && status_ != nullptr; +} +inline const ::milvus::proto::common::Status& PersistentSegmentInfoResponse::status() const { + const ::milvus::proto::common::Status* p = status_; + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfoResponse.status) + return p != nullptr ? *p : *reinterpret_cast( + &::milvus::proto::common::_Status_default_instance_); +} +inline ::milvus::proto::common::Status* PersistentSegmentInfoResponse::release_status() { + // @@protoc_insertion_point(field_release:milvus.proto.milvus.PersistentSegmentInfoResponse.status) + + ::milvus::proto::common::Status* temp = status_; + status_ = nullptr; + return temp; +} +inline ::milvus::proto::common::Status* PersistentSegmentInfoResponse::mutable_status() { + + if (status_ == nullptr) { + auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual()); + status_ = p; + } + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.PersistentSegmentInfoResponse.status) + return status_; +} +inline void PersistentSegmentInfoResponse::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.PersistentSegmentInfoResponse.status) +} + +// repeated .milvus.proto.milvus.PersistentSegmentInfo infos = 2; +inline int PersistentSegmentInfoResponse::infos_size() const { + return infos_.size(); +} +inline void PersistentSegmentInfoResponse::clear_infos() { + infos_.Clear(); +} +inline ::milvus::proto::milvus::PersistentSegmentInfo* PersistentSegmentInfoResponse::mutable_infos(int index) { + // @@protoc_insertion_point(field_mutable:milvus.proto.milvus.PersistentSegmentInfoResponse.infos) + return infos_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::PersistentSegmentInfo >* +PersistentSegmentInfoResponse::mutable_infos() { + // @@protoc_insertion_point(field_mutable_list:milvus.proto.milvus.PersistentSegmentInfoResponse.infos) + return &infos_; +} +inline const ::milvus::proto::milvus::PersistentSegmentInfo& PersistentSegmentInfoResponse::infos(int index) const { + // @@protoc_insertion_point(field_get:milvus.proto.milvus.PersistentSegmentInfoResponse.infos) + return infos_.Get(index); +} +inline ::milvus::proto::milvus::PersistentSegmentInfo* PersistentSegmentInfoResponse::add_infos() { + // @@protoc_insertion_point(field_add:milvus.proto.milvus.PersistentSegmentInfoResponse.infos) + return infos_.Add(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::milvus::PersistentSegmentInfo >& +PersistentSegmentInfoResponse::infos() const { + // @@protoc_insertion_point(field_list:milvus.proto.milvus.PersistentSegmentInfoResponse.infos) + return infos_; +} + +// ------------------------------------------------------------------- + // RegisterLinkResponse // .milvus.proto.common.Address address = 1; @@ -12861,6 +13727,12 @@ inline void RegisterLinkResponse::set_allocated_status(::milvus::proto::common:: // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/internal/dataservice/meta.go b/internal/dataservice/meta.go index 6a2c5ca06c..b69cc746ef 100644 --- a/internal/dataservice/meta.go +++ b/internal/dataservice/meta.go @@ -5,6 +5,8 @@ import ( "strconv" "sync" + "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" + "github.com/zilliztech/milvus-distributed/internal/proto/datapb" "github.com/zilliztech/milvus-distributed/internal/proto/schemapb" @@ -262,7 +264,7 @@ func (meta *meta) FlushSegment(segID UniqueID, timetick Timestamp) error { return nil } -func (meta *meta) SetSegmentState(segmentID UniqueID, state datapb.SegmentState) error { +func (meta *meta) SetSegmentState(segmentID UniqueID, state commonpb.SegmentState) error { meta.ddLock.Lock() defer meta.ddLock.Unlock() @@ -396,6 +398,6 @@ func BuildSegment(collectionID UniqueID, partitionID UniqueID, segmentID UniqueI SealedTime: 0, NumRows: 0, MemSize: 0, - State: datapb.SegmentState_SegmentGrowing, + State: commonpb.SegmentState_SegmentGrowing, }, nil } diff --git a/internal/dataservice/watcher.go b/internal/dataservice/watcher.go index 490ae036ca..5c7bda36ba 100644 --- a/internal/dataservice/watcher.go +++ b/internal/dataservice/watcher.go @@ -94,7 +94,7 @@ func (watcher *dataNodeTimeTickWatcher) handleTimeTickMsg(msg *msgstream.TimeTic log.Println(err.Error()) continue } - if err = watcher.meta.SetSegmentState(id, datapb.SegmentState_SegmentSealed); err != nil { + if err = watcher.meta.SetSegmentState(id, commonpb.SegmentState_SegmentSealed); err != nil { log.Println(err.Error()) continue } diff --git a/internal/distributed/dataservice/grpc_service.go b/internal/distributed/dataservice/grpc_service.go index fbb334d967..413de1c21e 100644 --- a/internal/distributed/dataservice/grpc_service.go +++ b/internal/distributed/dataservice/grpc_service.go @@ -24,6 +24,10 @@ type Service struct { grpcServer *grpc.Server } +func (s *Service) GetSegmentInfo(ctx context.Context, request *datapb.SegmentInfoRequest) (*datapb.SegmentInfoResponse, error) { + panic("implement me") +} + func NewGrpcService(ctx context.Context) *Service { s := &Service{} var err error diff --git a/internal/distributed/proxynode/service.go b/internal/distributed/proxynode/service.go index ba2c64ed0c..b3c3611245 100644 --- a/internal/distributed/proxynode/service.go +++ b/internal/distributed/proxynode/service.go @@ -320,3 +320,7 @@ func (s *Server) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*co func (s *Server) GetDdChannel(ctx context.Context, request *commonpb.Empty) (*milvuspb.StringResponse, error) { return s.impl.GetDdChannel(request) } + +func (s *Server) GetPersistentSegmentInfo(ctx context.Context, request *milvuspb.PersistentSegmentInfoRequest) (*milvuspb.PersistentSegmentInfoResponse, error) { + panic("implement me") +} diff --git a/internal/proto/common.proto b/internal/proto/common.proto index cc75420897..42ac3c045c 100644 --- a/internal/proto/common.proto +++ b/internal/proto/common.proto @@ -41,6 +41,14 @@ enum IndexState { FAILED = 4; } +enum SegmentState { + SegmentNone = 0; + SegmentNotExist = 1; + SegmentGrowing = 2; + SegmentSealed = 3; + SegmentFlushed = 4; +} + message Empty{} diff --git a/internal/proto/commonpb/common.pb.go b/internal/proto/commonpb/common.pb.go index 426e9ee90a..257700596a 100644 --- a/internal/proto/commonpb/common.pb.go +++ b/internal/proto/commonpb/common.pb.go @@ -149,6 +149,40 @@ func (IndexState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_555bd8c177793206, []int{1} } +type SegmentState int32 + +const ( + SegmentState_SegmentNone SegmentState = 0 + SegmentState_SegmentNotExist SegmentState = 1 + SegmentState_SegmentGrowing SegmentState = 2 + SegmentState_SegmentSealed SegmentState = 3 + SegmentState_SegmentFlushed SegmentState = 4 +) + +var SegmentState_name = map[int32]string{ + 0: "SegmentNone", + 1: "SegmentNotExist", + 2: "SegmentGrowing", + 3: "SegmentSealed", + 4: "SegmentFlushed", +} + +var SegmentState_value = map[string]int32{ + "SegmentNone": 0, + "SegmentNotExist": 1, + "SegmentGrowing": 2, + "SegmentSealed": 3, + "SegmentFlushed": 4, +} + +func (x SegmentState) String() string { + return proto.EnumName(SegmentState_name, int32(x)) +} + +func (SegmentState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_555bd8c177793206, []int{2} +} + type MsgType int32 const ( @@ -272,7 +306,7 @@ func (x MsgType) String() string { } func (MsgType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_555bd8c177793206, []int{2} + return fileDescriptor_555bd8c177793206, []int{3} } type Empty struct { @@ -592,6 +626,7 @@ func (m *MsgHeader) GetBase() *MsgBase { func init() { proto.RegisterEnum("milvus.proto.common.ErrorCode", ErrorCode_name, ErrorCode_value) proto.RegisterEnum("milvus.proto.common.IndexState", IndexState_name, IndexState_value) + proto.RegisterEnum("milvus.proto.common.SegmentState", SegmentState_name, SegmentState_value) proto.RegisterEnum("milvus.proto.common.MsgType", MsgType_name, MsgType_value) proto.RegisterType((*Empty)(nil), "milvus.proto.common.Empty") proto.RegisterType((*Status)(nil), "milvus.proto.common.Status") @@ -605,76 +640,79 @@ func init() { func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) } var fileDescriptor_555bd8c177793206 = []byte{ - // 1124 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0x5b, 0x6e, 0xdb, 0x46, - 0x1b, 0x8d, 0x2c, 0xd9, 0x32, 0x3f, 0x2b, 0xf2, 0x78, 0x7c, 0xd3, 0xff, 0xd7, 0x2d, 0x02, 0x3f, - 0x05, 0x01, 0x62, 0x17, 0x2d, 0xd0, 0x3e, 0x05, 0x28, 0x4d, 0x8e, 0xec, 0x41, 0x28, 0x52, 0x19, - 0x52, 0x69, 0xd2, 0x17, 0x82, 0x92, 0x26, 0x32, 0x41, 0x4a, 0x54, 0x39, 0xa3, 0xb4, 0xca, 0x2a, - 0xda, 0x2c, 0xa3, 0x68, 0x81, 0xde, 0xdb, 0x25, 0xf4, 0xb6, 0x80, 0x2e, 0xa1, 0x0b, 0xe8, 0x0d, - 0xed, 0x4b, 0x31, 0x43, 0x51, 0x12, 0x8a, 0xf4, 0x8d, 0xdf, 0x39, 0xf3, 0x7d, 0x3c, 0xe7, 0xcc, - 0x05, 0x1a, 0x83, 0x6c, 0x3c, 0xce, 0x26, 0x67, 0xd3, 0x3c, 0x93, 0x19, 0xde, 0x1f, 0xc7, 0xe9, - 0xd3, 0x99, 0x28, 0xaa, 0xb3, 0x82, 0x3a, 0xad, 0xc3, 0x26, 0x19, 0x4f, 0xe5, 0xfc, 0x34, 0x84, - 0x2d, 0x5f, 0x46, 0x72, 0x26, 0xf0, 0x3d, 0x00, 0x9e, 0xe7, 0x59, 0x1e, 0x0e, 0xb2, 0x21, 0x6f, - 0x55, 0x6e, 0x55, 0x6e, 0x37, 0x5f, 0x7b, 0xe5, 0xec, 0x05, 0xcd, 0x67, 0x44, 0x2d, 0xb3, 0xb2, - 0x21, 0x67, 0x06, 0x2f, 0x3f, 0xf1, 0x11, 0x6c, 0xe5, 0x3c, 0x12, 0xd9, 0xa4, 0xb5, 0x71, 0xab, - 0x72, 0xdb, 0x60, 0x8b, 0xea, 0xf4, 0x0d, 0x68, 0xdc, 0xe7, 0xf3, 0x87, 0x51, 0x3a, 0xe3, 0xdd, - 0x28, 0xce, 0x31, 0x82, 0x6a, 0xc2, 0xe7, 0x7a, 0xbe, 0xc1, 0xd4, 0x27, 0x3e, 0x80, 0xcd, 0xa7, - 0x8a, 0x5e, 0x34, 0x16, 0xc5, 0xe9, 0x09, 0xd4, 0x2e, 0xd2, 0xac, 0xbf, 0x62, 0x55, 0x47, 0xa3, - 0x64, 0xef, 0x42, 0xdd, 0x1c, 0x0e, 0x73, 0x2e, 0x04, 0x6e, 0xc2, 0x46, 0x3c, 0x5d, 0xcc, 0xdb, - 0x88, 0xa7, 0x18, 0x43, 0x6d, 0x9a, 0xe5, 0x52, 0x4f, 0xab, 0x32, 0xfd, 0x7d, 0xfa, 0xbc, 0x02, - 0xf5, 0x8e, 0x18, 0x5d, 0x44, 0x82, 0xe3, 0x37, 0x61, 0x7b, 0x2c, 0x46, 0xa1, 0x9c, 0x4f, 0x4b, - 0x97, 0x27, 0x2f, 0x74, 0xd9, 0x11, 0xa3, 0x60, 0x3e, 0xe5, 0xac, 0x3e, 0x2e, 0x3e, 0x94, 0x92, - 0xb1, 0x18, 0x51, 0x7b, 0x31, 0xb9, 0x28, 0xf0, 0x09, 0x18, 0x32, 0x1e, 0x73, 0x21, 0xa3, 0xf1, - 0xb4, 0x55, 0xbd, 0x55, 0xb9, 0x5d, 0x63, 0x2b, 0x00, 0xff, 0x1f, 0xb6, 0x45, 0x36, 0xcb, 0x07, - 0x9c, 0xda, 0xad, 0x9a, 0x6e, 0x5b, 0xd6, 0xa7, 0xf7, 0xc0, 0xe8, 0x88, 0xd1, 0x15, 0x8f, 0x86, - 0x3c, 0xc7, 0xaf, 0x42, 0xad, 0x1f, 0x89, 0x42, 0xd1, 0xce, 0x7f, 0x2b, 0x52, 0x0e, 0x98, 0x5e, - 0x79, 0xe7, 0xdb, 0x1a, 0x18, 0xcb, 0x9d, 0xc0, 0x3b, 0x50, 0xf7, 0x7b, 0x96, 0x45, 0x7c, 0x1f, - 0xdd, 0xc0, 0x07, 0x80, 0x7a, 0x2e, 0x79, 0xd4, 0x25, 0x56, 0x40, 0xec, 0x90, 0x30, 0xe6, 0x31, - 0x54, 0xc1, 0x18, 0x9a, 0x96, 0xe7, 0xba, 0xc4, 0x0a, 0xc2, 0xb6, 0x49, 0x1d, 0x62, 0xa3, 0x0d, - 0x7c, 0x08, 0x7b, 0x5d, 0xc2, 0x3a, 0xd4, 0xf7, 0xa9, 0xe7, 0x86, 0x36, 0x71, 0x29, 0xb1, 0x51, - 0x15, 0xff, 0x0f, 0x0e, 0x2d, 0xcf, 0x71, 0x88, 0x15, 0x28, 0xd8, 0xf5, 0x82, 0x90, 0x3c, 0xa2, - 0x7e, 0xe0, 0xa3, 0x9a, 0x9a, 0x4d, 0x1d, 0x87, 0x5c, 0x9a, 0x4e, 0x68, 0xb2, 0xcb, 0x5e, 0x87, - 0xb8, 0x01, 0xda, 0x54, 0x73, 0x4a, 0xd4, 0xa6, 0x1d, 0xe2, 0xaa, 0x71, 0xa8, 0x8e, 0x8f, 0x00, - 0x97, 0x30, 0x75, 0x6d, 0xf2, 0x28, 0x0c, 0x1e, 0x77, 0x09, 0xda, 0xc6, 0x2f, 0xc1, 0x71, 0x89, - 0xaf, 0xff, 0xc7, 0xec, 0x10, 0x64, 0x60, 0x04, 0x8d, 0x92, 0x0c, 0xbc, 0xee, 0x7d, 0x04, 0xeb, - 0xd3, 0x99, 0xf7, 0x36, 0x23, 0x96, 0xc7, 0x6c, 0xb4, 0xb3, 0x0e, 0x3f, 0x24, 0x56, 0xe0, 0xb1, - 0x90, 0xda, 0xa8, 0xa1, 0xc4, 0x97, 0xb0, 0x4f, 0x4c, 0x66, 0x5d, 0x85, 0x8c, 0xf8, 0x3d, 0x27, - 0x40, 0x37, 0x55, 0x04, 0x6d, 0xea, 0x10, 0xed, 0xa8, 0xed, 0xf5, 0x5c, 0x1b, 0x35, 0xf1, 0x2e, - 0xec, 0x74, 0x48, 0x60, 0x96, 0x99, 0xec, 0xaa, 0xff, 0x5b, 0xa6, 0x75, 0x45, 0x4a, 0x04, 0xe1, - 0x16, 0x1c, 0x58, 0xa6, 0xab, 0x9a, 0x2c, 0x46, 0xcc, 0x80, 0x84, 0x6d, 0xcf, 0xb1, 0x09, 0x43, - 0x7b, 0xca, 0xe0, 0xbf, 0x18, 0xea, 0x10, 0x84, 0xd7, 0x3a, 0x6c, 0xe2, 0x90, 0x55, 0xc7, 0xfe, - 0x5a, 0x47, 0xc9, 0xa8, 0x8e, 0x03, 0x65, 0xe6, 0xa2, 0x47, 0x1d, 0x7b, 0x11, 0x54, 0xb1, 0x69, - 0x87, 0x78, 0x0f, 0x6e, 0x96, 0x66, 0x5c, 0x87, 0xfa, 0x01, 0x3a, 0xc2, 0xc7, 0xb0, 0x5f, 0x42, - 0x1d, 0x12, 0x30, 0x6a, 0x15, 0xa9, 0x1e, 0xab, 0xb5, 0x5e, 0x2f, 0x08, 0xbd, 0x76, 0xd8, 0x21, - 0x1d, 0x8f, 0x3d, 0x46, 0x2d, 0x7c, 0x00, 0xbb, 0xb6, 0x1d, 0x32, 0xf2, 0xa0, 0x47, 0xfc, 0x20, - 0x64, 0xa6, 0x45, 0xd0, 0x2f, 0xf5, 0x3b, 0x2e, 0x00, 0x9d, 0x0c, 0xf9, 0xfb, 0xea, 0xe6, 0x73, - 0xbc, 0x0d, 0x35, 0xd7, 0x73, 0x09, 0xba, 0x81, 0x1b, 0xb0, 0xdd, 0x73, 0xa9, 0xef, 0xf7, 0x88, - 0x8d, 0x2a, 0xb8, 0x09, 0x40, 0xdd, 0x2e, 0xf3, 0x2e, 0x99, 0x3a, 0x55, 0x1b, 0x8a, 0x6d, 0x53, - 0x97, 0xfa, 0x57, 0xfa, 0x88, 0x00, 0x6c, 0x2d, 0xf2, 0xa9, 0xdd, 0xf9, 0x68, 0x53, 0x5f, 0x2f, - 0x7d, 0x4b, 0x0c, 0xd8, 0x4c, 0xdc, 0x6c, 0xc2, 0xd1, 0x0d, 0x65, 0x29, 0xb1, 0x72, 0x1e, 0x49, - 0x6e, 0x65, 0x69, 0xca, 0x07, 0x32, 0xce, 0x26, 0x68, 0x88, 0xf7, 0x61, 0x37, 0xb1, 0xf3, 0x6c, - 0xba, 0x06, 0x72, 0xb5, 0x33, 0xc9, 0x55, 0x24, 0xd6, 0xb0, 0x27, 0xca, 0x68, 0x62, 0x73, 0x31, - 0xc8, 0xe3, 0xfe, 0xfa, 0x84, 0x91, 0x3a, 0x83, 0x89, 0x7f, 0x9d, 0xbd, 0xb7, 0x02, 0x05, 0xba, - 0xd6, 0x23, 0x2e, 0xb9, 0xf4, 0xe7, 0xc2, 0xca, 0x26, 0x4f, 0xe2, 0x91, 0x40, 0x31, 0x3e, 0x04, - 0xb4, 0x90, 0xd0, 0x8d, 0x72, 0x19, 0xeb, 0xfe, 0xef, 0x2a, 0x78, 0x1f, 0x9a, 0x5a, 0xc2, 0x0a, - 0xfc, 0x5e, 0xdd, 0x8f, 0x9b, 0x4a, 0xc2, 0x0a, 0xfb, 0xa1, 0x82, 0x8f, 0x01, 0x2f, 0x25, 0xac, - 0x88, 0x1f, 0x2b, 0x2a, 0x58, 0x2d, 0x61, 0x09, 0x0a, 0xf4, 0x53, 0x05, 0xef, 0x41, 0x43, 0xa3, - 0x3e, 0x1f, 0x8d, 0xf9, 0x44, 0xa2, 0xbf, 0x2a, 0x5a, 0x41, 0x39, 0xa1, 0x84, 0xff, 0x2e, 0x56, - 0x16, 0xc2, 0xf4, 0x4e, 0xa0, 0x8f, 0x37, 0x0a, 0x51, 0x8b, 0x95, 0x05, 0xf8, 0x89, 0x0a, 0xbd, - 0x9e, 0xd0, 0x89, 0xe0, 0xb9, 0x44, 0x1f, 0x54, 0x75, 0x65, 0xf3, 0x94, 0x4b, 0x8e, 0x3e, 0xac, - 0xe2, 0x1d, 0xd8, 0x4a, 0xda, 0xe9, 0x4c, 0x5c, 0xa3, 0xe7, 0x05, 0xe5, 0xf3, 0x28, 0x1f, 0x5c, - 0xa3, 0x5f, 0xab, 0xda, 0x4b, 0x51, 0x31, 0x2e, 0x66, 0xa9, 0x44, 0xbf, 0x55, 0xf5, 0xfc, 0x4b, - 0x2e, 0x57, 0x3b, 0x8f, 0x7e, 0xaf, 0xe2, 0x97, 0xa1, 0xa5, 0xc0, 0x55, 0x92, 0x8a, 0x89, 0x85, - 0x8c, 0x07, 0x02, 0xfd, 0x51, 0xc5, 0x27, 0x70, 0xac, 0xe8, 0xa5, 0xcb, 0x35, 0xf6, 0xcf, 0x6a, - 0x61, 0xb7, 0xf0, 0x44, 0x27, 0x4f, 0x32, 0xf4, 0x73, 0x0d, 0x37, 0xc1, 0x48, 0x82, 0x78, 0xcc, - 0x83, 0x78, 0x90, 0xa0, 0x4f, 0x0d, 0x9d, 0xd3, 0x83, 0x19, 0xcf, 0xe7, 0x6e, 0x36, 0xe4, 0xaa, - 0x5b, 0xa0, 0xcf, 0x0c, 0xbc, 0x0b, 0x90, 0x38, 0x59, 0x34, 0x2c, 0x6c, 0x7e, 0x5e, 0x00, 0x8c, - 0xbf, 0x3b, 0xe3, 0x42, 0x52, 0x1b, 0x7d, 0xa1, 0x1e, 0x81, 0x9d, 0x12, 0x08, 0x7c, 0x0f, 0x7d, - 0x69, 0xe8, 0x20, 0xcd, 0x34, 0xcd, 0x06, 0x91, 0x5c, 0x06, 0xf9, 0x95, 0xa1, 0x77, 0x68, 0x51, - 0xae, 0x89, 0xfb, 0xda, 0xc0, 0x47, 0xb0, 0x57, 0x12, 0x3a, 0x24, 0x5b, 0x1d, 0xca, 0x6f, 0x8c, - 0x8b, 0x8b, 0x77, 0xde, 0x1a, 0xc5, 0xf2, 0x7a, 0xd6, 0x57, 0xcf, 0xea, 0xf9, 0xb3, 0x38, 0x4d, - 0xe3, 0x67, 0x92, 0x0f, 0xae, 0xcf, 0x8b, 0x27, 0xf7, 0xee, 0x30, 0x16, 0x32, 0x8f, 0xfb, 0x33, - 0xc9, 0x87, 0xe7, 0xf1, 0x44, 0xf2, 0x7c, 0x12, 0xa5, 0xe7, 0xfa, 0x1d, 0x3e, 0x2f, 0xde, 0xe1, - 0x69, 0xbf, 0xbf, 0xa5, 0xeb, 0xd7, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x71, 0x55, 0x6b, - 0x6a, 0x07, 0x00, 0x00, + // 1175 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0xdb, 0x6e, 0xdb, 0x46, + 0x13, 0x8e, 0x2c, 0xd9, 0x32, 0x47, 0x8a, 0xbc, 0x5e, 0x9f, 0xf4, 0xff, 0x75, 0x8b, 0xc0, 0x57, + 0x81, 0x81, 0xd8, 0x45, 0x0b, 0xb4, 0x57, 0x01, 0x2a, 0x93, 0x2b, 0x9b, 0x08, 0x45, 0x2a, 0x4b, + 0x2a, 0x4d, 0x7a, 0x43, 0x50, 0xe2, 0x46, 0x26, 0x48, 0x89, 0x2a, 0x77, 0x95, 0x44, 0x79, 0x8a, + 0x36, 0x8f, 0x51, 0xb4, 0x40, 0xcf, 0xed, 0x23, 0xf4, 0xf4, 0x00, 0x7d, 0x84, 0x3e, 0x40, 0x4f, + 0x68, 0x6f, 0x8a, 0x5d, 0x92, 0x92, 0x50, 0xa4, 0x77, 0x9c, 0x6f, 0x76, 0xbe, 0xfd, 0xbe, 0x99, + 0xe1, 0x42, 0x73, 0x94, 0x4e, 0x26, 0xe9, 0xf4, 0x6c, 0x96, 0xa5, 0x22, 0xc5, 0x7b, 0x93, 0x28, + 0x79, 0x32, 0xe7, 0x79, 0x74, 0x96, 0xa7, 0x4e, 0xea, 0xb0, 0x49, 0x26, 0x33, 0xb1, 0x38, 0xf1, + 0x61, 0xcb, 0x15, 0x81, 0x98, 0x73, 0x7c, 0x17, 0x80, 0x65, 0x59, 0x9a, 0xf9, 0xa3, 0x34, 0x64, + 0xed, 0xca, 0xad, 0xca, 0xed, 0xd6, 0x1b, 0xaf, 0x9d, 0xbd, 0xa4, 0xf8, 0x8c, 0xc8, 0x63, 0x7a, + 0x1a, 0x32, 0xaa, 0xb1, 0xf2, 0x13, 0x1f, 0xc2, 0x56, 0xc6, 0x02, 0x9e, 0x4e, 0xdb, 0x1b, 0xb7, + 0x2a, 0xb7, 0x35, 0x5a, 0x44, 0x27, 0x6f, 0x41, 0xf3, 0x1e, 0x5b, 0x3c, 0x08, 0x92, 0x39, 0xeb, + 0x07, 0x51, 0x86, 0x11, 0x54, 0x63, 0xb6, 0x50, 0xfc, 0x1a, 0x95, 0x9f, 0x78, 0x1f, 0x36, 0x9f, + 0xc8, 0x74, 0x51, 0x98, 0x07, 0x27, 0xc7, 0x50, 0xbb, 0x48, 0xd2, 0xe1, 0x2a, 0x2b, 0x2b, 0x9a, + 0x65, 0xf6, 0x0e, 0xd4, 0x3b, 0x61, 0x98, 0x31, 0xce, 0x71, 0x0b, 0x36, 0xa2, 0x59, 0xc1, 0xb7, + 0x11, 0xcd, 0x30, 0x86, 0xda, 0x2c, 0xcd, 0x84, 0x62, 0xab, 0x52, 0xf5, 0x7d, 0xf2, 0xa2, 0x02, + 0xf5, 0x1e, 0x1f, 0x5f, 0x04, 0x9c, 0xe1, 0xb7, 0x61, 0x7b, 0xc2, 0xc7, 0xbe, 0x58, 0xcc, 0x4a, + 0x97, 0xc7, 0x2f, 0x75, 0xd9, 0xe3, 0x63, 0x6f, 0x31, 0x63, 0xb4, 0x3e, 0xc9, 0x3f, 0xa4, 0x92, + 0x09, 0x1f, 0x9b, 0x46, 0xc1, 0x9c, 0x07, 0xf8, 0x18, 0x34, 0x11, 0x4d, 0x18, 0x17, 0xc1, 0x64, + 0xd6, 0xae, 0xde, 0xaa, 0xdc, 0xae, 0xd1, 0x15, 0x80, 0xff, 0x0f, 0xdb, 0x3c, 0x9d, 0x67, 0x23, + 0x66, 0x1a, 0xed, 0x9a, 0x2a, 0x5b, 0xc6, 0x27, 0x77, 0x41, 0xeb, 0xf1, 0xf1, 0x15, 0x0b, 0x42, + 0x96, 0xe1, 0xd7, 0xa1, 0x36, 0x0c, 0x78, 0xae, 0xa8, 0xf1, 0xdf, 0x8a, 0xa4, 0x03, 0xaa, 0x4e, + 0x9e, 0x7e, 0x5b, 0x03, 0x6d, 0x39, 0x09, 0xdc, 0x80, 0xba, 0x3b, 0xd0, 0x75, 0xe2, 0xba, 0xe8, + 0x06, 0xde, 0x07, 0x34, 0xb0, 0xc9, 0xc3, 0x3e, 0xd1, 0x3d, 0x62, 0xf8, 0x84, 0x52, 0x87, 0xa2, + 0x0a, 0xc6, 0xd0, 0xd2, 0x1d, 0xdb, 0x26, 0xba, 0xe7, 0x77, 0x3b, 0xa6, 0x45, 0x0c, 0xb4, 0x81, + 0x0f, 0x60, 0xb7, 0x4f, 0x68, 0xcf, 0x74, 0x5d, 0xd3, 0xb1, 0x7d, 0x83, 0xd8, 0x26, 0x31, 0x50, + 0x15, 0xff, 0x0f, 0x0e, 0x74, 0xc7, 0xb2, 0x88, 0xee, 0x49, 0xd8, 0x76, 0x3c, 0x9f, 0x3c, 0x34, + 0x5d, 0xcf, 0x45, 0x35, 0xc9, 0x6d, 0x5a, 0x16, 0xb9, 0xec, 0x58, 0x7e, 0x87, 0x5e, 0x0e, 0x7a, + 0xc4, 0xf6, 0xd0, 0xa6, 0xe4, 0x29, 0x51, 0xc3, 0xec, 0x11, 0x5b, 0xd2, 0xa1, 0x3a, 0x3e, 0x04, + 0x5c, 0xc2, 0xa6, 0x6d, 0x90, 0x87, 0xbe, 0xf7, 0xa8, 0x4f, 0xd0, 0x36, 0x7e, 0x05, 0x8e, 0x4a, + 0x7c, 0xfd, 0x9e, 0x4e, 0x8f, 0x20, 0x0d, 0x23, 0x68, 0x96, 0x49, 0xcf, 0xe9, 0xdf, 0x43, 0xb0, + 0xce, 0x4e, 0x9d, 0x77, 0x29, 0xd1, 0x1d, 0x6a, 0xa0, 0xc6, 0x3a, 0xfc, 0x80, 0xe8, 0x9e, 0x43, + 0x7d, 0xd3, 0x40, 0x4d, 0x29, 0xbe, 0x84, 0x5d, 0xd2, 0xa1, 0xfa, 0x95, 0x4f, 0x89, 0x3b, 0xb0, + 0x3c, 0x74, 0x53, 0xb6, 0xa0, 0x6b, 0x5a, 0x44, 0x39, 0xea, 0x3a, 0x03, 0xdb, 0x40, 0x2d, 0xbc, + 0x03, 0x8d, 0x1e, 0xf1, 0x3a, 0x65, 0x4f, 0x76, 0xe4, 0xfd, 0x7a, 0x47, 0xbf, 0x22, 0x25, 0x82, + 0x70, 0x1b, 0xf6, 0xf5, 0x8e, 0x2d, 0x8b, 0x74, 0x4a, 0x3a, 0x1e, 0xf1, 0xbb, 0x8e, 0x65, 0x10, + 0x8a, 0x76, 0xa5, 0xc1, 0x7f, 0x65, 0x4c, 0x8b, 0x20, 0xbc, 0x56, 0x61, 0x10, 0x8b, 0xac, 0x2a, + 0xf6, 0xd6, 0x2a, 0xca, 0x8c, 0xac, 0xd8, 0x97, 0x66, 0x2e, 0x06, 0xa6, 0x65, 0x14, 0x8d, 0xca, + 0x87, 0x76, 0x80, 0x77, 0xe1, 0x66, 0x69, 0xc6, 0xb6, 0x4c, 0xd7, 0x43, 0x87, 0xf8, 0x08, 0xf6, + 0x4a, 0xa8, 0x47, 0x3c, 0x6a, 0xea, 0x79, 0x57, 0x8f, 0xe4, 0x59, 0x67, 0xe0, 0xf9, 0x4e, 0xd7, + 0xef, 0x91, 0x9e, 0x43, 0x1f, 0xa1, 0x36, 0xde, 0x87, 0x1d, 0xc3, 0xf0, 0x29, 0xb9, 0x3f, 0x20, + 0xae, 0xe7, 0xd3, 0x8e, 0x4e, 0xd0, 0x2f, 0xf5, 0x53, 0x1b, 0xc0, 0x9c, 0x86, 0xec, 0x99, 0xfc, + 0xf3, 0x19, 0xde, 0x86, 0x9a, 0xed, 0xd8, 0x04, 0xdd, 0xc0, 0x4d, 0xd8, 0x1e, 0xd8, 0xa6, 0xeb, + 0x0e, 0x88, 0x81, 0x2a, 0xb8, 0x05, 0x60, 0xda, 0x7d, 0xea, 0x5c, 0x52, 0xb9, 0x55, 0x1b, 0x32, + 0xdb, 0x35, 0x6d, 0xd3, 0xbd, 0x52, 0x2b, 0x02, 0xb0, 0x55, 0xf4, 0xa7, 0x76, 0x9a, 0x42, 0xd3, + 0x65, 0xe3, 0x09, 0x9b, 0x8a, 0x9c, 0x71, 0x07, 0x1a, 0x45, 0x6c, 0xa7, 0x53, 0x86, 0x6e, 0xe0, + 0x3d, 0xd8, 0x59, 0x02, 0x82, 0x3c, 0x8b, 0xb8, 0xc8, 0xf7, 0xb1, 0x00, 0x2f, 0xb3, 0xf4, 0x69, + 0x34, 0x1d, 0xa3, 0x0d, 0x69, 0xa1, 0x64, 0x62, 0x41, 0xc2, 0x42, 0x54, 0x5d, 0x3b, 0xd6, 0x4d, + 0xe6, 0xfc, 0x9a, 0x85, 0xa8, 0x76, 0xfa, 0xd1, 0xa6, 0xfa, 0x9f, 0xd5, 0x6f, 0xa9, 0xc1, 0x66, + 0x5c, 0x5c, 0x73, 0x00, 0xbb, 0xb1, 0x9e, 0xb1, 0x40, 0x30, 0x3d, 0x4d, 0x12, 0x36, 0x12, 0x51, + 0x3a, 0x45, 0xa1, 0xbc, 0x3d, 0x36, 0xb2, 0x74, 0xb6, 0x06, 0x32, 0x49, 0x1b, 0x5f, 0x05, 0x7c, + 0x0d, 0x7b, 0x2c, 0x3b, 0x1b, 0x1b, 0x8c, 0x8f, 0xb2, 0x68, 0xb8, 0xce, 0x30, 0x96, 0x4b, 0x1f, + 0xbb, 0xd7, 0xe9, 0xd3, 0x15, 0xc8, 0xd1, 0xb5, 0xa2, 0xb8, 0x64, 0xc2, 0x5d, 0x70, 0x3d, 0x9d, + 0x3e, 0x8e, 0xc6, 0x1c, 0x45, 0xf8, 0x00, 0x50, 0x21, 0xa1, 0x1f, 0x64, 0x22, 0x52, 0xf5, 0xdf, + 0x55, 0xf0, 0x1e, 0xb4, 0x94, 0x84, 0x15, 0xf8, 0xbd, 0x6c, 0xc0, 0x4d, 0x29, 0x61, 0x85, 0xfd, + 0x50, 0xc1, 0x47, 0x80, 0x97, 0x12, 0x56, 0x89, 0x1f, 0x2b, 0x72, 0x92, 0x4a, 0xc2, 0x12, 0xe4, + 0xe8, 0xa7, 0x0a, 0xde, 0x85, 0xa6, 0x42, 0x8b, 0x0e, 0xa1, 0xbf, 0x2a, 0x4a, 0x41, 0xc9, 0x50, + 0xc2, 0x7f, 0xe7, 0x27, 0x73, 0x61, 0x6a, 0xf4, 0xe8, 0xe3, 0x8d, 0x5c, 0x54, 0x71, 0x32, 0x07, + 0x3f, 0x91, 0x53, 0xae, 0xc7, 0xe6, 0x94, 0xb3, 0x4c, 0xa0, 0x0f, 0xaa, 0x2a, 0x32, 0x58, 0xc2, + 0x04, 0x43, 0x1f, 0x56, 0x71, 0x03, 0xb6, 0x62, 0x35, 0x04, 0xf4, 0x22, 0x4f, 0xb9, 0x2c, 0xc8, + 0x46, 0xd7, 0xe8, 0xd7, 0xaa, 0xf2, 0x92, 0x47, 0x94, 0xf1, 0x79, 0x22, 0xd0, 0x6f, 0x55, 0xc5, + 0x7f, 0xc9, 0xc4, 0x6a, 0xd5, 0xd0, 0xef, 0x55, 0xfc, 0x2a, 0xb4, 0x25, 0xb8, 0xea, 0xa4, 0xcc, + 0x44, 0x5c, 0x44, 0x23, 0x8e, 0xfe, 0xa8, 0xe2, 0x63, 0x38, 0x92, 0xe9, 0xa5, 0xcb, 0xb5, 0xec, + 0x9f, 0xd5, 0xdc, 0x6e, 0xee, 0xc9, 0x9c, 0x3e, 0x4e, 0xd1, 0xcf, 0x35, 0xdc, 0x02, 0x2d, 0xf6, + 0xa2, 0x09, 0xf3, 0xa2, 0x51, 0x8c, 0x3e, 0xd5, 0x54, 0x9f, 0xee, 0xcf, 0x59, 0xb6, 0xb0, 0xd3, + 0x90, 0xc9, 0x6a, 0x8e, 0x3e, 0xd3, 0xf0, 0x0e, 0x40, 0x6c, 0xa5, 0x41, 0x98, 0xdb, 0xfc, 0x3c, + 0x07, 0x28, 0x7b, 0x7f, 0xce, 0xb8, 0x30, 0x0d, 0xf4, 0x85, 0x7c, 0x75, 0x1a, 0x25, 0xe0, 0xb9, + 0x0e, 0xfa, 0x52, 0x53, 0x8d, 0xec, 0x24, 0x49, 0x3a, 0x0a, 0xc4, 0xb2, 0x91, 0x5f, 0x69, 0x6a, + 0x42, 0x6b, 0xdb, 0x5e, 0x88, 0xfb, 0x5a, 0xc3, 0x87, 0xb0, 0x1b, 0xaf, 0x6f, 0xaa, 0x21, 0x97, + 0xf2, 0x1b, 0xed, 0xe2, 0xe2, 0xbd, 0x77, 0xc6, 0x91, 0xb8, 0x9e, 0x0f, 0xe5, 0x3b, 0x7e, 0xfe, + 0x3c, 0x4a, 0x92, 0xe8, 0xb9, 0x60, 0xa3, 0xeb, 0xf3, 0xfc, 0x8d, 0xbf, 0x13, 0x46, 0x5c, 0x64, + 0xd1, 0x70, 0x2e, 0x58, 0x78, 0x1e, 0x4d, 0x05, 0xcb, 0xa6, 0x41, 0x72, 0xae, 0x1e, 0xfe, 0xf3, + 0xfc, 0xe1, 0x9f, 0x0d, 0x87, 0x5b, 0x2a, 0x7e, 0xf3, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, + 0xc3, 0x62, 0xa9, 0xdb, 0x07, 0x00, 0x00, } diff --git a/internal/proto/data_service.proto b/internal/proto/data_service.proto index 60dcdd8f87..ea69cd75c7 100644 --- a/internal/proto/data_service.proto +++ b/internal/proto/data_service.proto @@ -71,15 +71,6 @@ message ShowSegmentResponse { common.Status status = 2; } -enum SegmentState { - SegmentNone = 0; - SegmentNotExist = 1; - SegmentGrowing = 2; - SegmentSealed = 3; - SegmentFlushed = 4; -} - - message SegmentStatesRequest { common.MsgBase base = 1; repeated int64 segmentIDs = 2; @@ -87,7 +78,7 @@ message SegmentStatesRequest { message SegmentStateInfo { int64 segmentID = 1; - SegmentState state = 2; + common.SegmentState state = 2; uint64 create_time = 3; uint64 sealed_time = 4; uint64 flushed_time = 5; @@ -96,6 +87,16 @@ message SegmentStateInfo { common.Status status = 8; } +message SegmentInfoRequest { + common.MsgBase base = 1; + repeated int64 segmentIDs = 2; +} + +message SegmentInfoResponse { + common.Status status = 1; + repeated SegmentInfo infos = 2; +} + message SegmentStatesResponse { common.Status status = 1; repeated SegmentStateInfo states = 2; @@ -143,7 +144,7 @@ message SegmentInfo { uint64 flushed_time = 7; int64 num_rows = 8; int64 mem_size = 9; - SegmentState state = 10; + common.SegmentState state = 10; repeated internal.MsgPosition start_position = 11; repeated internal.MsgPosition end_position = 12; } @@ -211,6 +212,7 @@ service DataService { rpc AssignSegmentID(AssignSegIDRequest) returns (AssignSegIDResponse) {} rpc ShowSegments(ShowSegmentRequest) returns (ShowSegmentResponse) {} + rpc GetSegmentInfo(SegmentInfoRequest) returns (SegmentInfoResponse) {} rpc GetSegmentStates(SegmentStatesRequest) returns (SegmentStatesResponse) {} rpc GetInsertBinlogPaths(InsertBinlogPathRequest) returns (InsertBinlogPathsResponse) {} diff --git a/internal/proto/datapb/data_service.pb.go b/internal/proto/datapb/data_service.pb.go index 432444baa3..7ffdefa907 100644 --- a/internal/proto/datapb/data_service.pb.go +++ b/internal/proto/datapb/data_service.pb.go @@ -27,40 +27,6 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package -type SegmentState int32 - -const ( - SegmentState_SegmentNone SegmentState = 0 - SegmentState_SegmentNotExist SegmentState = 1 - SegmentState_SegmentGrowing SegmentState = 2 - SegmentState_SegmentSealed SegmentState = 3 - SegmentState_SegmentFlushed SegmentState = 4 -) - -var SegmentState_name = map[int32]string{ - 0: "SegmentNone", - 1: "SegmentNotExist", - 2: "SegmentGrowing", - 3: "SegmentSealed", - 4: "SegmentFlushed", -} - -var SegmentState_value = map[string]int32{ - "SegmentNone": 0, - "SegmentNotExist": 1, - "SegmentGrowing": 2, - "SegmentSealed": 3, - "SegmentFlushed": 4, -} - -func (x SegmentState) String() string { - return proto.EnumName(SegmentState_name, int32(x)) -} - -func (SegmentState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{0} -} - type RegisterNodeRequest struct { Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` Address *commonpb.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` @@ -653,7 +619,7 @@ func (m *SegmentStatesRequest) GetSegmentIDs() []int64 { type SegmentStateInfo struct { SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` - State SegmentState `protobuf:"varint,2,opt,name=state,proto3,enum=milvus.proto.data.SegmentState" json:"state,omitempty"` + State commonpb.SegmentState `protobuf:"varint,2,opt,name=state,proto3,enum=milvus.proto.common.SegmentState" json:"state,omitempty"` CreateTime uint64 `protobuf:"varint,3,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"` SealedTime uint64 `protobuf:"varint,4,opt,name=sealed_time,json=sealedTime,proto3" json:"sealed_time,omitempty"` FlushedTime uint64 `protobuf:"varint,5,opt,name=flushed_time,json=flushedTime,proto3" json:"flushed_time,omitempty"` @@ -697,11 +663,11 @@ func (m *SegmentStateInfo) GetSegmentID() int64 { return 0 } -func (m *SegmentStateInfo) GetState() SegmentState { +func (m *SegmentStateInfo) GetState() commonpb.SegmentState { if m != nil { return m.State } - return SegmentState_SegmentNone + return commonpb.SegmentState_SegmentNone } func (m *SegmentStateInfo) GetCreateTime() uint64 { @@ -746,6 +712,100 @@ func (m *SegmentStateInfo) GetStatus() *commonpb.Status { return nil } +type SegmentInfoRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + SegmentIDs []int64 `protobuf:"varint,2,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SegmentInfoRequest) Reset() { *m = SegmentInfoRequest{} } +func (m *SegmentInfoRequest) String() string { return proto.CompactTextString(m) } +func (*SegmentInfoRequest) ProtoMessage() {} +func (*SegmentInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_3385cd32ad6cfe64, []int{11} +} + +func (m *SegmentInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SegmentInfoRequest.Unmarshal(m, b) +} +func (m *SegmentInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SegmentInfoRequest.Marshal(b, m, deterministic) +} +func (m *SegmentInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SegmentInfoRequest.Merge(m, src) +} +func (m *SegmentInfoRequest) XXX_Size() int { + return xxx_messageInfo_SegmentInfoRequest.Size(m) +} +func (m *SegmentInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SegmentInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SegmentInfoRequest proto.InternalMessageInfo + +func (m *SegmentInfoRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + +func (m *SegmentInfoRequest) GetSegmentIDs() []int64 { + if m != nil { + return m.SegmentIDs + } + return nil +} + +type SegmentInfoResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Infos []*SegmentInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SegmentInfoResponse) Reset() { *m = SegmentInfoResponse{} } +func (m *SegmentInfoResponse) String() string { return proto.CompactTextString(m) } +func (*SegmentInfoResponse) ProtoMessage() {} +func (*SegmentInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3385cd32ad6cfe64, []int{12} +} + +func (m *SegmentInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SegmentInfoResponse.Unmarshal(m, b) +} +func (m *SegmentInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SegmentInfoResponse.Marshal(b, m, deterministic) +} +func (m *SegmentInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SegmentInfoResponse.Merge(m, src) +} +func (m *SegmentInfoResponse) XXX_Size() int { + return xxx_messageInfo_SegmentInfoResponse.Size(m) +} +func (m *SegmentInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SegmentInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SegmentInfoResponse proto.InternalMessageInfo + +func (m *SegmentInfoResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *SegmentInfoResponse) GetInfos() []*SegmentInfo { + if m != nil { + return m.Infos + } + return nil +} + type SegmentStatesResponse struct { Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` States []*SegmentStateInfo `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"` @@ -758,7 +818,7 @@ func (m *SegmentStatesResponse) Reset() { *m = SegmentStatesResponse{} } func (m *SegmentStatesResponse) String() string { return proto.CompactTextString(m) } func (*SegmentStatesResponse) ProtoMessage() {} func (*SegmentStatesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{11} + return fileDescriptor_3385cd32ad6cfe64, []int{13} } func (m *SegmentStatesResponse) XXX_Unmarshal(b []byte) error { @@ -805,7 +865,7 @@ func (m *InsertBinlogPathRequest) Reset() { *m = InsertBinlogPathRequest func (m *InsertBinlogPathRequest) String() string { return proto.CompactTextString(m) } func (*InsertBinlogPathRequest) ProtoMessage() {} func (*InsertBinlogPathRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{12} + return fileDescriptor_3385cd32ad6cfe64, []int{14} } func (m *InsertBinlogPathRequest) XXX_Unmarshal(b []byte) error { @@ -853,7 +913,7 @@ func (m *InsertBinlogPathsResponse) Reset() { *m = InsertBinlogPathsResp func (m *InsertBinlogPathsResponse) String() string { return proto.CompactTextString(m) } func (*InsertBinlogPathsResponse) ProtoMessage() {} func (*InsertBinlogPathsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{13} + return fileDescriptor_3385cd32ad6cfe64, []int{15} } func (m *InsertBinlogPathsResponse) XXX_Unmarshal(b []byte) error { @@ -908,7 +968,7 @@ func (m *InsertChannelRequest) Reset() { *m = InsertChannelRequest{} } func (m *InsertChannelRequest) String() string { return proto.CompactTextString(m) } func (*InsertChannelRequest) ProtoMessage() {} func (*InsertChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{14} + return fileDescriptor_3385cd32ad6cfe64, []int{16} } func (m *InsertChannelRequest) XXX_Unmarshal(b []byte) error { @@ -962,7 +1022,7 @@ func (m *WatchDmChannelRequest) Reset() { *m = WatchDmChannelRequest{} } func (m *WatchDmChannelRequest) String() string { return proto.CompactTextString(m) } func (*WatchDmChannelRequest) ProtoMessage() {} func (*WatchDmChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{15} + return fileDescriptor_3385cd32ad6cfe64, []int{17} } func (m *WatchDmChannelRequest) XXX_Unmarshal(b []byte) error { @@ -1011,7 +1071,7 @@ func (m *FlushSegRequest) Reset() { *m = FlushSegRequest{} } func (m *FlushSegRequest) String() string { return proto.CompactTextString(m) } func (*FlushSegRequest) ProtoMessage() {} func (*FlushSegRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{16} + return fileDescriptor_3385cd32ad6cfe64, []int{18} } func (m *FlushSegRequest) XXX_Unmarshal(b []byte) error { @@ -1070,7 +1130,7 @@ type SegmentInfo struct { FlushedTime uint64 `protobuf:"varint,7,opt,name=flushed_time,json=flushedTime,proto3" json:"flushed_time,omitempty"` NumRows int64 `protobuf:"varint,8,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"` MemSize int64 `protobuf:"varint,9,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"` - State SegmentState `protobuf:"varint,10,opt,name=state,proto3,enum=milvus.proto.data.SegmentState" json:"state,omitempty"` + State commonpb.SegmentState `protobuf:"varint,10,opt,name=state,proto3,enum=milvus.proto.common.SegmentState" json:"state,omitempty"` StartPosition []*internalpb2.MsgPosition `protobuf:"bytes,11,rep,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` EndPosition []*internalpb2.MsgPosition `protobuf:"bytes,12,rep,name=end_position,json=endPosition,proto3" json:"end_position,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -1082,7 +1142,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} } func (m *SegmentInfo) String() string { return proto.CompactTextString(m) } func (*SegmentInfo) ProtoMessage() {} func (*SegmentInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{17} + return fileDescriptor_3385cd32ad6cfe64, []int{19} } func (m *SegmentInfo) XXX_Unmarshal(b []byte) error { @@ -1166,11 +1226,11 @@ func (m *SegmentInfo) GetMemSize() int64 { return 0 } -func (m *SegmentInfo) GetState() SegmentState { +func (m *SegmentInfo) GetState() commonpb.SegmentState { if m != nil { return m.State } - return SegmentState_SegmentNone + return commonpb.SegmentState_SegmentNone } func (m *SegmentInfo) GetStartPosition() []*internalpb2.MsgPosition { @@ -1199,7 +1259,7 @@ func (m *SegmentMsg) Reset() { *m = SegmentMsg{} } func (m *SegmentMsg) String() string { return proto.CompactTextString(m) } func (*SegmentMsg) ProtoMessage() {} func (*SegmentMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{18} + return fileDescriptor_3385cd32ad6cfe64, []int{20} } func (m *SegmentMsg) XXX_Unmarshal(b []byte) error { @@ -1247,7 +1307,7 @@ func (m *CollectionStatsRequest) Reset() { *m = CollectionStatsRequest{} func (m *CollectionStatsRequest) String() string { return proto.CompactTextString(m) } func (*CollectionStatsRequest) ProtoMessage() {} func (*CollectionStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{19} + return fileDescriptor_3385cd32ad6cfe64, []int{21} } func (m *CollectionStatsRequest) XXX_Unmarshal(b []byte) error { @@ -1301,7 +1361,7 @@ func (m *CollectionStatsResponse) Reset() { *m = CollectionStatsResponse func (m *CollectionStatsResponse) String() string { return proto.CompactTextString(m) } func (*CollectionStatsResponse) ProtoMessage() {} func (*CollectionStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{20} + return fileDescriptor_3385cd32ad6cfe64, []int{22} } func (m *CollectionStatsResponse) XXX_Unmarshal(b []byte) error { @@ -1350,7 +1410,7 @@ func (m *PartitionStatsRequest) Reset() { *m = PartitionStatsRequest{} } func (m *PartitionStatsRequest) String() string { return proto.CompactTextString(m) } func (*PartitionStatsRequest) ProtoMessage() {} func (*PartitionStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{21} + return fileDescriptor_3385cd32ad6cfe64, []int{23} } func (m *PartitionStatsRequest) XXX_Unmarshal(b []byte) error { @@ -1411,7 +1471,7 @@ func (m *PartitionStatsResponse) Reset() { *m = PartitionStatsResponse{} func (m *PartitionStatsResponse) String() string { return proto.CompactTextString(m) } func (*PartitionStatsResponse) ProtoMessage() {} func (*PartitionStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{22} + return fileDescriptor_3385cd32ad6cfe64, []int{24} } func (m *PartitionStatsResponse) XXX_Unmarshal(b []byte) error { @@ -1458,7 +1518,7 @@ func (m *FieldFlushMeta) Reset() { *m = FieldFlushMeta{} } func (m *FieldFlushMeta) String() string { return proto.CompactTextString(m) } func (*FieldFlushMeta) ProtoMessage() {} func (*FieldFlushMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{23} + return fileDescriptor_3385cd32ad6cfe64, []int{25} } func (m *FieldFlushMeta) XXX_Unmarshal(b []byte) error { @@ -1506,7 +1566,7 @@ func (m *SegmentFlushMeta) Reset() { *m = SegmentFlushMeta{} } func (m *SegmentFlushMeta) String() string { return proto.CompactTextString(m) } func (*SegmentFlushMeta) ProtoMessage() {} func (*SegmentFlushMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{24} + return fileDescriptor_3385cd32ad6cfe64, []int{26} } func (m *SegmentFlushMeta) XXX_Unmarshal(b []byte) error { @@ -1560,7 +1620,7 @@ func (m *DDLFlushMeta) Reset() { *m = DDLFlushMeta{} } func (m *DDLFlushMeta) String() string { return proto.CompactTextString(m) } func (*DDLFlushMeta) ProtoMessage() {} func (*DDLFlushMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{25} + return fileDescriptor_3385cd32ad6cfe64, []int{27} } func (m *DDLFlushMeta) XXX_Unmarshal(b []byte) error { @@ -1608,7 +1668,7 @@ func (m *CollectionCountRequest) Reset() { *m = CollectionCountRequest{} func (m *CollectionCountRequest) String() string { return proto.CompactTextString(m) } func (*CollectionCountRequest) ProtoMessage() {} func (*CollectionCountRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{26} + return fileDescriptor_3385cd32ad6cfe64, []int{28} } func (m *CollectionCountRequest) XXX_Unmarshal(b []byte) error { @@ -1662,7 +1722,7 @@ func (m *CollectionCountResponse) Reset() { *m = CollectionCountResponse func (m *CollectionCountResponse) String() string { return proto.CompactTextString(m) } func (*CollectionCountResponse) ProtoMessage() {} func (*CollectionCountResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3385cd32ad6cfe64, []int{27} + return fileDescriptor_3385cd32ad6cfe64, []int{29} } func (m *CollectionCountResponse) XXX_Unmarshal(b []byte) error { @@ -1698,7 +1758,6 @@ func (m *CollectionCountResponse) GetCount() int64 { } func init() { - proto.RegisterEnum("milvus.proto.data.SegmentState", SegmentState_name, SegmentState_value) proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.data.RegisterNodeRequest") proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.data.RegisterNodeResponse") proto.RegisterType((*SegIDRequest)(nil), "milvus.proto.data.SegIDRequest") @@ -1710,6 +1769,8 @@ func init() { proto.RegisterType((*ShowSegmentResponse)(nil), "milvus.proto.data.ShowSegmentResponse") proto.RegisterType((*SegmentStatesRequest)(nil), "milvus.proto.data.SegmentStatesRequest") proto.RegisterType((*SegmentStateInfo)(nil), "milvus.proto.data.SegmentStateInfo") + proto.RegisterType((*SegmentInfoRequest)(nil), "milvus.proto.data.SegmentInfoRequest") + proto.RegisterType((*SegmentInfoResponse)(nil), "milvus.proto.data.SegmentInfoResponse") proto.RegisterType((*SegmentStatesResponse)(nil), "milvus.proto.data.SegmentStatesResponse") proto.RegisterType((*InsertBinlogPathRequest)(nil), "milvus.proto.data.InsertBinlogPathRequest") proto.RegisterType((*InsertBinlogPathsResponse)(nil), "milvus.proto.data.InsertBinlogPathsResponse") @@ -1732,109 +1793,109 @@ func init() { func init() { proto.RegisterFile("data_service.proto", fileDescriptor_3385cd32ad6cfe64) } var fileDescriptor_3385cd32ad6cfe64 = []byte{ - // 1627 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5b, 0x6f, 0x1b, 0x45, - 0x14, 0xce, 0x66, 0xed, 0xd8, 0x3e, 0xbe, 0xc4, 0x9d, 0x5c, 0xea, 0xba, 0xa5, 0x4d, 0x17, 0xb5, - 0x4d, 0x2b, 0x48, 0x50, 0x2a, 0x28, 0x08, 0x09, 0xd1, 0xd4, 0x69, 0x64, 0xb5, 0x89, 0xa2, 0x75, - 0xa1, 0x22, 0x2f, 0xd6, 0xda, 0x9e, 0x3a, 0x03, 0xde, 0x5d, 0xb3, 0x33, 0x6e, 0xd2, 0xbc, 0x80, - 0x78, 0x00, 0xc1, 0x0b, 0x3c, 0x81, 0x04, 0x2f, 0x48, 0x88, 0xdf, 0xc1, 0x5f, 0xe0, 0xc7, 0xf0, - 0xc0, 0x23, 0x9a, 0xcb, 0xde, 0xec, 0x4d, 0xd6, 0xa4, 0xb7, 0x37, 0xcf, 0xf1, 0x37, 0xe7, 0x9c, - 0x39, 0x97, 0xef, 0xcc, 0x2c, 0xa0, 0x9e, 0xc5, 0xac, 0x36, 0xc5, 0xde, 0x53, 0xd2, 0xc5, 0x6b, - 0x43, 0xcf, 0x65, 0x2e, 0x3a, 0x67, 0x93, 0xc1, 0xd3, 0x11, 0x95, 0xab, 0x35, 0x0e, 0xa8, 0x97, - 0xba, 0xae, 0x6d, 0xbb, 0x8e, 0x14, 0xd5, 0x2b, 0xc4, 0x61, 0xd8, 0x73, 0xac, 0x81, 0x5a, 0x97, - 0xa2, 0x1b, 0x8c, 0xaf, 0x60, 0xc1, 0xc4, 0x7d, 0x42, 0x19, 0xf6, 0x76, 0xdd, 0x1e, 0x36, 0xf1, - 0x97, 0x23, 0x4c, 0x19, 0x7a, 0x07, 0x32, 0x1d, 0x8b, 0xe2, 0x9a, 0xb6, 0xa2, 0xad, 0x16, 0x37, - 0x2e, 0xad, 0xc5, 0x8c, 0x28, 0xf5, 0x3b, 0xb4, 0xbf, 0x69, 0x51, 0x6c, 0x0a, 0x24, 0x7a, 0x0f, - 0x72, 0x56, 0xaf, 0xe7, 0x61, 0x4a, 0x6b, 0xb3, 0xa7, 0x6c, 0xba, 0x2b, 0x31, 0xa6, 0x0f, 0x36, - 0x7e, 0xd4, 0x60, 0x31, 0xee, 0x01, 0x1d, 0xba, 0x0e, 0xc5, 0x68, 0x13, 0x8a, 0xc4, 0x21, 0xac, - 0x3d, 0xb4, 0x3c, 0xcb, 0xa6, 0xca, 0x93, 0xab, 0x71, 0xa5, 0xc1, 0xd1, 0x9a, 0x0e, 0x61, 0x7b, - 0x02, 0x68, 0x02, 0x09, 0x7e, 0xa3, 0xdb, 0x30, 0x47, 0x99, 0xc5, 0x46, 0xbe, 0x4f, 0x17, 0x13, - 0x7d, 0x6a, 0x09, 0x88, 0xa9, 0xa0, 0xc6, 0xdf, 0x1a, 0x94, 0x5a, 0xb8, 0xdf, 0x6c, 0xf8, 0xc1, - 0x58, 0x84, 0x6c, 0xd7, 0x1d, 0x39, 0x4c, 0xf8, 0x50, 0x36, 0xe5, 0x02, 0xad, 0x40, 0xb1, 0x7b, - 0x60, 0x39, 0x0e, 0x1e, 0xec, 0x5a, 0x36, 0x16, 0x06, 0x0a, 0x66, 0x54, 0x84, 0x0c, 0x28, 0x75, - 0xdd, 0xc1, 0x00, 0x77, 0x19, 0x71, 0x9d, 0x66, 0xa3, 0xa6, 0xaf, 0x68, 0xab, 0xba, 0x19, 0x93, - 0x71, 0x2d, 0x43, 0xcb, 0x63, 0x44, 0x41, 0x32, 0x02, 0x12, 0x15, 0xa1, 0x8b, 0x50, 0xe0, 0x3b, - 0xda, 0x0e, 0xb7, 0x92, 0x15, 0x56, 0xf2, 0x5c, 0x20, 0x4c, 0x5c, 0x83, 0x4a, 0x80, 0x95, 0x88, - 0x39, 0x81, 0x28, 0x07, 0x52, 0x0e, 0x33, 0x7e, 0xd2, 0x00, 0xdd, 0xa5, 0x94, 0xf4, 0x9d, 0xd8, - 0xc1, 0x96, 0x61, 0xce, 0x71, 0x7b, 0xb8, 0xd9, 0x10, 0x27, 0xd3, 0x4d, 0xb5, 0xe2, 0x26, 0x87, - 0x18, 0x7b, 0x6d, 0xcf, 0x1d, 0xf8, 0x07, 0xcb, 0x73, 0x81, 0xe9, 0x0e, 0x30, 0xda, 0x82, 0x32, - 0x8d, 0x28, 0xa1, 0x35, 0x7d, 0x45, 0x5f, 0x2d, 0x6e, 0x5c, 0x59, 0x9b, 0x28, 0xc4, 0xb5, 0xa8, - 0x31, 0x33, 0xbe, 0xcb, 0xf8, 0x6b, 0x16, 0xe6, 0xc5, 0xff, 0xd2, 0x2f, 0x1b, 0x3b, 0x22, 0xd0, - 0x02, 0xa4, 0xdc, 0x91, 0x8b, 0x29, 0x02, 0x1d, 0x24, 0x48, 0x8f, 0x26, 0x68, 0x3c, 0xfc, 0x99, - 0xf4, 0xf0, 0x67, 0x27, 0xc3, 0x7f, 0x05, 0x8a, 0xf8, 0x68, 0x48, 0x3c, 0xdc, 0x66, 0x44, 0x85, - 0x37, 0x63, 0x82, 0x14, 0x3d, 0x22, 0x36, 0x8e, 0xd4, 0x58, 0x6e, 0xea, 0x1a, 0x8b, 0x27, 0x35, - 0x9f, 0x9a, 0xd4, 0x42, 0x52, 0x52, 0x7f, 0xd5, 0x60, 0x21, 0x96, 0x54, 0xd5, 0x38, 0xbb, 0x50, - 0xa5, 0xf1, 0xc0, 0xf2, 0xee, 0xe1, 0x39, 0x32, 0x4e, 0xca, 0x51, 0x08, 0x35, 0x27, 0xf6, 0x9e, - 0xad, 0x89, 0x8e, 0xa0, 0x74, 0x7f, 0x30, 0xa2, 0x07, 0x67, 0x27, 0x14, 0x04, 0x99, 0x5e, 0xa7, - 0xd9, 0x10, 0x46, 0x75, 0x53, 0xfc, 0x9e, 0x26, 0xa5, 0xc6, 0xef, 0x1a, 0xa0, 0xd6, 0x81, 0x7b, - 0xd8, 0xc2, 0x7d, 0x71, 0xa0, 0x33, 0x3b, 0x30, 0x6e, 0x6c, 0x36, 0xbd, 0x7e, 0xf4, 0xc9, 0xfa, - 0xf1, 0x8f, 0x91, 0x09, 0x8f, 0x61, 0x7c, 0x0e, 0x0b, 0x31, 0x0f, 0x55, 0xe2, 0x2e, 0x03, 0x50, - 0x29, 0x6a, 0x36, 0x64, 0xca, 0x74, 0x33, 0x22, 0x39, 0x5b, 0x22, 0x0e, 0x60, 0x51, 0xd9, 0xe1, - 0x7f, 0x60, 0x7a, 0xf6, 0x78, 0xc4, 0xdd, 0x9b, 0x1d, 0x77, 0xcf, 0xf8, 0x45, 0x87, 0x6a, 0xd4, - 0x54, 0xd3, 0x79, 0xe2, 0xa2, 0x4b, 0x50, 0x08, 0x20, 0xaa, 0xad, 0x43, 0x01, 0x7a, 0x17, 0xb2, - 0xdc, 0x4d, 0xd9, 0xd4, 0x95, 0x93, 0x38, 0x24, 0xd0, 0x68, 0x4a, 0x34, 0xef, 0xc9, 0xae, 0x87, - 0x2d, 0xa6, 0x7a, 0x52, 0x97, 0x3d, 0x29, 0x45, 0xa2, 0x27, 0xaf, 0x40, 0x91, 0x62, 0x6b, 0x80, - 0x7b, 0x12, 0x90, 0x91, 0x00, 0x29, 0x12, 0x80, 0xab, 0x50, 0x7a, 0xc2, 0xcb, 0xd3, 0x47, 0x64, - 0x05, 0xa2, 0xa8, 0x64, 0x02, 0xf2, 0x00, 0xe6, 0x29, 0xb3, 0x3c, 0xd6, 0x1e, 0xba, 0x54, 0x24, - 0x93, 0xd6, 0xe6, 0x92, 0xba, 0x28, 0x98, 0x41, 0x3b, 0xb4, 0xbf, 0xa7, 0xa0, 0x66, 0x45, 0x6c, - 0xf5, 0x97, 0x14, 0x6d, 0x43, 0x19, 0x3b, 0xbd, 0x88, 0xaa, 0xdc, 0xd4, 0xaa, 0x4a, 0xd8, 0xe9, - 0x85, 0x8a, 0xc2, 0x1a, 0xc8, 0x4f, 0x5f, 0x03, 0xdf, 0x6b, 0xb0, 0x34, 0x56, 0x04, 0xaa, 0xe4, - 0x42, 0x75, 0xda, 0xf4, 0xe4, 0xf5, 0xa1, 0xdc, 0x84, 0x65, 0x11, 0x14, 0x37, 0xde, 0x4c, 0x49, - 0x1b, 0x2f, 0x04, 0x53, 0x6d, 0x31, 0x08, 0x9c, 0x6f, 0x3a, 0x14, 0x7b, 0x6c, 0x93, 0x38, 0x03, - 0xb7, 0xbf, 0x67, 0xb1, 0xe7, 0xe0, 0x88, 0x58, 0x75, 0xcd, 0x8e, 0x55, 0x97, 0xf1, 0xa7, 0x06, - 0x17, 0xc6, 0x6d, 0x85, 0x47, 0xaf, 0x43, 0xfe, 0x09, 0xc1, 0x83, 0x5e, 0xd8, 0x6b, 0xc1, 0x1a, - 0xdd, 0x81, 0xec, 0x90, 0x83, 0xd5, 0x01, 0x4f, 0xba, 0x75, 0xb4, 0x98, 0x47, 0x9c, 0xfe, 0x43, - 0x42, 0x99, 0x29, 0xf1, 0x91, 0x78, 0xea, 0xd3, 0xa7, 0xe7, 0x6b, 0x0d, 0x16, 0xa5, 0x9f, 0xf7, - 0xe4, 0x50, 0x7b, 0xb9, 0xa4, 0x99, 0x70, 0x0d, 0x31, 0x6c, 0x58, 0x7a, 0x6c, 0xb1, 0xee, 0x41, - 0xc3, 0x7e, 0x6e, 0x17, 0xb8, 0xb9, 0x70, 0x36, 0xcb, 0x10, 0x16, 0xcc, 0x98, 0xcc, 0xf8, 0x4d, - 0x83, 0x79, 0x31, 0x1e, 0x5a, 0xb8, 0xff, 0xca, 0x0f, 0x3b, 0x46, 0x64, 0x99, 0x09, 0x22, 0xfb, - 0x57, 0x87, 0xa2, 0xaa, 0xdf, 0x29, 0x38, 0xec, 0xc5, 0x8c, 0x89, 0x6b, 0x50, 0x21, 0xa2, 0x04, - 0xda, 0x2a, 0x50, 0x82, 0xb4, 0x0a, 0x66, 0x99, 0x44, 0x0b, 0x83, 0xdf, 0x1b, 0xdc, 0x21, 0x76, - 0xa2, 0xa4, 0x95, 0xe7, 0x82, 0x24, 0xd6, 0x9b, 0x4b, 0x65, 0xbd, 0xdc, 0x24, 0xeb, 0x5d, 0x80, - 0xbc, 0x33, 0xb2, 0xdb, 0x9e, 0x7b, 0x28, 0x19, 0x46, 0x37, 0x73, 0xce, 0xc8, 0x36, 0xdd, 0x43, - 0xca, 0xff, 0xb2, 0xb1, 0xdd, 0xa6, 0xe4, 0x58, 0x5e, 0x48, 0x74, 0x33, 0x67, 0x63, 0xbb, 0x45, - 0x8e, 0x71, 0xc8, 0xe3, 0xf0, 0xbf, 0x78, 0xbc, 0x09, 0x95, 0x38, 0xc5, 0xd6, 0x8a, 0x53, 0xd3, - 0x62, 0x39, 0xc6, 0xb0, 0x68, 0x0b, 0x4a, 0x51, 0x82, 0xad, 0x95, 0xa6, 0x56, 0x54, 0x8c, 0xf0, - 0xab, 0x71, 0x04, 0xa0, 0x1c, 0xdd, 0xa1, 0xfd, 0x33, 0x94, 0xe4, 0xfb, 0x90, 0x53, 0x95, 0xa1, - 0x66, 0xf4, 0xe5, 0x93, 0x43, 0x21, 0x68, 0xd1, 0x87, 0x1b, 0xdf, 0x68, 0xb0, 0x7c, 0x2f, 0xa8, - 0x19, 0x1e, 0x26, 0xfa, 0xea, 0x69, 0xe0, 0x3b, 0x0d, 0xce, 0x4f, 0x38, 0xa1, 0xf8, 0xf2, 0x8e, - 0xcc, 0xb1, 0x7f, 0x97, 0xbc, 0x9a, 0xe8, 0xc6, 0x03, 0xfc, 0xec, 0x53, 0x6b, 0x30, 0xc2, 0x7b, - 0x16, 0xf1, 0x64, 0x96, 0xcf, 0x78, 0x6d, 0xf9, 0x43, 0x83, 0xa5, 0x3d, 0xbf, 0x3f, 0x5e, 0x4f, - 0x34, 0xd2, 0xdf, 0x66, 0xc6, 0xb7, 0x1a, 0x2c, 0x8f, 0x7b, 0xf9, 0x5a, 0xc2, 0xb5, 0x03, 0x95, - 0xfb, 0x7c, 0x78, 0x09, 0x52, 0xdd, 0xc1, 0xcc, 0x42, 0x35, 0xc8, 0xa9, 0x71, 0xa6, 0x28, 0xcb, - 0x5f, 0x72, 0x16, 0xe8, 0x88, 0x79, 0xd8, 0x0e, 0x67, 0x5c, 0xc1, 0x2c, 0x76, 0xc2, 0x19, 0x69, - 0xfc, 0xa0, 0x05, 0x57, 0xb9, 0x50, 0xe3, 0xe9, 0x34, 0xf8, 0x06, 0x00, 0xa1, 0x6d, 0x45, 0x25, - 0xc2, 0xf5, 0xbc, 0x59, 0x20, 0xf4, 0xbe, 0x14, 0xa0, 0x0f, 0x60, 0x4e, 0xd8, 0xa7, 0xb5, 0x6c, - 0x52, 0x3c, 0x44, 0x5f, 0xc4, 0x4f, 0x60, 0xaa, 0x0d, 0xc6, 0x27, 0x50, 0x6a, 0x34, 0x1e, 0x86, - 0x7e, 0x8c, 0xa7, 0x4e, 0x4b, 0x48, 0xdd, 0x14, 0x67, 0x8c, 0x37, 0xdc, 0x3d, 0xfe, 0x64, 0x7c, - 0xf5, 0x0d, 0xd7, 0x8b, 0xf6, 0x9b, 0xf2, 0xe1, 0x79, 0xae, 0x66, 0xc1, 0x4b, 0x58, 0x3a, 0x22, - 0x17, 0xb7, 0x5c, 0xf1, 0x41, 0x23, 0xa0, 0x5f, 0x34, 0x1f, 0xcc, 0xb7, 0x5d, 0xd7, 0xc1, 0xd5, - 0x19, 0xb4, 0x20, 0xde, 0xe2, 0x52, 0xc0, 0xb6, 0x8e, 0x08, 0x65, 0x55, 0x0d, 0x21, 0xa8, 0x28, - 0xe1, 0xb6, 0xe7, 0x1e, 0x12, 0xa7, 0x5f, 0x9d, 0x45, 0xe7, 0xa0, 0xec, 0x6b, 0x12, 0x63, 0xa5, - 0xaa, 0x47, 0x60, 0x2a, 0xd7, 0xd5, 0xcc, 0xc6, 0x3f, 0x00, 0xc5, 0x86, 0xc5, 0xac, 0x96, 0xfc, - 0x54, 0x85, 0x2c, 0x28, 0x45, 0xbf, 0xf1, 0xa0, 0xeb, 0x09, 0xd9, 0x4f, 0xf8, 0x0c, 0x55, 0xbf, - 0x91, 0x8a, 0x93, 0xc1, 0x32, 0x66, 0xd0, 0x36, 0x64, 0x85, 0x7d, 0x94, 0x34, 0x7c, 0xa2, 0x4f, - 0xd1, 0xfa, 0x69, 0x81, 0x34, 0x66, 0x50, 0x07, 0xe6, 0x83, 0x57, 0xb5, 0xaa, 0xed, 0x6b, 0x09, - 0x2a, 0x27, 0x3f, 0xa7, 0xd4, 0xaf, 0xa7, 0xc1, 0x02, 0x67, 0xdb, 0x50, 0x8a, 0x3c, 0x00, 0x69, - 0xa2, 0x81, 0xc9, 0x37, 0x6c, 0xa2, 0x81, 0x84, 0x87, 0xa4, 0x31, 0x83, 0xfa, 0x50, 0xdd, 0xc6, - 0x2c, 0x76, 0xe7, 0x47, 0x37, 0x52, 0xa6, 0xb2, 0xcf, 0xb0, 0xf5, 0xd5, 0x74, 0x60, 0x60, 0xc8, - 0x83, 0xc5, 0x6d, 0xcc, 0x26, 0x6e, 0xd9, 0xe8, 0x56, 0x82, 0x8e, 0x13, 0xee, 0xfd, 0xf5, 0xb7, - 0xa6, 0xc0, 0x46, 0x6d, 0x5a, 0x70, 0x2e, 0xb0, 0xa9, 0x2e, 0x46, 0xc9, 0xa7, 0x4b, 0xba, 0x54, - 0xd7, 0xd3, 0x2f, 0xf3, 0xe2, 0x58, 0xe7, 0xb7, 0x31, 0x8b, 0x8f, 0x42, 0x42, 0x19, 0xe9, 0x52, - 0x74, 0x33, 0xc1, 0x50, 0xf2, 0xe0, 0xae, 0xdf, 0x9a, 0x06, 0x1a, 0x1c, 0xcb, 0x85, 0xe5, 0x6d, - 0xcc, 0x62, 0xe3, 0x44, 0x99, 0x4c, 0x4a, 0x48, 0xe2, 0x70, 0xac, 0xdf, 0x9c, 0x02, 0x19, 0x18, - 0xdc, 0x07, 0x24, 0x0e, 0x69, 0x0f, 0x5d, 0x27, 0x2c, 0x93, 0x7a, 0x62, 0x7b, 0x6c, 0xd9, 0x43, - 0xf6, 0x6c, 0xbc, 0x00, 0x83, 0xd8, 0x8d, 0xe9, 0x30, 0x66, 0xd0, 0x63, 0xa1, 0x9b, 0x5f, 0x29, - 0x1f, 0x91, 0xee, 0x17, 0xfe, 0xf5, 0xf5, 0x34, 0xdd, 0x63, 0xaf, 0x48, 0xb5, 0x90, 0x59, 0x89, - 0x38, 0xfd, 0x99, 0x28, 0xb8, 0x30, 0x38, 0x2f, 0x50, 0xf5, 0x3e, 0x2c, 0x85, 0x4d, 0xc3, 0x6f, - 0x67, 0x2f, 0x50, 0x77, 0x17, 0xf2, 0x22, 0xd6, 0x23, 0x87, 0xa5, 0x54, 0x50, 0x74, 0x12, 0xa5, - 0x54, 0x50, 0x6c, 0x60, 0x18, 0x33, 0x1b, 0x3f, 0xcf, 0x42, 0x9e, 0xd3, 0xae, 0xe0, 0xd8, 0x97, - 0x99, 0xdd, 0x7d, 0x98, 0x8f, 0x3f, 0x17, 0x93, 0x6b, 0x34, 0xf1, 0x49, 0x99, 0xc6, 0xbf, 0x26, - 0x94, 0xfd, 0xa7, 0xa1, 0x24, 0x47, 0xe3, 0x24, 0x42, 0x0f, 0x1f, 0x8f, 0x29, 0x3a, 0x37, 0x3f, - 0xde, 0xff, 0xa8, 0x4f, 0xd8, 0xc1, 0xa8, 0xc3, 0xff, 0x59, 0x3f, 0x26, 0x83, 0x01, 0x39, 0x66, - 0xb8, 0x7b, 0xb0, 0x2e, 0x77, 0xbd, 0xdd, 0x23, 0x94, 0x79, 0xa4, 0x33, 0x62, 0xb8, 0xb7, 0xee, - 0x1f, 0x7b, 0x5d, 0xa8, 0x5a, 0xe7, 0xe6, 0x86, 0x9d, 0xce, 0x9c, 0x58, 0xdd, 0xfe, 0x2f, 0x00, - 0x00, 0xff, 0xff, 0x12, 0x7a, 0x41, 0x93, 0x83, 0x19, 0x00, 0x00, + // 1618 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5b, 0x6f, 0x1b, 0xc5, + 0x1e, 0xcf, 0x66, 0xed, 0xd8, 0xfe, 0xdb, 0x71, 0xda, 0xc9, 0xa5, 0xae, 0xdb, 0xd3, 0xa6, 0x7b, + 0x94, 0x36, 0xad, 0xce, 0x49, 0x8e, 0xd2, 0xa3, 0x73, 0x40, 0x48, 0x88, 0xa6, 0x6e, 0x23, 0xab, + 0x4d, 0x15, 0x8d, 0x0b, 0x15, 0x79, 0xb1, 0xd6, 0xf6, 0xc4, 0x19, 0xf0, 0xee, 0x9a, 0x9d, 0x71, + 0x2f, 0x79, 0xa1, 0xe2, 0x01, 0x04, 0x2f, 0xf0, 0x84, 0x04, 0xbc, 0x20, 0x21, 0x3e, 0x07, 0x5f, + 0x81, 0x37, 0xbe, 0x0b, 0x4f, 0x68, 0x2e, 0x7b, 0xb3, 0x37, 0x59, 0x93, 0xf4, 0xf2, 0xe6, 0xf9, + 0xfb, 0x37, 0xff, 0xfb, 0x6d, 0x16, 0x50, 0xcf, 0xe6, 0x76, 0x9b, 0x11, 0xff, 0x29, 0xed, 0x92, + 0x8d, 0xa1, 0xef, 0x71, 0x0f, 0x9d, 0x77, 0xe8, 0xe0, 0xe9, 0x88, 0xa9, 0xd3, 0x86, 0x00, 0xd4, + 0x2b, 0x5d, 0xcf, 0x71, 0x3c, 0x57, 0x91, 0xea, 0x55, 0xea, 0x72, 0xe2, 0xbb, 0xf6, 0x40, 0x9f, + 0x2b, 0xf1, 0x0b, 0xd6, 0xe7, 0xb0, 0x88, 0x49, 0x9f, 0x32, 0x4e, 0xfc, 0x47, 0x5e, 0x8f, 0x60, + 0xf2, 0xd9, 0x88, 0x30, 0x8e, 0xfe, 0x03, 0xb9, 0x8e, 0xcd, 0x48, 0xcd, 0x58, 0x35, 0xd6, 0xcb, + 0x5b, 0x97, 0x37, 0x12, 0x42, 0x34, 0xfb, 0x5d, 0xd6, 0xdf, 0xb6, 0x19, 0xc1, 0x12, 0x89, 0xfe, + 0x07, 0x05, 0xbb, 0xd7, 0xf3, 0x09, 0x63, 0xb5, 0xd9, 0x13, 0x2e, 0xdd, 0x51, 0x18, 0x1c, 0x80, + 0xad, 0x6f, 0x0d, 0x58, 0x4a, 0x6a, 0xc0, 0x86, 0x9e, 0xcb, 0x08, 0xda, 0x86, 0x32, 0x75, 0x29, + 0x6f, 0x0f, 0x6d, 0xdf, 0x76, 0x98, 0xd6, 0xe4, 0x5a, 0x92, 0x69, 0x68, 0x5a, 0xd3, 0xa5, 0x7c, + 0x4f, 0x02, 0x31, 0xd0, 0xf0, 0x37, 0xba, 0x0d, 0x73, 0x8c, 0xdb, 0x7c, 0x14, 0xe8, 0x74, 0x29, + 0x55, 0xa7, 0x96, 0x84, 0x60, 0x0d, 0xb5, 0x7e, 0x37, 0xa0, 0xd2, 0x22, 0xfd, 0x66, 0x23, 0x70, + 0xc6, 0x12, 0xe4, 0xbb, 0xde, 0xc8, 0xe5, 0x52, 0x87, 0x79, 0xac, 0x0e, 0x68, 0x15, 0xca, 0xdd, + 0x43, 0xdb, 0x75, 0xc9, 0xe0, 0x91, 0xed, 0x10, 0x29, 0xa0, 0x84, 0xe3, 0x24, 0x64, 0x41, 0xa5, + 0xeb, 0x0d, 0x06, 0xa4, 0xcb, 0xa9, 0xe7, 0x36, 0x1b, 0x35, 0x73, 0xd5, 0x58, 0x37, 0x71, 0x82, + 0x26, 0xb8, 0x0c, 0x6d, 0x9f, 0x53, 0x0d, 0xc9, 0x49, 0x48, 0x9c, 0x84, 0x2e, 0x41, 0x49, 0xdc, + 0x68, 0xbb, 0x42, 0x4a, 0x5e, 0x4a, 0x29, 0x0a, 0x82, 0x14, 0xb1, 0x06, 0xd5, 0x10, 0xab, 0x10, + 0x73, 0x12, 0x31, 0x1f, 0x52, 0x05, 0xcc, 0xfa, 0xce, 0x00, 0x74, 0x87, 0x31, 0xda, 0x77, 0x13, + 0x86, 0xad, 0xc0, 0x9c, 0xeb, 0xf5, 0x48, 0xb3, 0x21, 0x2d, 0x33, 0xb1, 0x3e, 0x09, 0x91, 0x43, + 0x42, 0xfc, 0xb6, 0xef, 0x0d, 0x02, 0xc3, 0x8a, 0x82, 0x80, 0xbd, 0x01, 0x41, 0xf7, 0x60, 0x9e, + 0xc5, 0x98, 0xb0, 0x9a, 0xb9, 0x6a, 0xae, 0x97, 0xb7, 0xae, 0x6e, 0x4c, 0x24, 0xe2, 0x46, 0x5c, + 0x18, 0x4e, 0xde, 0xb2, 0x7e, 0x9b, 0x85, 0x05, 0xf9, 0xbf, 0xd2, 0xcb, 0x21, 0xae, 0x74, 0xb4, + 0x04, 0x69, 0x75, 0xd4, 0x61, 0x0a, 0x47, 0x87, 0x01, 0x32, 0xe3, 0x01, 0x1a, 0x77, 0x7f, 0x2e, + 0xdb, 0xfd, 0xf9, 0x49, 0xf7, 0x5f, 0x85, 0x32, 0x79, 0x3e, 0xa4, 0x3e, 0x69, 0x73, 0xaa, 0xdd, + 0x9b, 0xc3, 0xa0, 0x48, 0x8f, 0xa9, 0x43, 0x62, 0x39, 0x56, 0x98, 0x3a, 0xc7, 0x92, 0x41, 0x2d, + 0x66, 0x06, 0xb5, 0x94, 0x16, 0xd4, 0x1f, 0x0d, 0x58, 0x4c, 0x04, 0x55, 0x17, 0xce, 0x23, 0x38, + 0xc7, 0x92, 0x8e, 0x15, 0xd5, 0x23, 0x62, 0x64, 0x1d, 0x17, 0xa3, 0x08, 0x8a, 0x27, 0xee, 0x9e, + 0xae, 0x88, 0x9e, 0x43, 0xe5, 0xfe, 0x60, 0xc4, 0x0e, 0x4f, 0xdf, 0x50, 0x10, 0xe4, 0x7a, 0x9d, + 0x66, 0x43, 0x0a, 0x35, 0xb1, 0xfc, 0x3d, 0x4d, 0x48, 0xad, 0x9f, 0x0d, 0x40, 0xad, 0x43, 0xef, + 0x59, 0x8b, 0xf4, 0xa5, 0x41, 0xa7, 0x56, 0x60, 0x5c, 0xd8, 0x6c, 0x76, 0xfe, 0x98, 0x93, 0xf9, + 0x13, 0x98, 0x91, 0x8b, 0xcc, 0xb0, 0x3e, 0x81, 0xc5, 0x84, 0x86, 0x3a, 0x70, 0x57, 0x00, 0x98, + 0x22, 0x35, 0x1b, 0x2a, 0x64, 0x26, 0x8e, 0x51, 0x4e, 0x17, 0x88, 0x43, 0x58, 0xd2, 0x72, 0xc4, + 0x1f, 0x84, 0x9d, 0xde, 0x1f, 0x49, 0xf5, 0x66, 0xc7, 0xd5, 0xb3, 0x7e, 0x30, 0xe1, 0x5c, 0x5c, + 0x54, 0xd3, 0x3d, 0xf0, 0xd0, 0x65, 0x28, 0x85, 0x10, 0x5d, 0xd6, 0x11, 0x01, 0xfd, 0x1f, 0xf2, + 0x42, 0x4d, 0x55, 0xd4, 0xd5, 0xf1, 0xee, 0x1e, 0x18, 0x14, 0xe3, 0x89, 0x15, 0x5e, 0x54, 0x65, + 0xd7, 0x27, 0x36, 0xd7, 0x55, 0x69, 0xaa, 0xaa, 0x54, 0x24, 0x59, 0x95, 0x57, 0xa1, 0xcc, 0x88, + 0x3d, 0x20, 0x3d, 0x05, 0xc8, 0x29, 0x80, 0x22, 0x49, 0xc0, 0x35, 0xa8, 0x1c, 0x88, 0x04, 0x0d, + 0x10, 0x79, 0x89, 0x28, 0x6b, 0x9a, 0x84, 0x3c, 0x80, 0x05, 0xc6, 0x6d, 0x9f, 0xb7, 0x87, 0x1e, + 0x93, 0xe1, 0x64, 0xb5, 0xb9, 0xb4, 0x3a, 0x0a, 0xa7, 0xd0, 0x2e, 0xeb, 0xef, 0x69, 0x28, 0xae, + 0xca, 0xab, 0xc1, 0x91, 0xa1, 0x1d, 0x98, 0x27, 0x6e, 0x2f, 0xc6, 0xaa, 0x30, 0x35, 0xab, 0x0a, + 0x71, 0x7b, 0x11, 0xa3, 0x28, 0x0b, 0x8a, 0xd3, 0x67, 0xc1, 0x01, 0x20, 0xed, 0x46, 0x11, 0x95, + 0xd7, 0x97, 0x03, 0x2f, 0x0d, 0x58, 0x4c, 0x08, 0xd2, 0xa9, 0x1d, 0x29, 0x6d, 0x4c, 0xdf, 0x24, + 0xff, 0x0b, 0x79, 0xea, 0x1e, 0x78, 0x4a, 0x4e, 0x79, 0xeb, 0x4a, 0x7a, 0xf7, 0x0a, 0x65, 0x29, + 0xb0, 0xf5, 0xb5, 0x01, 0xcb, 0x63, 0x19, 0x7f, 0x16, 0x25, 0xde, 0x53, 0x97, 0x48, 0xa0, 0xc5, + 0x3f, 0x8f, 0xd7, 0x22, 0xcc, 0x7a, 0xac, 0xaf, 0x58, 0x14, 0x2e, 0x34, 0x5d, 0x46, 0x7c, 0xbe, + 0x4d, 0xdd, 0x81, 0xd7, 0xdf, 0xb3, 0xf9, 0x19, 0x1a, 0x62, 0xa2, 0x94, 0x66, 0xc7, 0x4a, 0xc9, + 0xfa, 0xd5, 0x80, 0x8b, 0xe3, 0xb2, 0x22, 0xd3, 0xeb, 0x50, 0x3c, 0xa0, 0x64, 0xd0, 0x8b, 0x1a, + 0x4b, 0x78, 0x16, 0x45, 0x38, 0x14, 0x60, 0x6d, 0xe0, 0x71, 0x2b, 0x56, 0x8b, 0xfb, 0xd4, 0xed, + 0x3f, 0xa4, 0x8c, 0x63, 0x85, 0x8f, 0xf9, 0xd3, 0x9c, 0x3e, 0x13, 0x5f, 0x1a, 0xb0, 0xa4, 0xf4, + 0xbc, 0xab, 0x26, 0xf8, 0xeb, 0x9d, 0x10, 0x29, 0x3b, 0x97, 0xe5, 0xc0, 0xf2, 0x13, 0x9b, 0x77, + 0x0f, 0x1b, 0xce, 0x99, 0x55, 0x10, 0xe2, 0xa2, 0x45, 0x44, 0xb9, 0xb0, 0x84, 0x13, 0x34, 0xeb, + 0x27, 0x03, 0x16, 0xe4, 0x2c, 0x6c, 0x91, 0xfe, 0x1b, 0x37, 0x76, 0xac, 0x62, 0x73, 0x13, 0x15, + 0xfb, 0xa7, 0x09, 0xe5, 0x58, 0x15, 0x65, 0x34, 0xec, 0x57, 0x33, 0x13, 0xd7, 0xa0, 0x4a, 0x65, + 0x0a, 0xb4, 0xb5, 0xa3, 0x64, 0x7f, 0x2e, 0xe1, 0x79, 0x1a, 0x4f, 0x0c, 0xb1, 0x24, 0x79, 0x43, + 0xe2, 0xc6, 0xfb, 0x73, 0x51, 0x10, 0xd2, 0x1a, 0xfc, 0x5c, 0x66, 0x83, 0x2f, 0x4c, 0x36, 0xf8, + 0x8b, 0x50, 0x74, 0x47, 0x4e, 0xdb, 0xf7, 0x9e, 0xa9, 0x66, 0x6a, 0xe2, 0x82, 0x3b, 0x72, 0xb0, + 0xf7, 0x8c, 0x89, 0xbf, 0x1c, 0xe2, 0xb4, 0x19, 0x3d, 0x52, 0xdb, 0x97, 0x89, 0x0b, 0x0e, 0x71, + 0x5a, 0xf4, 0x88, 0x44, 0x43, 0x0b, 0xfe, 0xe6, 0xd0, 0x6a, 0x42, 0x35, 0x39, 0x4f, 0x6a, 0xe5, + 0xa9, 0x67, 0xc0, 0x7c, 0x62, 0x9c, 0xa0, 0x7b, 0x50, 0x89, 0x4f, 0x93, 0x5a, 0x65, 0x6a, 0x46, + 0xe5, 0xd8, 0x30, 0xb1, 0x9e, 0x03, 0x68, 0x45, 0x77, 0x59, 0xff, 0x14, 0x49, 0xf9, 0x0e, 0x14, + 0x74, 0x6e, 0xe8, 0x95, 0x24, 0xab, 0x47, 0x07, 0x70, 0xeb, 0x0b, 0x03, 0x56, 0xee, 0x86, 0x59, + 0x23, 0xdc, 0xc4, 0xde, 0x7c, 0x23, 0xf8, 0xca, 0x80, 0x0b, 0x13, 0x4a, 0xe8, 0x8e, 0xa9, 0xa3, + 0x1c, 0xac, 0xce, 0xe9, 0x51, 0x7e, 0x40, 0x5e, 0x7c, 0x64, 0x0f, 0x46, 0x64, 0xcf, 0xa6, 0xbe, + 0x8a, 0xf2, 0x29, 0xb7, 0xb4, 0x5f, 0x0c, 0x58, 0xde, 0x0b, 0x2a, 0xe4, 0xed, 0x78, 0x23, 0xfb, + 0x29, 0x6a, 0x7d, 0x69, 0xc0, 0xca, 0xb8, 0x96, 0x6f, 0xc5, 0x5d, 0xbb, 0x50, 0xbd, 0x2f, 0xc6, + 0x97, 0x6c, 0xab, 0xbb, 0x84, 0xdb, 0xa8, 0x06, 0x05, 0x3d, 0xd0, 0x74, 0xd3, 0x0a, 0x8e, 0xa2, + 0x0f, 0x74, 0xe4, 0x44, 0x6c, 0x47, 0x53, 0xae, 0x84, 0xcb, 0x9d, 0x68, 0x4a, 0x5a, 0xdf, 0x18, + 0xe1, 0xe6, 0x1a, 0x71, 0x3c, 0xb9, 0x11, 0xfe, 0x03, 0x80, 0xb2, 0xb6, 0x6e, 0x26, 0x52, 0xf5, + 0x22, 0x2e, 0x51, 0x76, 0x5f, 0x11, 0xd0, 0xbb, 0x30, 0x27, 0xe5, 0xb3, 0x5a, 0x3e, 0xcd, 0x1f, + 0xb2, 0x2e, 0x92, 0x16, 0x60, 0x7d, 0xc1, 0xfa, 0x10, 0x2a, 0x8d, 0xc6, 0xc3, 0x48, 0x8f, 0xf1, + 0xd0, 0x19, 0x29, 0xa1, 0x9b, 0xc2, 0xc6, 0x64, 0xc1, 0xdd, 0x15, 0x2f, 0xe4, 0x37, 0x5f, 0x70, + 0xbd, 0x78, 0xbd, 0x69, 0x1d, 0xce, 0xb2, 0x9c, 0x85, 0x0f, 0x7f, 0xa5, 0x88, 0x3a, 0x6c, 0xfd, + 0x51, 0x86, 0x72, 0xc3, 0xe6, 0x76, 0x4b, 0x7d, 0x28, 0x43, 0x36, 0x54, 0xe2, 0x5f, 0x98, 0xd0, + 0xf5, 0x94, 0x60, 0xa4, 0x7c, 0x04, 0xab, 0xdf, 0xc8, 0xc4, 0x29, 0xdd, 0xad, 0x19, 0xb4, 0x03, + 0x79, 0x19, 0x31, 0x94, 0xf6, 0x19, 0x24, 0xfe, 0x10, 0xae, 0x9f, 0x64, 0x97, 0x35, 0x83, 0x3a, + 0xb0, 0x10, 0xbe, 0xe9, 0x75, 0xaa, 0xad, 0xa5, 0xb0, 0x9c, 0xfc, 0x98, 0x53, 0xbf, 0x9e, 0x05, + 0x0b, 0x95, 0x6d, 0x43, 0x25, 0xf6, 0xfc, 0x64, 0xa9, 0x02, 0x26, 0x5f, 0xd0, 0xa9, 0x02, 0x52, + 0x9e, 0xb1, 0xd6, 0x0c, 0xb2, 0xa1, 0xba, 0x43, 0x78, 0x7c, 0xab, 0x58, 0xcb, 0x98, 0x0b, 0x27, + 0x89, 0x98, 0x7c, 0x4e, 0x58, 0x33, 0xa8, 0x0f, 0xe7, 0x22, 0x11, 0x6a, 0xcf, 0x47, 0x37, 0x32, + 0x56, 0xf3, 0xa0, 0xa7, 0xd6, 0xd7, 0xb3, 0x81, 0xa1, 0x20, 0x1f, 0x96, 0x76, 0x08, 0x9f, 0xd8, + 0xac, 0xd1, 0xad, 0x14, 0x1e, 0xc7, 0xec, 0xfa, 0xf5, 0x7f, 0x4d, 0x81, 0x65, 0x09, 0xff, 0x9d, + 0x0f, 0x65, 0xea, 0x65, 0x28, 0xdd, 0xba, 0xb4, 0x45, 0xba, 0x9e, 0xbd, 0xc0, 0x4b, 0xb3, 0x2e, + 0xec, 0x10, 0x9e, 0x1c, 0x7e, 0x94, 0x71, 0xda, 0x65, 0xe8, 0x66, 0x8a, 0xa0, 0xf4, 0x51, 0x5d, + 0xbf, 0x35, 0x0d, 0x34, 0x34, 0xcb, 0x83, 0x95, 0x1d, 0xc2, 0x13, 0x03, 0x44, 0x8b, 0x4c, 0x0b, + 0x48, 0xea, 0x38, 0xac, 0xdf, 0x9c, 0x02, 0x19, 0x0a, 0xdc, 0x07, 0x24, 0x8d, 0x74, 0x86, 0x9e, + 0x1b, 0xa5, 0x49, 0x3d, 0xb5, 0x02, 0xef, 0x39, 0x43, 0xfe, 0x62, 0x3c, 0x01, 0x43, 0xdf, 0x8d, + 0xf1, 0xb0, 0x66, 0xd0, 0x13, 0xc9, 0x5b, 0xac, 0x91, 0x8f, 0x69, 0xf7, 0xd3, 0x60, 0x65, 0x3d, + 0x89, 0xf7, 0xd8, 0xcb, 0x51, 0x1f, 0x54, 0x54, 0x62, 0x4a, 0x7f, 0x2c, 0x13, 0x2e, 0x72, 0xce, + 0x2b, 0x64, 0xbd, 0x0f, 0xcb, 0xc9, 0xba, 0x7c, 0x85, 0xbc, 0xbb, 0x50, 0x94, 0xbe, 0x1e, 0xb9, + 0x3c, 0x23, 0x83, 0xe2, 0xb3, 0x27, 0x23, 0x83, 0x12, 0x23, 0xc2, 0x9a, 0xd9, 0xfa, 0x7e, 0x16, + 0x8a, 0xa2, 0xb3, 0xcb, 0x36, 0xfe, 0x3a, 0xa3, 0xbb, 0x0f, 0x0b, 0xc9, 0x27, 0x62, 0x7a, 0x8e, + 0xa6, 0x3e, 0x23, 0xb3, 0x5a, 0x3c, 0x86, 0xf9, 0xe0, 0x39, 0xa8, 0xfa, 0xaf, 0x75, 0xdc, 0xcc, + 0x88, 0x1e, 0x8c, 0x19, 0x3c, 0xb7, 0x3f, 0xd8, 0x7f, 0xbf, 0x4f, 0xf9, 0xe1, 0xa8, 0x23, 0xfe, + 0xd9, 0x3c, 0xa2, 0x83, 0x01, 0x3d, 0xe2, 0xa4, 0x7b, 0xb8, 0xa9, 0x6e, 0xfd, 0xbb, 0x47, 0x19, + 0xf7, 0x69, 0x67, 0xc4, 0x49, 0x6f, 0x33, 0x30, 0x7b, 0x53, 0xb2, 0xda, 0x14, 0xe2, 0x86, 0x9d, + 0xce, 0x9c, 0x3c, 0xdd, 0xfe, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xac, 0x3c, 0x2b, 0xea, 0x64, 0x1a, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1853,6 +1914,7 @@ type DataServiceClient interface { Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error) AssignSegmentID(ctx context.Context, in *AssignSegIDRequest, opts ...grpc.CallOption) (*AssignSegIDResponse, error) ShowSegments(ctx context.Context, in *ShowSegmentRequest, opts ...grpc.CallOption) (*ShowSegmentResponse, error) + GetSegmentInfo(ctx context.Context, in *SegmentInfoRequest, opts ...grpc.CallOption) (*SegmentInfoResponse, error) GetSegmentStates(ctx context.Context, in *SegmentStatesRequest, opts ...grpc.CallOption) (*SegmentStatesResponse, error) GetInsertBinlogPaths(ctx context.Context, in *InsertBinlogPathRequest, opts ...grpc.CallOption) (*InsertBinlogPathsResponse, error) GetInsertChannels(ctx context.Context, in *InsertChannelRequest, opts ...grpc.CallOption) (*internalpb2.StringList, error) @@ -1909,6 +1971,15 @@ func (c *dataServiceClient) ShowSegments(ctx context.Context, in *ShowSegmentReq return out, nil } +func (c *dataServiceClient) GetSegmentInfo(ctx context.Context, in *SegmentInfoRequest, opts ...grpc.CallOption) (*SegmentInfoResponse, error) { + out := new(SegmentInfoResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/GetSegmentInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *dataServiceClient) GetSegmentStates(ctx context.Context, in *SegmentStatesRequest, opts ...grpc.CallOption) (*SegmentStatesResponse, error) { out := new(SegmentStatesResponse) err := c.cc.Invoke(ctx, "/milvus.proto.data.DataService/GetSegmentStates", in, out, opts...) @@ -2005,6 +2076,7 @@ type DataServiceServer interface { Flush(context.Context, *FlushRequest) (*commonpb.Status, error) AssignSegmentID(context.Context, *AssignSegIDRequest) (*AssignSegIDResponse, error) ShowSegments(context.Context, *ShowSegmentRequest) (*ShowSegmentResponse, error) + GetSegmentInfo(context.Context, *SegmentInfoRequest) (*SegmentInfoResponse, error) GetSegmentStates(context.Context, *SegmentStatesRequest) (*SegmentStatesResponse, error) GetInsertBinlogPaths(context.Context, *InsertBinlogPathRequest) (*InsertBinlogPathsResponse, error) GetInsertChannels(context.Context, *InsertChannelRequest) (*internalpb2.StringList, error) @@ -2033,6 +2105,9 @@ func (*UnimplementedDataServiceServer) AssignSegmentID(ctx context.Context, req func (*UnimplementedDataServiceServer) ShowSegments(ctx context.Context, req *ShowSegmentRequest) (*ShowSegmentResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ShowSegments not implemented") } +func (*UnimplementedDataServiceServer) GetSegmentInfo(ctx context.Context, req *SegmentInfoRequest) (*SegmentInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetSegmentInfo not implemented") +} func (*UnimplementedDataServiceServer) GetSegmentStates(ctx context.Context, req *SegmentStatesRequest) (*SegmentStatesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSegmentStates not implemented") } @@ -2140,6 +2215,24 @@ func _DataService_ShowSegments_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _DataService_GetSegmentInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SegmentInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DataServiceServer).GetSegmentInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.data.DataService/GetSegmentInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DataServiceServer).GetSegmentInfo(ctx, req.(*SegmentInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _DataService_GetSegmentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SegmentStatesRequest) if err := dec(in); err != nil { @@ -2340,6 +2433,10 @@ var _DataService_serviceDesc = grpc.ServiceDesc{ MethodName: "ShowSegments", Handler: _DataService_ShowSegments_Handler, }, + { + MethodName: "GetSegmentInfo", + Handler: _DataService_GetSegmentInfo_Handler, + }, { MethodName: "GetSegmentStates", Handler: _DataService_GetSegmentStates_Handler, diff --git a/internal/proto/milvus.proto b/internal/proto/milvus.proto index 33a4cbbab9..9077a8a860 100644 --- a/internal/proto/milvus.proto +++ b/internal/proto/milvus.proto @@ -266,6 +266,30 @@ message FlushRequest { repeated string collection_names = 3; } + +message PersistentSegmentInfo { + int64 segmentID = 1; + int64 collectionID = 2; + int64 partitionID = 3; + uint64 open_time = 4; + uint64 sealed_time = 5; + uint64 flushed_time = 6; + int64 num_rows = 7; + int64 mem_size = 8; + common.SegmentState state = 9; +} + +message PersistentSegmentInfoRequest { + common.MsgBase base = 1; + string dbName = 2; + string collectionName = 3; +} + +message PersistentSegmentInfoResponse { + common.Status status = 1; + repeated PersistentSegmentInfo infos = 2; +} + service MilvusService { rpc CreateCollection(CreateCollectionRequest) returns (common.Status) {} rpc DropCollection(DropCollectionRequest) returns (common.Status) {} @@ -293,6 +317,9 @@ service MilvusService { rpc Flush(FlushRequest) returns (common.Status) {} rpc GetDdChannel(common.Empty) returns (StringResponse) {} + + rpc GetPersistentSegmentInfo(PersistentSegmentInfoRequest) returns (PersistentSegmentInfoResponse) {} + } message RegisterLinkResponse { diff --git a/internal/proto/milvuspb/milvus.pb.go b/internal/proto/milvuspb/milvus.pb.go index 66fca8c54d..3dec54bc2f 100644 --- a/internal/proto/milvuspb/milvus.pb.go +++ b/internal/proto/milvuspb/milvus.pb.go @@ -2313,6 +2313,211 @@ func (m *FlushRequest) GetCollectionNames() []string { 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"` + PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + OpenTime uint64 `protobuf:"varint,4,opt,name=open_time,json=openTime,proto3" json:"open_time,omitempty"` + SealedTime uint64 `protobuf:"varint,5,opt,name=sealed_time,json=sealedTime,proto3" json:"sealed_time,omitempty"` + FlushedTime uint64 `protobuf:"varint,6,opt,name=flushed_time,json=flushedTime,proto3" json:"flushed_time,omitempty"` + NumRows int64 `protobuf:"varint,7,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"` + MemSize int64 `protobuf:"varint,8,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"` + State commonpb.SegmentState `protobuf:"varint,9,opt,name=state,proto3,enum=milvus.proto.common.SegmentState" json:"state,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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{40} +} + +func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PersistentSegmentInfo.Unmarshal(m, b) +} +func (m *PersistentSegmentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PersistentSegmentInfo.Marshal(b, m, deterministic) +} +func (m *PersistentSegmentInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_PersistentSegmentInfo.Merge(m, src) +} +func (m *PersistentSegmentInfo) XXX_Size() int { + return xxx_messageInfo_PersistentSegmentInfo.Size(m) +} +func (m *PersistentSegmentInfo) XXX_DiscardUnknown() { + xxx_messageInfo_PersistentSegmentInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_PersistentSegmentInfo proto.InternalMessageInfo + +func (m *PersistentSegmentInfo) GetSegmentID() int64 { + if m != nil { + return m.SegmentID + } + return 0 +} + +func (m *PersistentSegmentInfo) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *PersistentSegmentInfo) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *PersistentSegmentInfo) GetOpenTime() uint64 { + if m != nil { + return m.OpenTime + } + return 0 +} + +func (m *PersistentSegmentInfo) GetSealedTime() uint64 { + if m != nil { + return m.SealedTime + } + return 0 +} + +func (m *PersistentSegmentInfo) GetFlushedTime() uint64 { + if m != nil { + return m.FlushedTime + } + return 0 +} + +func (m *PersistentSegmentInfo) GetNumRows() int64 { + if m != nil { + return m.NumRows + } + return 0 +} + +func (m *PersistentSegmentInfo) GetMemSize() int64 { + if m != nil { + return m.MemSize + } + return 0 +} + +func (m *PersistentSegmentInfo) GetState() commonpb.SegmentState { + if m != nil { + return m.State + } + return commonpb.SegmentState_SegmentNone +} + +type PersistentSegmentInfoRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + DbName string `protobuf:"bytes,2,opt,name=dbName,proto3" json:"dbName,omitempty"` + CollectionName string `protobuf:"bytes,3,opt,name=collectionName,proto3" json:"collectionName,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PersistentSegmentInfoRequest) Reset() { *m = PersistentSegmentInfoRequest{} } +func (m *PersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) } +func (*PersistentSegmentInfoRequest) ProtoMessage() {} +func (*PersistentSegmentInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_02345ba45cc0e303, []int{41} +} + +func (m *PersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PersistentSegmentInfoRequest.Unmarshal(m, b) +} +func (m *PersistentSegmentInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PersistentSegmentInfoRequest.Marshal(b, m, deterministic) +} +func (m *PersistentSegmentInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PersistentSegmentInfoRequest.Merge(m, src) +} +func (m *PersistentSegmentInfoRequest) XXX_Size() int { + return xxx_messageInfo_PersistentSegmentInfoRequest.Size(m) +} +func (m *PersistentSegmentInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PersistentSegmentInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_PersistentSegmentInfoRequest proto.InternalMessageInfo + +func (m *PersistentSegmentInfoRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + +func (m *PersistentSegmentInfoRequest) GetDbName() string { + if m != nil { + return m.DbName + } + return "" +} + +func (m *PersistentSegmentInfoRequest) GetCollectionName() string { + if m != nil { + return m.CollectionName + } + return "" +} + +type PersistentSegmentInfoResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Infos []*PersistentSegmentInfo `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PersistentSegmentInfoResponse) Reset() { *m = PersistentSegmentInfoResponse{} } +func (m *PersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) } +func (*PersistentSegmentInfoResponse) ProtoMessage() {} +func (*PersistentSegmentInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_02345ba45cc0e303, []int{42} +} + +func (m *PersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_PersistentSegmentInfoResponse.Unmarshal(m, b) +} +func (m *PersistentSegmentInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_PersistentSegmentInfoResponse.Marshal(b, m, deterministic) +} +func (m *PersistentSegmentInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PersistentSegmentInfoResponse.Merge(m, src) +} +func (m *PersistentSegmentInfoResponse) XXX_Size() int { + return xxx_messageInfo_PersistentSegmentInfoResponse.Size(m) +} +func (m *PersistentSegmentInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PersistentSegmentInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_PersistentSegmentInfoResponse proto.InternalMessageInfo + +func (m *PersistentSegmentInfoResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *PersistentSegmentInfoResponse) GetInfos() []*PersistentSegmentInfo { + if m != nil { + return m.Infos + } + return nil +} + type RegisterLinkResponse struct { Address *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` @@ -2325,7 +2530,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{40} + return fileDescriptor_02345ba45cc0e303, []int{43} } func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error { @@ -2402,119 +2607,134 @@ 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((*PersistentSegmentInfo)(nil), "milvus.proto.milvus.PersistentSegmentInfo") + proto.RegisterType((*PersistentSegmentInfoRequest)(nil), "milvus.proto.milvus.PersistentSegmentInfoRequest") + proto.RegisterType((*PersistentSegmentInfoResponse)(nil), "milvus.proto.milvus.PersistentSegmentInfoResponse") proto.RegisterType((*RegisterLinkResponse)(nil), "milvus.proto.milvus.RegisterLinkResponse") } func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) } var fileDescriptor_02345ba45cc0e303 = []byte{ - // 1685 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0xdb, 0x46, - 0x12, 0x37, 0x25, 0x59, 0xb6, 0xc7, 0x94, 0x2c, 0xaf, 0xbf, 0x14, 0x25, 0xb9, 0x38, 0x7b, 0x97, - 0xb3, 0xf3, 0x65, 0x1f, 0x9c, 0xfb, 0x7c, 0x38, 0x20, 0xb1, 0xe5, 0x38, 0x42, 0x12, 0xc7, 0x47, - 0xf9, 0x72, 0xe7, 0x0b, 0x02, 0x1d, 0x25, 0xee, 0x49, 0xbc, 0x50, 0xa4, 0xca, 0x5d, 0xf9, 0x23, - 0x4f, 0x45, 0x53, 0xb4, 0x40, 0x5b, 0xb4, 0xcf, 0x7d, 0x2d, 0xd0, 0xd7, 0xa2, 0x4d, 0x8b, 0xfe, - 0x07, 0x05, 0xfa, 0xbf, 0x14, 0x45, 0xff, 0x82, 0x02, 0x05, 0x97, 0x14, 0x45, 0xd2, 0x4b, 0x4b, - 0x8d, 0x9a, 0x5a, 0x7e, 0xd3, 0x8e, 0x66, 0x67, 0x7f, 0xfb, 0x9b, 0x99, 0xdd, 0xd9, 0x21, 0xc8, - 0x4d, 0xdd, 0xd8, 0x6f, 0xd3, 0x95, 0x96, 0x6d, 0x31, 0x0b, 0xcd, 0x04, 0x47, 0x2b, 0xee, 0xa0, - 0x20, 0xd7, 0xac, 0x66, 0xd3, 0x32, 0x5d, 0x61, 0x41, 0xa6, 0xb5, 0x06, 0x69, 0xaa, 0xee, 0x08, - 0x7f, 0x2a, 0xc1, 0xc2, 0x86, 0x4d, 0x54, 0x46, 0x36, 0x2c, 0xc3, 0x20, 0x35, 0xa6, 0x5b, 0xa6, - 0x42, 0xde, 0x68, 0x13, 0xca, 0xd0, 0x1f, 0x20, 0x55, 0x55, 0x29, 0xc9, 0x4b, 0x8b, 0xd2, 0xf2, - 0xe4, 0xda, 0x85, 0x95, 0x90, 0x6d, 0xcf, 0xe6, 0x43, 0x5a, 0x5f, 0x57, 0x29, 0x51, 0xb8, 0x26, - 0x5a, 0x80, 0x31, 0xad, 0x5a, 0x31, 0xd5, 0x26, 0xc9, 0x27, 0x16, 0xa5, 0xe5, 0x09, 0x25, 0xad, - 0x55, 0xb7, 0xd5, 0x26, 0x41, 0x4b, 0x30, 0x55, 0xf3, 0xed, 0xbb, 0x0a, 0x49, 0xae, 0x90, 0xed, - 0x8a, 0xb9, 0xe2, 0x3c, 0xa4, 0x5d, 0x7c, 0xf9, 0xd4, 0xa2, 0xb4, 0x2c, 0x2b, 0xde, 0x08, 0xbf, - 0x2f, 0xc1, 0x5c, 0xd1, 0xb6, 0x5a, 0x43, 0x81, 0x12, 0xbf, 0x27, 0xc1, 0xec, 0x3d, 0x95, 0x0e, - 0x07, 0x98, 0x3d, 0x90, 0xd7, 0x2d, 0xcb, 0x50, 0x08, 0x6d, 0x59, 0x26, 0x25, 0xe8, 0x16, 0xa4, - 0x29, 0x53, 0x59, 0x9b, 0x7a, 0x28, 0xce, 0x0b, 0x51, 0x94, 0xb9, 0x8a, 0xe2, 0xa9, 0xa2, 0x59, - 0x18, 0xdd, 0x57, 0x8d, 0xb6, 0x0b, 0x62, 0x5c, 0x71, 0x07, 0xf8, 0x09, 0x64, 0xcb, 0xcc, 0xd6, - 0xcd, 0xfa, 0x2f, 0x68, 0x7c, 0xa2, 0x63, 0xfc, 0x23, 0x09, 0xce, 0x15, 0x09, 0xad, 0xd9, 0x7a, - 0x75, 0x38, 0x82, 0x0f, 0x7f, 0x25, 0x41, 0x41, 0x84, 0x68, 0x90, 0xbd, 0xff, 0xdd, 0x0f, 0xe8, - 0x04, 0x9f, 0x74, 0x25, 0x3c, 0xc9, 0x4b, 0xc6, 0xee, 0x6a, 0x65, 0x2e, 0xe8, 0xc4, 0x3d, 0xc2, - 0x20, 0x77, 0x41, 0x96, 0x8a, 0x1c, 0x78, 0x52, 0x09, 0xc9, 0x78, 0x6e, 0x3c, 0xb0, 0x54, 0x6d, - 0x38, 0x48, 0xfc, 0x50, 0x82, 0xbc, 0x42, 0x0c, 0xa2, 0xd2, 0x21, 0xf1, 0xea, 0x07, 0x12, 0xcc, - 0x07, 0xf8, 0x65, 0x2a, 0xa3, 0xa7, 0x09, 0xe7, 0x5d, 0xe7, 0xc4, 0x8d, 0xc2, 0x19, 0x24, 0xc2, - 0xfe, 0x02, 0xa3, 0xce, 0x2f, 0x9a, 0x4f, 0x2c, 0x26, 0x97, 0x27, 0xd7, 0x2e, 0x0b, 0xe7, 0xdc, - 0x27, 0x47, 0x8f, 0x9d, 0xac, 0xdb, 0x51, 0x75, 0x5b, 0x71, 0xf5, 0x71, 0x15, 0xe6, 0xca, 0x0d, - 0xeb, 0xe0, 0x75, 0x7a, 0x09, 0x1f, 0xc2, 0x7c, 0x74, 0x8d, 0x41, 0xf6, 0x7a, 0x15, 0x72, 0x11, - 0x96, 0xdd, 0x6d, 0x4f, 0x28, 0x53, 0x61, 0x9a, 0x29, 0xfe, 0xd2, 0x71, 0x3b, 0xbf, 0xd9, 0x76, - 0x54, 0x9b, 0xe9, 0xa7, 0x7d, 0xb1, 0x5d, 0x81, 0x6c, 0xab, 0x83, 0xc3, 0xd5, 0x4b, 0x71, 0xbd, - 0x8c, 0x2f, 0xe5, 0x7c, 0x7d, 0x21, 0xc1, 0xac, 0x73, 0xcf, 0x9d, 0x25, 0xcc, 0x9f, 0x4b, 0x30, - 0x73, 0x4f, 0xa5, 0x67, 0x09, 0xf2, 0x4b, 0x09, 0x66, 0x9c, 0x23, 0xd3, 0xc5, 0x7c, 0xba, 0x90, - 0x97, 0x60, 0x2a, 0x0c, 0x99, 0xe6, 0x53, 0x3c, 0xa4, 0xb3, 0x21, 0xcc, 0x14, 0x7f, 0x2d, 0xc1, - 0x82, 0x77, 0xb2, 0x0e, 0x05, 0xd7, 0x7d, 0x03, 0x7f, 0x29, 0xc1, 0x9c, 0x8f, 0xf8, 0xb4, 0x0f, - 0xe0, 0x7e, 0x43, 0xe4, 0x1d, 0x09, 0xe6, 0xa3, 0xa0, 0x4f, 0xe5, 0x98, 0xfe, 0x4c, 0x82, 0x59, - 0xe7, 0x0c, 0x1d, 0x0a, 0x9f, 0x47, 0xeb, 0x91, 0x94, 0xa0, 0x1e, 0xf9, 0x58, 0x72, 0x2f, 0x96, - 0x00, 0xe0, 0x41, 0x88, 0x13, 0x84, 0x59, 0x42, 0x14, 0x66, 0x0e, 0x36, 0x5f, 0x52, 0x2a, 0xd2, - 0x7c, 0x72, 0x31, 0xe9, 0x60, 0x0b, 0xca, 0x78, 0x31, 0xd0, 0x29, 0xf1, 0xca, 0xa4, 0xde, 0x24, - 0x26, 0x7b, 0x75, 0x3a, 0xa3, 0x64, 0x24, 0x8e, 0x93, 0x81, 0x2e, 0xc0, 0x04, 0x75, 0xd7, 0xf1, - 0xab, 0xb7, 0xae, 0x00, 0xbf, 0x25, 0xc1, 0xc2, 0x31, 0x38, 0x83, 0x90, 0x95, 0x87, 0x31, 0xdd, - 0xd4, 0xc8, 0xa1, 0x8f, 0xa6, 0x33, 0x74, 0xfe, 0xa9, 0xb6, 0x75, 0x43, 0xf3, 0x61, 0x74, 0x86, - 0x0e, 0x27, 0xc8, 0xf1, 0xd7, 0xaf, 0xc2, 0xc7, 0x22, 0x4c, 0x06, 0x1c, 0xe2, 0x41, 0x09, 0x8a, - 0xf0, 0xff, 0x61, 0x26, 0x84, 0x66, 0x10, 0x3a, 0x7e, 0x03, 0xe0, 0x93, 0xed, 0x86, 0x4d, 0x52, - 0x09, 0x48, 0xf0, 0xf7, 0x12, 0x20, 0xb7, 0x48, 0x28, 0x39, 0x34, 0x9d, 0x66, 0x66, 0x5d, 0x04, - 0xf8, 0x9f, 0x4e, 0x0c, 0x2d, 0x78, 0x24, 0x4d, 0x70, 0x09, 0xff, 0xbb, 0x08, 0x32, 0x39, 0x64, - 0xb6, 0x5a, 0x69, 0xa9, 0xb6, 0xda, 0xa4, 0xf9, 0xd1, 0x7e, 0x4f, 0x91, 0x49, 0x3e, 0x6d, 0x87, - 0xcf, 0xc2, 0xdf, 0x3a, 0xe5, 0x85, 0x17, 0x6f, 0xc3, 0xbe, 0xe3, 0x8b, 0x00, 0x3c, 0x76, 0xdd, - 0xbf, 0x47, 0xdd, 0xbf, 0xb9, 0x84, 0x9f, 0xcf, 0x06, 0xe4, 0xf8, 0x0e, 0xdc, 0xed, 0xb4, 0x1c, - 0xab, 0x91, 0x29, 0x52, 0x64, 0x0a, 0xfa, 0x1b, 0xa4, 0x3d, 0xf6, 0xfa, 0x3e, 0x83, 0xbd, 0x09, - 0xf8, 0x13, 0x09, 0xe6, 0x22, 0xc4, 0x0d, 0x12, 0x97, 0xbb, 0x80, 0x5c, 0xa0, 0x5a, 0x17, 0x7d, - 0x07, 0x55, 0xe4, 0x85, 0xe8, 0x0d, 0xa2, 0x7b, 0x55, 0xa6, 0xf5, 0x88, 0x84, 0xe2, 0x6f, 0x24, - 0x98, 0xe6, 0x7a, 0xce, 0x6a, 0xe4, 0xec, 0xba, 0xf6, 0x4d, 0x09, 0x50, 0x70, 0x1f, 0x83, 0x30, - 0xfd, 0x27, 0xf7, 0xda, 0x75, 0x77, 0x92, 0x5d, 0xbb, 0x24, 0x9c, 0x13, 0x58, 0xcc, 0xd5, 0xc6, - 0x3f, 0x4a, 0x90, 0x29, 0x99, 0x94, 0xd8, 0x6c, 0xf8, 0x4b, 0x15, 0xf4, 0x47, 0x18, 0xb7, 0xad, - 0x83, 0x8a, 0xa6, 0x32, 0xd5, 0x3b, 0x17, 0xce, 0x09, 0xe1, 0xad, 0x1b, 0x56, 0x55, 0x19, 0xb3, - 0xad, 0x83, 0xa2, 0xca, 0x54, 0x74, 0x1e, 0x26, 0x1a, 0x2a, 0x6d, 0x54, 0x9e, 0x91, 0x23, 0x9a, - 0x4f, 0x2f, 0x26, 0x97, 0x33, 0xca, 0xb8, 0x23, 0xb8, 0x4f, 0x8e, 0x28, 0x7e, 0x21, 0x41, 0xb6, - 0xb3, 0xff, 0x41, 0xe8, 0xbf, 0x04, 0x93, 0xb6, 0x75, 0x50, 0x2a, 0x56, 0xaa, 0xa4, 0xae, 0x9b, - 0xde, 0x8d, 0x00, 0x5c, 0xb4, 0xee, 0x48, 0x1c, 0x14, 0xae, 0x02, 0x31, 0x35, 0xef, 0x36, 0x18, - 0xe7, 0x82, 0x4d, 0x53, 0xc3, 0xfb, 0x90, 0xdb, 0x31, 0xd4, 0x1a, 0x69, 0x58, 0x86, 0x46, 0x6c, - 0x9e, 0x95, 0x28, 0x07, 0x49, 0xa6, 0xd6, 0xbd, 0xe4, 0x76, 0x7e, 0xa2, 0xbf, 0x42, 0x8a, 0x1d, - 0xb5, 0x3a, 0x1e, 0xfe, 0x9d, 0x30, 0x7d, 0x02, 0x66, 0x76, 0x8f, 0x5a, 0x44, 0xe1, 0x33, 0xd0, - 0x3c, 0xa4, 0x79, 0x2f, 0xca, 0xad, 0x15, 0x64, 0xc5, 0x1b, 0xe1, 0xa7, 0xa1, 0x75, 0xb7, 0x6c, - 0xab, 0xdd, 0x42, 0x25, 0x90, 0x5b, 0x5d, 0x99, 0x43, 0x42, 0x7c, 0xb2, 0x46, 0x41, 0x2b, 0xa1, - 0xa9, 0xf8, 0x3b, 0x09, 0x32, 0x65, 0xa2, 0xda, 0xb5, 0xc6, 0x59, 0x28, 0xdf, 0x1d, 0xc6, 0x35, - 0x6a, 0x78, 0x69, 0xea, 0xfc, 0x44, 0xd7, 0x61, 0x3a, 0xb0, 0xa1, 0x4a, 0xdd, 0x21, 0x28, 0x9f, - 0xe6, 0x0d, 0xdb, 0x5c, 0x2b, 0x42, 0x1c, 0xbe, 0x0f, 0xa9, 0x7b, 0x3a, 0xe3, 0x66, 0x9c, 0x4b, - 0x58, 0xe2, 0x97, 0xb0, 0xf3, 0x13, 0x9d, 0x0b, 0xc4, 0x6d, 0x82, 0x3b, 0xc0, 0x0f, 0x4e, 0xde, - 0x07, 0xb6, 0x6c, 0xcf, 0x33, 0x09, 0xc5, 0x1b, 0xe1, 0x7f, 0x77, 0x99, 0xa3, 0x6d, 0x83, 0xd1, - 0x57, 0x8b, 0x4a, 0x04, 0xa9, 0x86, 0xee, 0x95, 0xe2, 0xb2, 0xc2, 0x7f, 0xe3, 0xb7, 0x25, 0x90, - 0xef, 0x1a, 0x6d, 0xfa, 0x3a, 0x7c, 0x22, 0x6a, 0x5b, 0x24, 0xc5, 0x6d, 0x8b, 0x17, 0x12, 0xcc, - 0x2a, 0xa4, 0xae, 0x53, 0x46, 0xec, 0x07, 0xba, 0xf9, 0xcc, 0x4f, 0xbf, 0x3f, 0xc3, 0x98, 0xaa, - 0x69, 0x36, 0xa1, 0xf4, 0x44, 0x44, 0x77, 0x5c, 0x1d, 0xa5, 0xa3, 0x1c, 0x20, 0x28, 0xd1, 0x37, - 0x41, 0xd7, 0x6e, 0xc3, 0x54, 0x24, 0x63, 0xd0, 0x38, 0xa4, 0xb6, 0x1f, 0x6d, 0x6f, 0xe6, 0x46, - 0xd0, 0x34, 0x64, 0x1e, 0x6f, 0x6e, 0xec, 0x3e, 0x52, 0x2a, 0xeb, 0xa5, 0xed, 0x3b, 0xca, 0x5e, - 0x4e, 0x43, 0x39, 0x90, 0x3d, 0xd1, 0xdd, 0x07, 0x8f, 0xee, 0xec, 0xe6, 0xc8, 0xda, 0x0f, 0x39, - 0xc8, 0x3c, 0xe4, 0x0b, 0x95, 0x89, 0xbd, 0xaf, 0xd7, 0x08, 0xaa, 0x40, 0x2e, 0xfa, 0xa5, 0x01, - 0xdd, 0x10, 0xa6, 0x4f, 0xcc, 0x07, 0x89, 0xc2, 0x49, 0xd0, 0xf1, 0x08, 0x7a, 0x02, 0xd9, 0xf0, - 0x27, 0x02, 0x74, 0x4d, 0x68, 0x5e, 0xf8, 0x1d, 0xa1, 0x97, 0xf1, 0x0a, 0x64, 0x42, 0x1d, 0x7f, - 0x74, 0x55, 0x68, 0x5b, 0xf4, 0x55, 0xa0, 0x70, 0x59, 0xa8, 0x1a, 0x6c, 0xda, 0xbb, 0xe8, 0xc3, - 0x4d, 0xdc, 0x18, 0xf4, 0xc2, 0x4e, 0x6f, 0x2f, 0xf4, 0x2a, 0x4c, 0x1f, 0xeb, 0xc9, 0xa2, 0x9b, - 0x42, 0xfb, 0x71, 0xbd, 0xdb, 0x5e, 0x4b, 0x1c, 0x00, 0x3a, 0xde, 0x3b, 0x47, 0x2b, 0x62, 0x0f, - 0xc4, 0xb5, 0xfd, 0x0b, 0xab, 0x7d, 0xeb, 0xfb, 0xc4, 0xed, 0xc3, 0xc2, 0x16, 0x61, 0xe1, 0x96, - 0xaa, 0x4e, 0x99, 0x5e, 0xa3, 0xe8, 0xba, 0x38, 0xbc, 0x84, 0xcd, 0xe0, 0xc2, 0x8d, 0xfe, 0x94, - 0xfd, 0x75, 0x0d, 0x98, 0x0a, 0xb7, 0x36, 0x69, 0x8c, 0xc7, 0x84, 0x4d, 0xd6, 0xc2, 0xf5, 0xbe, - 0x74, 0xfd, 0xd5, 0x9e, 0xc2, 0x54, 0xa4, 0x9b, 0x19, 0xb7, 0x3b, 0x61, 0xcf, 0xb3, 0x97, 0xf7, - 0xf6, 0x20, 0x13, 0x6a, 0x3b, 0xc6, 0x84, 0xb7, 0xa8, 0x35, 0xd9, 0xcb, 0xf4, 0x53, 0x90, 0x83, - 0xdd, 0x41, 0xb4, 0x1c, 0x97, 0x38, 0xc7, 0x0c, 0xf7, 0x95, 0x37, 0x7b, 0x6e, 0xde, 0xf8, 0x93, - 0x69, 0xcc, 0x02, 0x82, 0x76, 0x5f, 0x2f, 0xe4, 0xff, 0xf5, 0xb3, 0x26, 0x60, 0xfd, 0xc6, 0x49, - 0x59, 0xf3, 0x73, 0xb9, 0xa1, 0x30, 0xbf, 0x45, 0x58, 0xa8, 0xcd, 0xe4, 0x85, 0xae, 0x38, 0x94, - 0x84, 0x5d, 0xb4, 0x98, 0x50, 0x12, 0x37, 0xaf, 0xf0, 0x08, 0xd2, 0x21, 0x1b, 0x6a, 0xcf, 0xd0, - 0x18, 0x67, 0x8b, 0x9a, 0x4e, 0x85, 0x6b, 0xfd, 0xa8, 0xfa, 0x4b, 0xfd, 0x13, 0x26, 0x03, 0xcf, - 0x6b, 0xb4, 0x74, 0x42, 0xc4, 0x06, 0x9f, 0xa3, 0xbd, 0x68, 0x6b, 0x40, 0x26, 0xf4, 0x18, 0x8b, - 0x8b, 0x56, 0xc1, 0x4b, 0x37, 0x66, 0x03, 0xc2, 0xb7, 0x1d, 0x1e, 0x41, 0x55, 0xc8, 0x6c, 0x11, - 0xd6, 0x7d, 0x1f, 0xa0, 0xdf, 0xc7, 0xbf, 0xce, 0x82, 0xaf, 0xae, 0xc2, 0x52, 0x4f, 0x3d, 0x7f, - 0x8d, 0x32, 0xa4, 0xdd, 0x52, 0x1b, 0xe1, 0x98, 0x49, 0x81, 0x77, 0x48, 0xe1, 0xb7, 0x27, 0xea, - 0xf8, 0x46, 0x15, 0x48, 0xbb, 0x85, 0x52, 0x8c, 0xd1, 0x50, 0xfd, 0x59, 0x38, 0x59, 0x87, 0x57, - 0x5a, 0x78, 0x04, 0x95, 0x60, 0x94, 0x57, 0x48, 0x48, 0x9c, 0x98, 0xc1, 0xea, 0xa9, 0x97, 0x07, - 0xff, 0x01, 0xf2, 0x16, 0x61, 0x45, 0x6d, 0xa3, 0xa1, 0x9a, 0x26, 0x31, 0x50, 0x41, 0xa8, 0xbe, - 0xd9, 0x6c, 0xb1, 0xa3, 0x98, 0x1d, 0x87, 0x3f, 0x4c, 0xe3, 0x91, 0xb5, 0x3a, 0xc8, 0x3b, 0xb6, - 0x75, 0x78, 0xd4, 0xa9, 0x37, 0xfe, 0x05, 0x72, 0xb0, 0x90, 0x3a, 0x71, 0x89, 0xab, 0x31, 0x49, - 0x7d, 0xbc, 0x0e, 0xc3, 0x23, 0xeb, 0xeb, 0xff, 0xb9, 0x5d, 0xd7, 0x59, 0xa3, 0x5d, 0x75, 0x6c, - 0xac, 0x3e, 0xd7, 0x0d, 0x43, 0x7f, 0xce, 0x48, 0xad, 0xb1, 0xea, 0x4e, 0xbb, 0xa9, 0xe9, 0x94, - 0xd9, 0x7a, 0xb5, 0xcd, 0x88, 0xb6, 0xaa, 0x9b, 0x8c, 0xd8, 0xa6, 0x6a, 0xac, 0x72, 0xc3, 0x9e, - 0x46, 0xab, 0x5a, 0x4d, 0xf3, 0xf1, 0xad, 0x9f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x14, 0x2f, 0x38, - 0x4a, 0xbf, 0x21, 0x00, 0x00, + // 1879 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xed, 0x6f, 0x1b, 0x49, + 0x19, 0xcf, 0xd8, 0x8e, 0x93, 0x3c, 0x59, 0x3b, 0xce, 0x34, 0x2f, 0xae, 0xaf, 0xe5, 0xd2, 0x85, + 0xbb, 0xa6, 0x2f, 0xd7, 0x40, 0x8e, 0xd7, 0x0f, 0x48, 0x6d, 0xea, 0x5e, 0x6a, 0xb5, 0xd7, 0x86, + 0x75, 0x38, 0x28, 0xa7, 0xca, 0xac, 0xbd, 0x53, 0x7b, 0xb9, 0x7d, 0x31, 0x3b, 0xe3, 0xa4, 0xe9, + 0x27, 0xc4, 0x21, 0x90, 0x00, 0x01, 0x9f, 0x90, 0xf8, 0x8a, 0xc4, 0x57, 0x04, 0x07, 0xe2, 0x3f, + 0x40, 0x42, 0xe2, 0x4f, 0x41, 0x7c, 0xe4, 0x23, 0x12, 0x9a, 0x99, 0xf5, 0x7a, 0x77, 0x33, 0x1b, + 0xbb, 0xf5, 0x1d, 0x71, 0xbf, 0x79, 0x9e, 0x79, 0x66, 0xe6, 0xf7, 0xbc, 0xce, 0xb3, 0xcf, 0x18, + 0x34, 0xd7, 0x76, 0x8e, 0x06, 0xf4, 0x56, 0x3f, 0xf0, 0x99, 0x8f, 0x2f, 0xc4, 0x47, 0xb7, 0xe4, + 0xa0, 0xa6, 0x75, 0x7c, 0xd7, 0xf5, 0x3d, 0x49, 0xac, 0x69, 0xb4, 0xd3, 0x23, 0xae, 0x29, 0x47, + 0xfa, 0x1f, 0x10, 0x6c, 0xde, 0x0d, 0x88, 0xc9, 0xc8, 0x5d, 0xdf, 0x71, 0x48, 0x87, 0xd9, 0xbe, + 0x67, 0x90, 0x1f, 0x0e, 0x08, 0x65, 0xf8, 0x8b, 0x50, 0x68, 0x9b, 0x94, 0x54, 0xd1, 0x16, 0xda, + 0x5e, 0xde, 0xbd, 0x74, 0x2b, 0xb1, 0x77, 0xb8, 0xe7, 0xfb, 0xb4, 0xbb, 0x67, 0x52, 0x62, 0x08, + 0x4e, 0xbc, 0x09, 0x0b, 0x56, 0xbb, 0xe5, 0x99, 0x2e, 0xa9, 0xe6, 0xb6, 0xd0, 0xf6, 0x92, 0x51, + 0xb4, 0xda, 0x8f, 0x4c, 0x97, 0xe0, 0xab, 0xb0, 0xd2, 0x89, 0xf6, 0x97, 0x0c, 0x79, 0xc1, 0x50, + 0x1e, 0x91, 0x05, 0xe3, 0x06, 0x14, 0x25, 0xbe, 0x6a, 0x61, 0x0b, 0x6d, 0x6b, 0x46, 0x38, 0xd2, + 0x7f, 0x81, 0x60, 0xbd, 0x1e, 0xf8, 0xfd, 0x99, 0x40, 0xa9, 0xff, 0x1c, 0xc1, 0xda, 0x7d, 0x93, + 0xce, 0x06, 0x98, 0x27, 0xa0, 0xed, 0xf9, 0xbe, 0x63, 0x10, 0xda, 0xf7, 0x3d, 0x4a, 0xf0, 0xbb, + 0x50, 0xa4, 0xcc, 0x64, 0x03, 0x1a, 0xa2, 0x78, 0x43, 0x89, 0xa2, 0x29, 0x58, 0x8c, 0x90, 0x15, + 0xaf, 0xc1, 0xfc, 0x91, 0xe9, 0x0c, 0x24, 0x88, 0x45, 0x43, 0x0e, 0xf4, 0x0f, 0xa1, 0xdc, 0x64, + 0x81, 0xed, 0x75, 0x3f, 0xc5, 0xcd, 0x97, 0x86, 0x9b, 0xff, 0x1a, 0xc1, 0xc5, 0x3a, 0xa1, 0x9d, + 0xc0, 0x6e, 0xcf, 0x86, 0xf3, 0xe9, 0x7f, 0x45, 0x50, 0x53, 0x21, 0x9a, 0x46, 0xf6, 0x6f, 0x46, + 0x0e, 0x9d, 0x13, 0x8b, 0xde, 0x4a, 0x2e, 0x0a, 0x83, 0x71, 0x74, 0x5a, 0x53, 0x10, 0x86, 0x7e, + 0x8f, 0x75, 0xd0, 0x46, 0x20, 0x1b, 0x75, 0x01, 0x3c, 0x6f, 0x24, 0x68, 0x22, 0x36, 0x1e, 0xfa, + 0xa6, 0x35, 0x1b, 0x4a, 0xfc, 0x15, 0x82, 0xaa, 0x41, 0x1c, 0x62, 0xd2, 0x19, 0xb1, 0xea, 0x2f, + 0x11, 0x6c, 0xc4, 0xf4, 0xcb, 0x4c, 0x46, 0xcf, 0x13, 0xce, 0xcf, 0x78, 0xc6, 0x4d, 0xc3, 0x99, + 0xc6, 0xc3, 0xbe, 0x06, 0xf3, 0xfc, 0x17, 0xad, 0xe6, 0xb6, 0xf2, 0xdb, 0xcb, 0xbb, 0x57, 0x94, + 0x6b, 0x1e, 0x90, 0x93, 0x0f, 0x78, 0xd4, 0x1d, 0x98, 0x76, 0x60, 0x48, 0x7e, 0xbd, 0x0d, 0xeb, + 0xcd, 0x9e, 0x7f, 0xfc, 0x59, 0x5a, 0x49, 0x7f, 0x0e, 0x1b, 0xe9, 0x33, 0xa6, 0x91, 0xf5, 0x1a, + 0x54, 0x52, 0x5a, 0x96, 0x62, 0x2f, 0x19, 0x2b, 0x49, 0x35, 0x53, 0xfd, 0x2f, 0xdc, 0xec, 0xe2, + 0x66, 0x3b, 0x30, 0x03, 0x66, 0x9f, 0xf7, 0xc5, 0xf6, 0x16, 0x94, 0xfb, 0x43, 0x1c, 0x92, 0xaf, + 0x20, 0xf8, 0x4a, 0x11, 0x55, 0xe8, 0xeb, 0xcf, 0x08, 0xd6, 0xf8, 0x3d, 0xf7, 0x3a, 0x61, 0xfe, + 0x13, 0x82, 0x0b, 0xf7, 0x4d, 0xfa, 0x3a, 0x41, 0xfe, 0x04, 0xc1, 0x05, 0x9e, 0x32, 0x25, 0xe6, + 0xf3, 0x85, 0x7c, 0x15, 0x56, 0x92, 0x90, 0x69, 0xb5, 0x20, 0x5c, 0xba, 0x9c, 0xc0, 0x4c, 0xf5, + 0xbf, 0x21, 0xd8, 0x0c, 0x33, 0xeb, 0x4c, 0xe8, 0x7a, 0x62, 0xe0, 0x9f, 0x20, 0x58, 0x8f, 0x10, + 0x9f, 0x77, 0x02, 0x9e, 0xd4, 0x45, 0x7e, 0x8a, 0x60, 0x23, 0x0d, 0xfa, 0x5c, 0xd2, 0xf4, 0x1f, + 0x11, 0xac, 0xf1, 0x1c, 0x3a, 0x13, 0x36, 0x4f, 0xd7, 0x23, 0x05, 0x45, 0x3d, 0xf2, 0x3b, 0x24, + 0x2f, 0x96, 0x18, 0xe0, 0x69, 0x14, 0xa7, 0x70, 0xb3, 0x9c, 0xca, 0xcd, 0x38, 0xb6, 0x88, 0xd2, + 0xa8, 0xd3, 0x6a, 0x7e, 0x2b, 0xcf, 0xb1, 0xc5, 0x69, 0xa2, 0x18, 0x18, 0x96, 0x78, 0x4d, 0xd2, + 0x75, 0x89, 0xc7, 0x5e, 0x5d, 0x9d, 0x69, 0x65, 0xe4, 0x4e, 0x2b, 0x03, 0x5f, 0x82, 0x25, 0x2a, + 0xcf, 0x89, 0xaa, 0xb7, 0x11, 0x41, 0xff, 0x31, 0x82, 0xcd, 0x53, 0x70, 0xa6, 0x51, 0x56, 0x15, + 0x16, 0x6c, 0xcf, 0x22, 0xcf, 0x23, 0x34, 0xc3, 0x21, 0x9f, 0x69, 0x0f, 0x6c, 0xc7, 0x8a, 0x60, + 0x0c, 0x87, 0x5c, 0x27, 0x98, 0xdb, 0xeb, 0xff, 0xa2, 0x8f, 0x2d, 0x58, 0x8e, 0x19, 0x24, 0x84, + 0x12, 0x27, 0xe9, 0x3f, 0x80, 0x0b, 0x09, 0x34, 0xd3, 0xa8, 0xe3, 0x73, 0x00, 0x91, 0xb2, 0xa5, + 0xdb, 0xe4, 0x8d, 0x18, 0x45, 0xff, 0x37, 0x02, 0x2c, 0x8b, 0x84, 0x06, 0x57, 0xd3, 0x79, 0x46, + 0xd6, 0x65, 0x80, 0x67, 0x36, 0x71, 0xac, 0x78, 0x4a, 0x5a, 0x12, 0x14, 0x31, 0x5d, 0x07, 0x8d, + 0x3c, 0x67, 0x81, 0xd9, 0xea, 0x9b, 0x81, 0xe9, 0xd2, 0xea, 0xfc, 0xa4, 0x59, 0x64, 0x59, 0x2c, + 0x3b, 0x10, 0xab, 0xf4, 0x7f, 0xf0, 0xf2, 0x22, 0xf4, 0xb7, 0x59, 0x97, 0xf8, 0x32, 0x80, 0xf0, + 0x5d, 0x39, 0x3d, 0x2f, 0xa7, 0x05, 0x45, 0xe4, 0x67, 0x07, 0x2a, 0x42, 0x02, 0x29, 0x4e, 0x9f, + 0xef, 0x9a, 0x5a, 0x82, 0x52, 0x4b, 0xf0, 0x37, 0xa0, 0x18, 0x6a, 0x6f, 0xe2, 0x1c, 0x1c, 0x2e, + 0xd0, 0x7f, 0x8f, 0x60, 0x3d, 0xa5, 0xb8, 0x69, 0xfc, 0xf2, 0x10, 0xb0, 0x04, 0x6a, 0x8d, 0xd0, + 0x0f, 0x51, 0xa5, 0xbe, 0x10, 0xc3, 0x41, 0x5a, 0x56, 0x63, 0xd5, 0x4e, 0x51, 0xa8, 0xfe, 0x77, + 0x04, 0xab, 0x82, 0x8f, 0x9f, 0x46, 0x5e, 0x5f, 0xd3, 0xfe, 0x08, 0x01, 0x8e, 0xcb, 0x31, 0x8d, + 0xa6, 0xbf, 0x22, 0xaf, 0x5d, 0x29, 0x49, 0x79, 0xf7, 0x4d, 0xe5, 0x9a, 0xd8, 0x61, 0x92, 0x5b, + 0xff, 0x2f, 0x82, 0x52, 0xc3, 0xa3, 0x24, 0x60, 0xb3, 0x5f, 0xaa, 0xe0, 0x2f, 0xc3, 0x62, 0xe0, + 0x1f, 0xb7, 0x2c, 0x93, 0x99, 0x61, 0x5e, 0xb8, 0xa8, 0x84, 0xb7, 0xe7, 0xf8, 0x6d, 0x63, 0x21, + 0xf0, 0x8f, 0xeb, 0x26, 0x33, 0xf1, 0x1b, 0xb0, 0xd4, 0x33, 0x69, 0xaf, 0xf5, 0x11, 0x39, 0xa1, + 0xd5, 0xe2, 0x56, 0x7e, 0xbb, 0x64, 0x2c, 0x72, 0xc2, 0x03, 0x72, 0x42, 0xf5, 0x8f, 0x11, 0x94, + 0x87, 0xf2, 0x4f, 0xa3, 0xfe, 0x37, 0x61, 0x39, 0xf0, 0x8f, 0x1b, 0xf5, 0x56, 0x9b, 0x74, 0x6d, + 0x2f, 0xbc, 0x11, 0x40, 0x90, 0xf6, 0x38, 0x85, 0xa3, 0x90, 0x0c, 0xc4, 0xb3, 0xc2, 0xdb, 0x60, + 0x51, 0x10, 0xee, 0x79, 0x96, 0x7e, 0x04, 0x95, 0x03, 0xc7, 0xec, 0x90, 0x9e, 0xef, 0x58, 0x24, + 0x10, 0x51, 0x89, 0x2b, 0x90, 0x67, 0x66, 0x37, 0x0c, 0x6e, 0xfe, 0x13, 0x7f, 0x1d, 0x0a, 0xec, + 0xa4, 0x3f, 0xb4, 0xf0, 0x17, 0x94, 0xe1, 0x13, 0xdb, 0xe6, 0xf0, 0xa4, 0x4f, 0x0c, 0xb1, 0x02, + 0x6f, 0x40, 0x51, 0xf4, 0xa2, 0x64, 0xad, 0xa0, 0x19, 0xe1, 0x48, 0x7f, 0x9a, 0x38, 0x77, 0x3f, + 0xf0, 0x07, 0x7d, 0xdc, 0x00, 0xad, 0x3f, 0xa2, 0x71, 0x25, 0x64, 0x07, 0x6b, 0x1a, 0xb4, 0x91, + 0x58, 0xaa, 0xff, 0x0b, 0x41, 0xa9, 0x49, 0xcc, 0xa0, 0xd3, 0x7b, 0x1d, 0xca, 0x77, 0xae, 0x71, + 0x8b, 0x3a, 0x61, 0x98, 0xf2, 0x9f, 0xf8, 0x06, 0xac, 0xc6, 0x04, 0x6a, 0x75, 0xb9, 0x82, 0xaa, + 0x45, 0xd1, 0xb0, 0xad, 0xf4, 0x53, 0x8a, 0xd3, 0x1f, 0x40, 0xe1, 0xbe, 0xcd, 0xc4, 0x36, 0xfc, + 0x12, 0x46, 0xe2, 0x12, 0xe6, 0x3f, 0xf1, 0xc5, 0x98, 0xdf, 0xe6, 0x84, 0x01, 0x22, 0xe7, 0x14, + 0x7d, 0x60, 0x3f, 0x08, 0x2d, 0x93, 0x33, 0xc2, 0x91, 0xfe, 0xdd, 0x91, 0xe6, 0xe8, 0xc0, 0x61, + 0xf4, 0xd5, 0xbc, 0x12, 0x43, 0xa1, 0x67, 0x87, 0xa5, 0xb8, 0x66, 0x88, 0xdf, 0xfa, 0x4f, 0x10, + 0x68, 0xef, 0x39, 0x03, 0xfa, 0x59, 0xd8, 0x44, 0xd5, 0xb6, 0xc8, 0xab, 0xdb, 0x16, 0xff, 0xcc, + 0xc1, 0xfa, 0x01, 0x09, 0xa8, 0x4d, 0x19, 0xf1, 0x58, 0x58, 0x04, 0x35, 0xbc, 0x67, 0x7e, 0xb2, + 0x92, 0x44, 0xa9, 0x4a, 0xf2, 0xd3, 0xa9, 0xbd, 0x78, 0x34, 0xfa, 0x7d, 0xe2, 0xb5, 0x98, 0x1d, + 0xe6, 0x9a, 0x82, 0xb1, 0xc8, 0x09, 0x87, 0xb6, 0x4b, 0x78, 0x2c, 0x53, 0x62, 0x3a, 0xc4, 0x92, + 0xd3, 0xf3, 0x62, 0x1a, 0x24, 0x49, 0x30, 0x5c, 0x01, 0xed, 0x19, 0xd7, 0xe0, 0x90, 0xa3, 0x28, + 0x38, 0x96, 0x43, 0x9a, 0x60, 0xb9, 0x08, 0x8b, 0xde, 0xc0, 0x6d, 0x05, 0xfe, 0x31, 0xad, 0x2e, + 0xc8, 0x32, 0xd4, 0x1b, 0xb8, 0x86, 0x7f, 0x2c, 0xbc, 0xc1, 0x25, 0x6e, 0x8b, 0xda, 0x2f, 0x48, + 0x75, 0x51, 0x4e, 0xb9, 0xc4, 0x6d, 0xda, 0x2f, 0xc8, 0xf0, 0xdb, 0x89, 0x54, 0x97, 0x44, 0x88, + 0xab, 0xef, 0xed, 0x50, 0x57, 0x89, 0x34, 0xfe, 0x1b, 0x04, 0x97, 0x94, 0xda, 0x7c, 0x75, 0x23, + 0x6f, 0x40, 0x68, 0xd5, 0x94, 0x8d, 0xdf, 0x86, 0x54, 0x80, 0x65, 0xf4, 0xff, 0x7e, 0x8b, 0xe0, + 0x72, 0x06, 0xa4, 0x69, 0x12, 0xed, 0x6d, 0x98, 0xb7, 0xbd, 0x67, 0xfe, 0xb0, 0x88, 0xb8, 0xae, + 0xce, 0x4b, 0xca, 0x73, 0xe5, 0x42, 0x9e, 0xf2, 0xd7, 0x0c, 0xd2, 0xe5, 0xf3, 0xc1, 0x43, 0xdb, + 0xfb, 0x28, 0xc2, 0xf3, 0x55, 0x58, 0x30, 0x2d, 0x2b, 0x20, 0x94, 0x9e, 0xa9, 0xa6, 0x3b, 0x92, + 0xc7, 0x18, 0x32, 0xc7, 0xe4, 0xc8, 0x4d, 0x2c, 0xc7, 0xf5, 0xdb, 0xb0, 0x92, 0xca, 0xd5, 0x78, + 0x11, 0x0a, 0x8f, 0x1e, 0x3f, 0xba, 0x57, 0x99, 0xc3, 0xab, 0x50, 0xfa, 0xe0, 0xde, 0xdd, 0xc3, + 0xc7, 0x46, 0x6b, 0xaf, 0xf1, 0xe8, 0x8e, 0xf1, 0xa4, 0x62, 0xe1, 0x0a, 0x68, 0x21, 0xe9, 0xbd, + 0x87, 0x8f, 0xef, 0x1c, 0x56, 0xc8, 0xee, 0x7f, 0x56, 0xa1, 0xf4, 0xbe, 0x38, 0xa8, 0x49, 0x82, + 0x23, 0xbb, 0x43, 0x70, 0x0b, 0x2a, 0xe9, 0x37, 0x2e, 0x7c, 0x53, 0xa9, 0xa0, 0x8c, 0xa7, 0xb0, + 0xda, 0x59, 0xd0, 0xf5, 0x39, 0xfc, 0x21, 0x94, 0x93, 0x8f, 0x53, 0x58, 0xad, 0x7f, 0xe5, 0x0b, + 0xd6, 0xb8, 0xcd, 0x5b, 0x50, 0x4a, 0xbc, 0x35, 0xe1, 0x6b, 0xca, 0xbd, 0x55, 0xef, 0x51, 0xb5, + 0x2b, 0x4a, 0xd6, 0xf8, 0x73, 0x91, 0x44, 0x9f, 0x7c, 0x3e, 0xc8, 0x40, 0xaf, 0x7c, 0x63, 0x18, + 0x87, 0xde, 0x84, 0xd5, 0x53, 0xaf, 0x01, 0xf8, 0x1d, 0xe5, 0xfe, 0x59, 0xaf, 0x06, 0xe3, 0x8e, + 0x38, 0x06, 0x7c, 0xfa, 0xd5, 0x06, 0xdf, 0x52, 0x5b, 0x20, 0xeb, 0xc1, 0xa9, 0xb6, 0x33, 0x31, + 0x7f, 0xa4, 0xb8, 0x23, 0xd8, 0xdc, 0x27, 0x2c, 0xd9, 0xcc, 0xb7, 0x29, 0xb3, 0x3b, 0x14, 0xdf, + 0x50, 0xbb, 0x97, 0xf2, 0x19, 0xa2, 0x76, 0x73, 0x32, 0xe6, 0xe8, 0x5c, 0x07, 0x56, 0x92, 0x4d, + 0x75, 0x9a, 0x61, 0x31, 0x65, 0x7b, 0xbf, 0x76, 0x63, 0x22, 0xde, 0xe8, 0xb4, 0xa7, 0xb0, 0x92, + 0xea, 0xa3, 0x67, 0x49, 0xa7, 0xec, 0xb6, 0x8f, 0xb3, 0xde, 0x13, 0x28, 0x25, 0x1a, 0xde, 0x19, + 0xee, 0xad, 0x6a, 0x8a, 0x8f, 0xdb, 0xfa, 0x29, 0x68, 0xf1, 0xbe, 0x34, 0xde, 0xce, 0x0a, 0x9c, + 0x53, 0x1b, 0x4f, 0x14, 0x37, 0x4f, 0x64, 0xdc, 0x44, 0x8b, 0x69, 0xc6, 0x01, 0x8a, 0x46, 0xf3, + 0x38, 0xe4, 0xdf, 0x8f, 0xa2, 0x26, 0xb6, 0xfb, 0xcd, 0xb3, 0xa2, 0xe6, 0x65, 0x75, 0x43, 0x61, + 0x63, 0x9f, 0xb0, 0x44, 0x83, 0x33, 0x74, 0xdd, 0x8c, 0xab, 0x43, 0xd5, 0xbf, 0xcd, 0x70, 0x25, + 0x75, 0xdb, 0x54, 0x9f, 0xc3, 0x36, 0x94, 0x13, 0x8d, 0x41, 0x9a, 0x61, 0x6c, 0x55, 0xbb, 0xb3, + 0x76, 0x7d, 0x12, 0xd6, 0xe8, 0xa8, 0x6f, 0xc3, 0x72, 0xac, 0xb1, 0x83, 0xaf, 0x9e, 0xe1, 0xb1, + 0xf1, 0x46, 0xc8, 0x38, 0xb5, 0xf5, 0xa0, 0x94, 0x68, 0x03, 0x64, 0x79, 0xab, 0xa2, 0xc7, 0x92, + 0x21, 0x80, 0xb2, 0xab, 0xa0, 0xcf, 0xe1, 0x36, 0x94, 0xf6, 0x09, 0x1b, 0x7d, 0x99, 0xe2, 0xb7, + 0xb3, 0xfb, 0x02, 0xf1, 0xef, 0xfd, 0xda, 0xd5, 0xb1, 0x7c, 0xd1, 0x19, 0x4d, 0x28, 0xca, 0x8f, + 0x3c, 0xac, 0x67, 0x2c, 0x8a, 0x7d, 0x01, 0xd7, 0x3e, 0x7f, 0x26, 0x4f, 0xb4, 0xa9, 0x01, 0x45, + 0x59, 0xa2, 0x67, 0x6c, 0x9a, 0xf8, 0xf2, 0xa9, 0x9d, 0xcd, 0x23, 0x6a, 0x7c, 0x7d, 0x0e, 0x37, + 0x60, 0x5e, 0xd4, 0xe6, 0x58, 0x1d, 0x98, 0xf1, 0xba, 0x7d, 0x9c, 0x05, 0xbf, 0x05, 0xda, 0x3e, + 0x61, 0x75, 0xeb, 0x6e, 0xcf, 0xf4, 0x3c, 0xe2, 0xe0, 0x9a, 0x92, 0xfd, 0x9e, 0xdb, 0x67, 0x27, + 0x19, 0x12, 0x27, 0xff, 0x12, 0xa1, 0xcf, 0xe1, 0x8f, 0x11, 0x54, 0x79, 0x30, 0x29, 0xcb, 0xf6, + 0x2f, 0xbd, 0x44, 0x25, 0x16, 0x4a, 0xb0, 0xfb, 0x32, 0x4b, 0x86, 0x28, 0x76, 0xbb, 0xa0, 0x1d, + 0x04, 0xfe, 0xf3, 0x93, 0x61, 0xd5, 0xf3, 0x1d, 0xd0, 0xe2, 0xe5, 0xdc, 0x99, 0x82, 0x5e, 0xcb, + 0x48, 0x2d, 0xa7, 0xab, 0x41, 0x7d, 0x6e, 0x6f, 0xef, 0x7b, 0xb7, 0xbb, 0x36, 0xeb, 0x0d, 0xda, + 0x7c, 0x8f, 0x9d, 0x17, 0xb6, 0xe3, 0xd8, 0x2f, 0x18, 0xe9, 0xf4, 0x76, 0xe4, 0xb2, 0x77, 0x2c, + 0x9b, 0xb2, 0xc0, 0x6e, 0x0f, 0x18, 0xb1, 0x76, 0x6c, 0x8f, 0x91, 0xc0, 0x33, 0x9d, 0x1d, 0xb1, + 0x71, 0xc8, 0xd1, 0x6f, 0xb7, 0x8b, 0x62, 0xfc, 0xee, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x92, + 0x88, 0x64, 0x88, 0xbf, 0x24, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2551,6 +2771,7 @@ type MilvusServiceClient interface { Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResults, error) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error) GetDdChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*StringResponse, error) + GetPersistentSegmentInfo(ctx context.Context, in *PersistentSegmentInfoRequest, opts ...grpc.CallOption) (*PersistentSegmentInfoResponse, error) } type milvusServiceClient struct { @@ -2759,6 +2980,15 @@ func (c *milvusServiceClient) GetDdChannel(ctx context.Context, in *commonpb.Emp return out, nil } +func (c *milvusServiceClient) GetPersistentSegmentInfo(ctx context.Context, in *PersistentSegmentInfoRequest, opts ...grpc.CallOption) (*PersistentSegmentInfoResponse, error) { + out := new(PersistentSegmentInfoResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MilvusServiceServer is the server API for MilvusService service. type MilvusServiceServer interface { CreateCollection(context.Context, *CreateCollectionRequest) (*commonpb.Status, error) @@ -2783,6 +3013,7 @@ type MilvusServiceServer interface { Search(context.Context, *SearchRequest) (*SearchResults, error) Flush(context.Context, *FlushRequest) (*commonpb.Status, error) GetDdChannel(context.Context, *commonpb.Empty) (*StringResponse, error) + GetPersistentSegmentInfo(context.Context, *PersistentSegmentInfoRequest) (*PersistentSegmentInfoResponse, error) } // UnimplementedMilvusServiceServer can be embedded to have forward compatible implementations. @@ -2855,6 +3086,9 @@ func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRe func (*UnimplementedMilvusServiceServer) GetDdChannel(ctx context.Context, req *commonpb.Empty) (*StringResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetDdChannel not implemented") } +func (*UnimplementedMilvusServiceServer) GetPersistentSegmentInfo(ctx context.Context, req *PersistentSegmentInfoRequest) (*PersistentSegmentInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetPersistentSegmentInfo not implemented") +} func RegisterMilvusServiceServer(s *grpc.Server, srv MilvusServiceServer) { s.RegisterService(&_MilvusService_serviceDesc, srv) @@ -3256,6 +3490,24 @@ func _MilvusService_GetDdChannel_Handler(srv interface{}, ctx context.Context, d 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(PersistentSegmentInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MilvusServiceServer).GetPersistentSegmentInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.milvus.MilvusService/GetPersistentSegmentInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MilvusServiceServer).GetPersistentSegmentInfo(ctx, req.(*PersistentSegmentInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _MilvusService_serviceDesc = grpc.ServiceDesc{ ServiceName: "milvus.proto.milvus.MilvusService", HandlerType: (*MilvusServiceServer)(nil), @@ -3348,6 +3600,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{ MethodName: "GetDdChannel", Handler: _MilvusService_GetDdChannel_Handler, }, + { + MethodName: "GetPersistentSegmentInfo", + Handler: _MilvusService_GetPersistentSegmentInfo_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "milvus.proto", diff --git a/internal/querynode/flow_graph_gc_node.go b/internal/querynode/flow_graph_gc_node.go index dc468ed079..6c156547d1 100644 --- a/internal/querynode/flow_graph_gc_node.go +++ b/internal/querynode/flow_graph_gc_node.go @@ -21,31 +21,27 @@ func (gcNode *gcNode) Operate(in []*Msg) []*Msg { // TODO: add error handling } - _, ok := (*in[0]).(*gcMsg) + gcMsg, ok := (*in[0]).(*gcMsg) if !ok { log.Println("type assertion failed for gcMsg") // TODO: add error handling } - // Use `releasePartition` and `releaseCollection`, - // because if we drop collections or partitions here, query service doesn't know this behavior, - // which would lead the wrong result of `showCollections` or `showPartition` + // drop collections + for _, collectionID := range gcMsg.gcRecord.collections { + err := gcNode.replica.removeCollection(collectionID) + if err != nil { + log.Println(err) + } + } - //// drop collections - //for _, collectionID := range gcMsg.gcRecord.collections { - // err := gcNode.replica.removeCollection(collectionID) - // if err != nil { - // log.Println(err) - // } - //} - // - //// drop partitions - //for _, partition := range gcMsg.gcRecord.partitions { - // err := gcNode.replica.removePartition(partition.collectionID, partition.partitionID) - // if err != nil { - // log.Println(err) - // } - //} + // drop partitions + for _, partition := range gcMsg.gcRecord.partitions { + err := gcNode.replica.removePartition(partition.collectionID, partition.partitionID) + if err != nil { + log.Println(err) + } + } return nil } diff --git a/internal/querynode/query_node.go b/internal/querynode/query_node.go index c2b2e58095..16178f4807 100644 --- a/internal/querynode/query_node.go +++ b/internal/querynode/query_node.go @@ -25,7 +25,6 @@ import ( "github.com/zilliztech/milvus-distributed/internal/msgstream/pulsarms" "github.com/zilliztech/milvus-distributed/internal/proto/commonpb" - "github.com/zilliztech/milvus-distributed/internal/proto/datapb" "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2" queryPb "github.com/zilliztech/milvus-distributed/internal/proto/querypb" "github.com/zilliztech/milvus-distributed/internal/util/typeutil" @@ -445,7 +444,7 @@ func (node *QueryNode) LoadSegments(in *queryPb.LoadSegmentRequest) (*commonpb.S } // segments are ordered before LoadSegments calling - if in.LastSegmentState.State == datapb.SegmentState_SegmentGrowing { + if in.LastSegmentState.State == commonpb.SegmentState_SegmentGrowing { segmentNum := len(segmentIDs) positions := in.LastSegmentState.StartPositions err = node.loadService.seekSegment(positions) diff --git a/internal/queryservice/queryservice.go b/internal/queryservice/queryservice.go index 59f1d845e6..6c925d3d6b 100644 --- a/internal/queryservice/queryservice.go +++ b/internal/queryservice/queryservice.go @@ -345,10 +345,10 @@ func (qs *QueryService) LoadPartitions(req *querypb.LoadPartitionRequest) (*comm sort.Slice(value, func(i, j int) bool { return segmentStates[value[i]].CreateTime < segmentStates[value[j]].CreateTime }) selectedSegs := make([]UniqueID, 0) for i, v := range value { - if segmentStates[v].State == datapb.SegmentState_SegmentFlushed { + if segmentStates[v].State == commonpb.SegmentState_SegmentFlushed { selectedSegs = append(selectedSegs, v) } else { - if i > 0 && segmentStates[selectedSegs[i-1]].State != datapb.SegmentState_SegmentFlushed { + if i > 0 && segmentStates[selectedSegs[i-1]].State != commonpb.SegmentState_SegmentFlushed { break } selectedSegs = append(selectedSegs, v) diff --git a/internal/queryservice/queryservice_test.go b/internal/queryservice/queryservice_test.go index 1193eb382f..7d6f55ad36 100644 --- a/internal/queryservice/queryservice_test.go +++ b/internal/queryservice/queryservice_test.go @@ -110,7 +110,7 @@ func newDataMock() *dataMock { segmentIDs = append(segmentIDs, 5) segmentIDs = append(segmentIDs, 6) - fillStates := func(segmentID UniqueID, time uint64, position []*internalpb2.MsgPosition, state datapb.SegmentState) *datapb.SegmentStateInfo { + fillStates := func(segmentID UniqueID, time uint64, position []*internalpb2.MsgPosition, state commonpb.SegmentState) *datapb.SegmentStateInfo { return &datapb.SegmentStateInfo{ Status: &commonpb.Status{ ErrorCode: commonpb.ErrorCode_SUCCESS, @@ -122,12 +122,12 @@ func newDataMock() *dataMock { } } segmentStates := make(map[UniqueID]*datapb.SegmentStateInfo) - segmentStates[1] = fillStates(1, 1, positions1, datapb.SegmentState_SegmentFlushed) - segmentStates[2] = fillStates(2, 2, positions2, datapb.SegmentState_SegmentFlushed) - segmentStates[3] = fillStates(3, 3, positions1, datapb.SegmentState_SegmentFlushed) - segmentStates[4] = fillStates(4, 4, positions2, datapb.SegmentState_SegmentFlushed) - segmentStates[5] = fillStates(5, 5, positions1, datapb.SegmentState_SegmentGrowing) - segmentStates[6] = fillStates(6, 6, positions2, datapb.SegmentState_SegmentGrowing) + segmentStates[1] = fillStates(1, 1, positions1, commonpb.SegmentState_SegmentFlushed) + segmentStates[2] = fillStates(2, 2, positions2, commonpb.SegmentState_SegmentFlushed) + segmentStates[3] = fillStates(3, 3, positions1, commonpb.SegmentState_SegmentFlushed) + segmentStates[4] = fillStates(4, 4, positions2, commonpb.SegmentState_SegmentFlushed) + segmentStates[5] = fillStates(5, 5, positions1, commonpb.SegmentState_SegmentGrowing) + segmentStates[6] = fillStates(6, 6, positions2, commonpb.SegmentState_SegmentGrowing) return &dataMock{ segmentIDs: segmentIDs,