diff --git a/internal/core/src/pb/common.pb.cc b/internal/core/src/pb/common.pb.cc index 73b57b02b0..b779592c65 100644 --- a/internal/core/src/pb/common.pb.cc +++ b/internal/core/src/pb/common.pb.cc @@ -285,7 +285,7 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE( "\006Failed\020\004*s\n\014SegmentState\022\024\n\020SegmentStat" "eNone\020\000\022\014\n\010NotExist\020\001\022\013\n\007Growing\020\002\022\n\n\006Se" "aled\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005\022\013\n\007Dro" - "pped\020\006*\251\t\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cre" + "pped\020\006*\300\t\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cre" "ateCollection\020d\022\022\n\016DropCollection\020e\022\021\n\rH" "asCollection\020f\022\026\n\022DescribeCollection\020g\022\023" "\n\017ShowCollections\020h\022\024\n\020GetSystemConfigs\020" @@ -298,35 +298,35 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE( "\020\316\001\022\021\n\014ShowSegments\020\372\001\022\024\n\017DescribeSegmen" "t\020\373\001\022\021\n\014LoadSegments\020\374\001\022\024\n\017ReleaseSegmen" "ts\020\375\001\022\024\n\017HandoffSegments\020\376\001\022\030\n\023LoadBalan" - "ceSegments\020\377\001\022\020\n\013CreateIndex\020\254\002\022\022\n\rDescr" - "ibeIndex\020\255\002\022\016\n\tDropIndex\020\256\002\022\013\n\006Insert\020\220\003" - "\022\013\n\006Delete\020\221\003\022\n\n\005Flush\020\222\003\022\013\n\006Search\020\364\003\022\021" - "\n\014SearchResult\020\365\003\022\022\n\rGetIndexState\020\366\003\022\032\n" - "\025GetIndexBuildProgress\020\367\003\022\034\n\027GetCollecti" - "onStatistics\020\370\003\022\033\n\026GetPartitionStatistic" - "s\020\371\003\022\r\n\010Retrieve\020\372\003\022\023\n\016RetrieveResult\020\373\003" - "\022\024\n\017WatchDmChannels\020\374\003\022\025\n\020RemoveDmChanne" - "ls\020\375\003\022\027\n\022WatchQueryChannels\020\376\003\022\030\n\023Remove" - "QueryChannels\020\377\003\022\035\n\030SealedSegmentsChange" - "Info\020\200\004\022\027\n\022WatchDeltaChannels\020\201\004\022\020\n\013Segm" - "entInfo\020\330\004\022\017\n\nSystemInfo\020\331\004\022\024\n\017GetRecove" - "ryInfo\020\332\004\022\024\n\017GetSegmentState\020\333\004\022\r\n\010TimeT" - "ick\020\260\t\022\023\n\016QueryNodeStats\020\261\t\022\016\n\tLoadIndex" - "\020\262\t\022\016\n\tRequestID\020\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017" - "AllocateSegment\020\265\t\022\026\n\021SegmentStatistics\020" - "\266\t\022\025\n\020SegmentFlushDone\020\267\t\022\017\n\nDataNodeTt\020" - "\270\t*\"\n\007DslType\022\007\n\003Dsl\020\000\022\016\n\nBoolExprV1\020\001*B" - "\n\017CompactionState\022\021\n\rUndefiedState\020\000\022\r\n\t" - "Executing\020\001\022\r\n\tCompleted\020\002*X\n\020Consistenc" - "yLevel\022\n\n\006Strong\020\000\022\013\n\007Session\020\001\022\013\n\007Bound" - "ed\020\002\022\016\n\nEventually\020\003\022\016\n\nCustomized\020\004*\227\001\n" - "\013ImportState\022\021\n\rImportPending\020\000\022\020\n\014Impor" - "tFailed\020\001\022\021\n\rImportStarted\020\002\022\024\n\020ImportDo" - "wnloaded\020\003\022\020\n\014ImportParsed\020\004\022\023\n\017ImportPe" - "rsisted\020\005\022\023\n\017ImportCompleted\020\006BW\n\016io.mil" - "vus.grpcB\013CommonProtoP\001Z3github.com/milv" - "us-io/milvus/internal/proto/commonpb\240\001\001b" - "\006proto3" + "ceSegments\020\377\001\022\025\n\020DescribeSegments\020\200\002\022\020\n\013" + "CreateIndex\020\254\002\022\022\n\rDescribeIndex\020\255\002\022\016\n\tDr" + "opIndex\020\256\002\022\013\n\006Insert\020\220\003\022\013\n\006Delete\020\221\003\022\n\n\005" + "Flush\020\222\003\022\013\n\006Search\020\364\003\022\021\n\014SearchResult\020\365\003" + "\022\022\n\rGetIndexState\020\366\003\022\032\n\025GetIndexBuildPro" + "gress\020\367\003\022\034\n\027GetCollectionStatistics\020\370\003\022\033" + "\n\026GetPartitionStatistics\020\371\003\022\r\n\010Retrieve\020" + "\372\003\022\023\n\016RetrieveResult\020\373\003\022\024\n\017WatchDmChanne" + "ls\020\374\003\022\025\n\020RemoveDmChannels\020\375\003\022\027\n\022WatchQue" + "ryChannels\020\376\003\022\030\n\023RemoveQueryChannels\020\377\003\022" + "\035\n\030SealedSegmentsChangeInfo\020\200\004\022\027\n\022WatchD" + "eltaChannels\020\201\004\022\020\n\013SegmentInfo\020\330\004\022\017\n\nSys" + "temInfo\020\331\004\022\024\n\017GetRecoveryInfo\020\332\004\022\024\n\017GetS" + "egmentState\020\333\004\022\r\n\010TimeTick\020\260\t\022\023\n\016QueryNo" + "deStats\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016\n\tRequestID\020" + "\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017AllocateSegment\020\265" + "\t\022\026\n\021SegmentStatistics\020\266\t\022\025\n\020SegmentFlus" + "hDone\020\267\t\022\017\n\nDataNodeTt\020\270\t*\"\n\007DslType\022\007\n\003" + "Dsl\020\000\022\016\n\nBoolExprV1\020\001*B\n\017CompactionState" + "\022\021\n\rUndefiedState\020\000\022\r\n\tExecuting\020\001\022\r\n\tCo" + "mpleted\020\002*X\n\020ConsistencyLevel\022\n\n\006Strong\020" + "\000\022\013\n\007Session\020\001\022\013\n\007Bounded\020\002\022\016\n\nEventuall" + "y\020\003\022\016\n\nCustomized\020\004*\227\001\n\013ImportState\022\021\n\rI" + "mportPending\020\000\022\020\n\014ImportFailed\020\001\022\021\n\rImpo" + "rtStarted\020\002\022\024\n\020ImportDownloaded\020\003\022\020\n\014Imp" + "ortParsed\020\004\022\023\n\017ImportPersisted\020\005\022\023\n\017Impo" + "rtCompleted\020\006BW\n\016io.milvus.grpcB\013CommonP" + "rotoP\001Z3github.com/milvus-io/milvus/inte" + "rnal/proto/commonpb\240\001\001b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = { }; @@ -343,7 +343,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", 2927, + &descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2950, &descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 8, 0, schemas, file_default_instances, TableStruct_common_2eproto::offsets, file_level_metadata_common_2eproto, 8, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto, @@ -460,6 +460,7 @@ bool MsgType_IsValid(int value) { case 253: case 254: case 255: + case 256: case 300: case 301: case 302: diff --git a/internal/core/src/pb/common.pb.h b/internal/core/src/pb/common.pb.h index bda83542d1..f280566cad 100644 --- a/internal/core/src/pb/common.pb.h +++ b/internal/core/src/pb/common.pb.h @@ -233,6 +233,7 @@ enum MsgType : int { ReleaseSegments = 253, HandoffSegments = 254, LoadBalanceSegments = 255, + DescribeSegments = 256, CreateIndex = 300, DescribeIndex = 301, DropIndex = 302, diff --git a/internal/datacoord/mock_test.go b/internal/datacoord/mock_test.go index 8daaffbd46..ebefe0cb89 100644 --- a/internal/datacoord/mock_test.go +++ b/internal/datacoord/mock_test.go @@ -383,6 +383,10 @@ func (m *mockRootCoordService) ShowSegments(ctx context.Context, req *milvuspb.S panic("not implemented") // TODO: Implement } +func (m *mockRootCoordService) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + panic("implement me") +} + func (m *mockRootCoordService) GetDdChannel(ctx context.Context) (*milvuspb.StringResponse, error) { return &milvuspb.StringResponse{ Status: &commonpb.Status{ diff --git a/internal/distributed/proxy/service_test.go b/internal/distributed/proxy/service_test.go index b5c7e76c83..07f5701c4a 100644 --- a/internal/distributed/proxy/service_test.go +++ b/internal/distributed/proxy/service_test.go @@ -186,6 +186,10 @@ func (m *MockRootCoord) ShowSegments(ctx context.Context, req *milvuspb.ShowSegm return nil, nil } +func (m *MockRootCoord) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + return nil, nil +} + func (m *MockRootCoord) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) { return nil, nil } diff --git a/internal/distributed/rootcoord/client/client.go b/internal/distributed/rootcoord/client/client.go index 89f9d8c2e2..8ed6bc7054 100644 --- a/internal/distributed/rootcoord/client/client.go +++ b/internal/distributed/rootcoord/client/client.go @@ -392,6 +392,19 @@ func (c *Client) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequ return ret.(*milvuspb.ShowSegmentsResponse), err } +func (c *Client) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { + if !funcutil.CheckCtxValid(ctx) { + return nil, ctx.Err() + } + return client.(rootcoordpb.RootCoordClient).DescribeSegments(ctx, in) + }) + if err != nil || ret == nil { + return nil, err + } + return ret.(*rootcoordpb.DescribeSegmentsResponse), err +} + // ReleaseDQLMessageStream release DQL msgstream func (c *Client) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) { ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) { diff --git a/internal/distributed/rootcoord/service.go b/internal/distributed/rootcoord/service.go index 2718841681..ddbc30f6e4 100644 --- a/internal/distributed/rootcoord/service.go +++ b/internal/distributed/rootcoord/service.go @@ -419,6 +419,10 @@ func (s *Server) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequ return s.rootCoord.ShowSegments(ctx, in) } +func (s *Server) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + return s.rootCoord.DescribeSegments(ctx, in) +} + // ReleaseDQLMessageStream notifies RootCoord to release and close the search message stream of specific collection. func (s *Server) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) { return s.rootCoord.ReleaseDQLMessageStream(ctx, in) diff --git a/internal/metrics/rootcoord_metrics.go b/internal/metrics/rootcoord_metrics.go index d221f5bffc..e389bc4dda 100644 --- a/internal/metrics/rootcoord_metrics.go +++ b/internal/metrics/rootcoord_metrics.go @@ -144,6 +144,15 @@ var ( Help: "Counter of show segments", }, []string{statusLabelName}) + // RootCoordDescribeSegmentsCounter counts the num of calls of DescribeSegments + RootCoordDescribeSegmentsCounter = prometheus.NewCounterVec( + prometheus.CounterOpts{ + Namespace: milvusNamespace, + Subsystem: typeutil.RootCoordRole, + Name: "describe_segments_total", + Help: "Counter of describe segments", + }, []string{statusLabelName}) + //////////////////////////////////////////////////////////////////////////// // for time tick @@ -284,6 +293,7 @@ func RegisterRootCoord(registry *prometheus.Registry) { registry.MustRegister(RootCoordDescribeIndexCounter) registry.MustRegister(RootCoordDescribeSegmentCounter) registry.MustRegister(RootCoordShowSegmentsCounter) + registry.MustRegister(RootCoordDescribeSegmentsCounter) // for time tick registry.MustRegister(RootCoordInsertChannelTimeTick) diff --git a/internal/proto/common.proto b/internal/proto/common.proto index 3c3ee1965c..998c65e819 100644 --- a/internal/proto/common.proto +++ b/internal/proto/common.proto @@ -114,6 +114,7 @@ enum MsgType { ReleaseSegments = 253; HandoffSegments = 254; LoadBalanceSegments = 255; + DescribeSegments = 256; /* DEFINITION REQUESTS: INDEX */ CreateIndex = 300; diff --git a/internal/proto/commonpb/common.pb.go b/internal/proto/commonpb/common.pb.go index a50d37878c..ad0763048b 100644 --- a/internal/proto/commonpb/common.pb.go +++ b/internal/proto/commonpb/common.pb.go @@ -226,6 +226,7 @@ const ( MsgType_ReleaseSegments MsgType = 253 MsgType_HandoffSegments MsgType = 254 MsgType_LoadBalanceSegments MsgType = 255 + MsgType_DescribeSegments MsgType = 256 // DEFINITION REQUESTS: INDEX MsgType_CreateIndex MsgType = 300 MsgType_DescribeIndex MsgType = 301 @@ -292,6 +293,7 @@ var MsgType_name = map[int32]string{ 253: "ReleaseSegments", 254: "HandoffSegments", 255: "LoadBalanceSegments", + 256: "DescribeSegments", 300: "CreateIndex", 301: "DescribeIndex", 302: "DropIndex", @@ -353,6 +355,7 @@ var MsgType_value = map[string]int32{ "ReleaseSegments": 253, "HandoffSegments": 254, "LoadBalanceSegments": 255, + "DescribeSegments": 256, "CreateIndex": 300, "DescribeIndex": 301, "DropIndex": 302, @@ -923,105 +926,106 @@ func init() { func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) } var fileDescriptor_555bd8c177793206 = []byte{ - // 1594 bytes of a gzipped FileDescriptorProto + // 1602 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4b, 0x73, 0x1b, 0xb9, 0x11, 0xd6, 0x70, 0x28, 0x51, 0x04, 0x29, 0x0a, 0x86, 0x1e, 0xd6, 0x3a, 0x4e, 0xca, 0xa5, 0x93, 0x4b, 0x55, 0x6b, 0x27, 0x71, 0x55, 0x72, 0xda, 0x83, 0xc8, 0x91, 0x64, 0x96, 0x2d, 0x99, 0x21, - 0x65, 0xef, 0x56, 0x0e, 0x71, 0x41, 0x33, 0x2d, 0x12, 0x31, 0x06, 0x60, 0x00, 0x8c, 0x24, 0xe6, - 0x94, 0xfc, 0x83, 0x64, 0x2f, 0xb9, 0xe6, 0x9a, 0xaa, 0x24, 0x95, 0x77, 0x52, 0xf9, 0x05, 0x79, - 0x9f, 0xf3, 0xf8, 0x03, 0xf9, 0x01, 0x79, 0xee, 0x33, 0xd5, 0x98, 0xe1, 0xcc, 0x6c, 0xd5, 0xee, - 0x29, 0x37, 0xf4, 0x87, 0xee, 0xaf, 0x1b, 0xdd, 0x8d, 0x06, 0x48, 0x37, 0xd6, 0x69, 0xaa, 0xd5, - 0x83, 0xb9, 0xd1, 0x4e, 0xb3, 0xad, 0x54, 0xc8, 0xab, 0xcc, 0xe6, 0xd2, 0x83, 0x7c, 0x6b, 0xff, - 0x25, 0x59, 0x9b, 0x38, 0xee, 0x32, 0xcb, 0xde, 0x20, 0x04, 0x8c, 0xd1, 0xe6, 0x65, 0xac, 0x13, - 0xd8, 0x0b, 0xee, 0x05, 0xf7, 0x7b, 0x9f, 0xff, 0xcc, 0x83, 0x8f, 0xb1, 0x79, 0x70, 0x84, 0x6a, - 0x03, 0x9d, 0xc0, 0xb8, 0x0d, 0xcb, 0x25, 0xdb, 0x25, 0x6b, 0x06, 0xb8, 0xd5, 0x6a, 0xaf, 0x71, - 0x2f, 0xb8, 0xdf, 0x1e, 0x17, 0xd2, 0xfe, 0x17, 0x48, 0xf7, 0x09, 0x2c, 0x5e, 0x70, 0x99, 0xc1, - 0x88, 0x0b, 0xc3, 0x28, 0x09, 0x5f, 0xc1, 0xc2, 0xf3, 0xb7, 0xc7, 0xb8, 0x64, 0xdb, 0x64, 0xf5, - 0x0a, 0xb7, 0x0b, 0xc3, 0x5c, 0xd8, 0x7f, 0x44, 0x3a, 0x4f, 0x60, 0x11, 0x71, 0xc7, 0x3f, 0xc1, - 0x8c, 0x91, 0x66, 0xc2, 0x1d, 0xf7, 0x56, 0xdd, 0xb1, 0x5f, 0xef, 0xdf, 0x25, 0xcd, 0xbe, 0xd4, - 0x17, 0x15, 0x65, 0xe0, 0x37, 0x0b, 0xca, 0xd7, 0x49, 0xeb, 0x30, 0x49, 0x0c, 0x58, 0xcb, 0x7a, - 0xa4, 0x21, 0xe6, 0x05, 0x5b, 0x43, 0xcc, 0x91, 0x6c, 0xae, 0x8d, 0xf3, 0x64, 0xe1, 0xd8, 0xaf, - 0xf7, 0xdf, 0x0e, 0x48, 0xeb, 0xd4, 0x4e, 0xfb, 0xdc, 0x02, 0xfb, 0x22, 0x59, 0x4f, 0xed, 0xf4, - 0xa5, 0x5b, 0xcc, 0x97, 0xa9, 0xb9, 0xfb, 0xb1, 0xa9, 0x39, 0xb5, 0xd3, 0xf3, 0xc5, 0x1c, 0xc6, - 0xad, 0x34, 0x5f, 0x60, 0x24, 0xa9, 0x9d, 0x0e, 0xa3, 0x82, 0x39, 0x17, 0xd8, 0x5d, 0xd2, 0x76, - 0x22, 0x05, 0xeb, 0x78, 0x3a, 0xdf, 0x0b, 0xef, 0x05, 0xf7, 0x9b, 0xe3, 0x0a, 0x60, 0x77, 0xc8, - 0xba, 0xd5, 0x99, 0x89, 0x61, 0x18, 0xed, 0x35, 0xbd, 0x59, 0x29, 0xef, 0xbf, 0x41, 0xda, 0xa7, - 0x76, 0xfa, 0x18, 0x78, 0x02, 0x86, 0x7d, 0x96, 0x34, 0x2f, 0xb8, 0xcd, 0x23, 0xea, 0x7c, 0x72, - 0x44, 0x78, 0x82, 0xb1, 0xd7, 0xdc, 0xff, 0x0a, 0xe9, 0x46, 0xa7, 0x4f, 0xff, 0x0f, 0x06, 0x0c, - 0xdd, 0xce, 0xb8, 0x49, 0xce, 0x78, 0xba, 0xac, 0x58, 0x05, 0x1c, 0xfc, 0xba, 0x49, 0xda, 0x65, - 0x7b, 0xb0, 0x0e, 0x69, 0x4d, 0xb2, 0x38, 0x06, 0x6b, 0xe9, 0x0a, 0xdb, 0x22, 0x9b, 0xcf, 0x15, - 0xdc, 0xcc, 0x21, 0x76, 0x90, 0x78, 0x1d, 0x1a, 0xb0, 0x5b, 0x64, 0x63, 0xa0, 0x95, 0x82, 0xd8, - 0x1d, 0x73, 0x21, 0x21, 0xa1, 0x0d, 0xb6, 0x4d, 0xe8, 0x08, 0x4c, 0x2a, 0xac, 0x15, 0x5a, 0x45, - 0xa0, 0x04, 0x24, 0x34, 0x64, 0xb7, 0xc9, 0xd6, 0x40, 0x4b, 0x09, 0xb1, 0x13, 0x5a, 0x9d, 0x69, - 0x77, 0x74, 0x23, 0xac, 0xb3, 0xb4, 0x89, 0xb4, 0x43, 0x29, 0x61, 0xca, 0xe5, 0xa1, 0x99, 0x66, - 0x29, 0x28, 0x47, 0x57, 0x91, 0xa3, 0x00, 0x23, 0x91, 0x82, 0x42, 0x26, 0xda, 0xaa, 0xa1, 0x43, - 0x95, 0xc0, 0x0d, 0xd6, 0x87, 0xae, 0xb3, 0xd7, 0xc8, 0x4e, 0x81, 0xd6, 0x1c, 0xf0, 0x14, 0x68, - 0x9b, 0x6d, 0x92, 0x4e, 0xb1, 0x75, 0xfe, 0x6c, 0xf4, 0x84, 0x92, 0x1a, 0xc3, 0x58, 0x5f, 0x8f, - 0x21, 0xd6, 0x26, 0xa1, 0x9d, 0x5a, 0x08, 0x2f, 0x20, 0x76, 0xda, 0x0c, 0x23, 0xda, 0xc5, 0x80, - 0x0b, 0x70, 0x02, 0xdc, 0xc4, 0xb3, 0x31, 0xd8, 0x4c, 0x3a, 0xba, 0xc1, 0x28, 0xe9, 0x1e, 0x0b, - 0x09, 0x67, 0xda, 0x1d, 0xeb, 0x4c, 0x25, 0xb4, 0xc7, 0x7a, 0x84, 0x9c, 0x82, 0xe3, 0x45, 0x06, - 0x36, 0xd1, 0xed, 0x80, 0xc7, 0x33, 0x28, 0x00, 0xca, 0x76, 0x09, 0x1b, 0x70, 0xa5, 0xb4, 0x1b, - 0x18, 0xe0, 0x0e, 0x8e, 0xb5, 0x4c, 0xc0, 0xd0, 0x5b, 0x18, 0xce, 0x47, 0x70, 0x21, 0x81, 0xb2, - 0x4a, 0x3b, 0x02, 0x09, 0xa5, 0xf6, 0x56, 0xa5, 0x5d, 0xe0, 0xa8, 0xbd, 0x8d, 0xc1, 0xf7, 0x33, - 0x21, 0x13, 0x9f, 0x92, 0xbc, 0x2c, 0x3b, 0x18, 0x63, 0x11, 0xfc, 0xd9, 0xd3, 0xe1, 0xe4, 0x9c, - 0xee, 0xb2, 0x1d, 0x72, 0xab, 0x40, 0x4e, 0xc1, 0x19, 0x11, 0xfb, 0xe4, 0xdd, 0xc6, 0x50, 0x9f, - 0x65, 0xee, 0xd9, 0xe5, 0x29, 0xa4, 0xda, 0x2c, 0xe8, 0x1e, 0x16, 0xd4, 0x33, 0x2d, 0x4b, 0x44, - 0x5f, 0x43, 0x0f, 0x47, 0xe9, 0xdc, 0x2d, 0xaa, 0xf4, 0xd2, 0x3b, 0x8c, 0x91, 0x8d, 0x28, 0x1a, - 0xc3, 0xd7, 0x32, 0xb0, 0x6e, 0xcc, 0x63, 0xa0, 0x7f, 0x6f, 0x1d, 0xbc, 0x45, 0x88, 0xb7, 0xc5, - 0x81, 0x04, 0x8c, 0x91, 0x5e, 0x25, 0x9d, 0x69, 0x05, 0x74, 0x85, 0x75, 0xc9, 0xfa, 0x73, 0x25, - 0xac, 0xcd, 0x20, 0xa1, 0x01, 0xe6, 0x6d, 0xa8, 0x46, 0x46, 0x4f, 0xf1, 0x4a, 0xd3, 0x06, 0xee, - 0x1e, 0x0b, 0x25, 0xec, 0xcc, 0x77, 0x0c, 0x21, 0x6b, 0x45, 0x02, 0x9b, 0x07, 0x96, 0x74, 0x27, - 0x30, 0xc5, 0xe6, 0xc8, 0xb9, 0xb7, 0x09, 0xad, 0xcb, 0x15, 0x7b, 0x19, 0x76, 0x80, 0xcd, 0x7b, - 0x62, 0xf4, 0xb5, 0x50, 0x53, 0xda, 0x40, 0xb2, 0x09, 0x70, 0xe9, 0x89, 0x3b, 0xa4, 0x75, 0x2c, - 0x33, 0xef, 0xa5, 0xe9, 0x7d, 0xa2, 0x80, 0x6a, 0xab, 0xb8, 0x15, 0x19, 0x3d, 0x9f, 0x43, 0x42, - 0xd7, 0x0e, 0xbe, 0xd7, 0xf6, 0xf3, 0xc3, 0x8f, 0x81, 0x0d, 0xd2, 0x7e, 0xae, 0x12, 0xb8, 0x14, - 0x0a, 0x12, 0xba, 0xe2, 0x4b, 0xe1, 0x4b, 0x56, 0xcb, 0x49, 0x82, 0x27, 0x46, 0xeb, 0x1a, 0x06, - 0x98, 0xcf, 0xc7, 0xdc, 0xd6, 0xa0, 0x4b, 0xac, 0x6f, 0x04, 0x36, 0x36, 0xe2, 0xa2, 0x6e, 0x3e, - 0xc5, 0x3c, 0x4f, 0x66, 0xfa, 0xba, 0xc2, 0x2c, 0x9d, 0xa1, 0xa7, 0x13, 0x70, 0x93, 0x85, 0x75, - 0x90, 0x0e, 0xb4, 0xba, 0x14, 0x53, 0x4b, 0x05, 0x7a, 0x7a, 0xaa, 0x79, 0x52, 0x33, 0xff, 0x2a, - 0x56, 0x78, 0x0c, 0x12, 0xb8, 0xad, 0xb3, 0xbe, 0xf2, 0xcd, 0xe8, 0x43, 0x3d, 0x94, 0x82, 0x5b, - 0x2a, 0xf1, 0x28, 0x18, 0x65, 0x2e, 0xa6, 0x58, 0x84, 0x43, 0xe9, 0xc0, 0xe4, 0xb2, 0x62, 0xdb, - 0x64, 0x33, 0xd7, 0x1f, 0x71, 0xe3, 0x84, 0x27, 0xf9, 0x4d, 0xe0, 0xcb, 0x6d, 0xf4, 0xbc, 0xc2, - 0x7e, 0x8b, 0x77, 0xbf, 0xfb, 0x98, 0xdb, 0x0a, 0xfa, 0x5d, 0xc0, 0x76, 0xc9, 0xad, 0xe5, 0xd1, - 0x2a, 0xfc, 0xf7, 0x01, 0xdb, 0x22, 0x3d, 0x3c, 0x5a, 0x89, 0x59, 0xfa, 0x07, 0x0f, 0xe2, 0x21, - 0x6a, 0xe0, 0x1f, 0x3d, 0x43, 0x71, 0x8a, 0x1a, 0xfe, 0x27, 0xef, 0x0c, 0x19, 0x8a, 0xaa, 0x5b, - 0xfa, 0x4e, 0x80, 0x91, 0x2e, 0x9d, 0x15, 0x30, 0x7d, 0xd7, 0x2b, 0x22, 0x6b, 0xa9, 0xf8, 0x9e, - 0x57, 0x2c, 0x38, 0x4b, 0xf4, 0x7d, 0x8f, 0x3e, 0xe6, 0x2a, 0xd1, 0x97, 0x97, 0x25, 0xfa, 0x41, - 0xc0, 0xf6, 0xc8, 0x16, 0x9a, 0xf7, 0xb9, 0xe4, 0x2a, 0xae, 0xf4, 0x3f, 0x0c, 0x18, 0x5d, 0x26, - 0xd2, 0x77, 0x35, 0xfd, 0x7e, 0xc3, 0x27, 0xa5, 0x08, 0x20, 0xc7, 0x7e, 0xd0, 0x60, 0xbd, 0x3c, - 0xbb, 0xb9, 0xfc, 0xc3, 0x06, 0xeb, 0x90, 0xb5, 0xa1, 0xb2, 0x60, 0x1c, 0xfd, 0x16, 0x76, 0xde, - 0x5a, 0x7e, 0x77, 0xe9, 0xb7, 0xb1, 0xbf, 0x57, 0x7d, 0xe7, 0xd1, 0xb7, 0xfd, 0x46, 0x3e, 0x65, - 0xe8, 0x3f, 0x42, 0x7f, 0xd4, 0xfa, 0xc8, 0xf9, 0x67, 0x88, 0x9e, 0x4e, 0xc0, 0x55, 0xd7, 0x89, - 0xfe, 0x2b, 0x64, 0x77, 0xc8, 0xce, 0x12, 0xf3, 0x03, 0xa0, 0xbc, 0x48, 0xff, 0x0e, 0xd9, 0x5d, - 0x72, 0xfb, 0x04, 0x5c, 0xd5, 0x07, 0x68, 0x24, 0xac, 0x13, 0xb1, 0xa5, 0xff, 0x09, 0xd9, 0xa7, - 0xc8, 0xee, 0x09, 0xb8, 0x32, 0xbf, 0xb5, 0xcd, 0xff, 0x86, 0x6c, 0x83, 0xac, 0x8f, 0x71, 0x42, - 0xc0, 0x15, 0xd0, 0x77, 0x42, 0x2c, 0xd2, 0x52, 0x2c, 0xc2, 0x79, 0x37, 0xc4, 0xd4, 0xbd, 0xc9, - 0x5d, 0x3c, 0x8b, 0xd2, 0xc1, 0x8c, 0x2b, 0x05, 0xd2, 0xd2, 0xf7, 0x42, 0xb6, 0x43, 0xe8, 0x18, - 0x52, 0x7d, 0x05, 0x35, 0xf8, 0x7d, 0x9c, 0xfc, 0xcc, 0x2b, 0x7f, 0x29, 0x03, 0xb3, 0x28, 0x37, - 0x3e, 0x08, 0x31, 0xd5, 0xb9, 0xfe, 0x47, 0x77, 0x3e, 0x0c, 0xd9, 0xa7, 0xc9, 0x5e, 0x7e, 0x5b, - 0x97, 0xf9, 0xc7, 0xcd, 0x29, 0x0c, 0xd5, 0xa5, 0xa6, 0xdf, 0x68, 0x96, 0x8c, 0x11, 0x48, 0xc7, - 0x4b, 0xbb, 0x6f, 0x36, 0xb1, 0x44, 0x85, 0x85, 0x57, 0xfd, 0x73, 0x93, 0x6d, 0x12, 0x92, 0xdf, - 0x1d, 0x0f, 0xfc, 0xa5, 0x89, 0xa1, 0x9f, 0x80, 0xc3, 0xd1, 0x7f, 0x05, 0x66, 0xe1, 0xd1, 0xbf, - 0x2e, 0xd1, 0xfa, 0x48, 0xa1, 0x7f, 0x6b, 0x62, 0x2a, 0xce, 0x45, 0x0a, 0xe7, 0x22, 0x7e, 0x45, - 0x7f, 0xd4, 0xc6, 0x54, 0xf8, 0x48, 0xcf, 0x74, 0x02, 0xa8, 0x63, 0xe9, 0x8f, 0xdb, 0x58, 0x6f, - 0xec, 0x97, 0xbc, 0xde, 0x3f, 0xf1, 0x72, 0x31, 0x15, 0x87, 0x11, 0xfd, 0x29, 0x3e, 0x41, 0xa4, - 0x90, 0xcf, 0x27, 0xcf, 0xe8, 0xcf, 0xda, 0xe8, 0xea, 0x50, 0x4a, 0x1d, 0x73, 0x57, 0x76, 0xed, - 0xcf, 0xdb, 0xd8, 0xf6, 0x35, 0xef, 0x45, 0x35, 0x7e, 0xd1, 0xc6, 0x9c, 0x16, 0xb8, 0xef, 0x95, - 0x08, 0x07, 0xdd, 0x2f, 0x3d, 0x2b, 0xfe, 0xac, 0x30, 0x92, 0x73, 0x47, 0x7f, 0xd5, 0x3e, 0xd8, - 0x27, 0xad, 0xc8, 0x4a, 0x3f, 0xaa, 0x5a, 0x24, 0x8c, 0xac, 0xa4, 0x2b, 0x78, 0xb3, 0xfb, 0x5a, - 0xcb, 0xa3, 0x9b, 0xb9, 0x79, 0xf1, 0x39, 0x1a, 0x1c, 0xf4, 0xc9, 0xe6, 0x40, 0xa7, 0x73, 0x5e, - 0x76, 0x84, 0x9f, 0x4e, 0xf9, 0x58, 0x83, 0x24, 0x3f, 0xf5, 0x0a, 0x8e, 0x87, 0xa3, 0x1b, 0x88, - 0x33, 0x87, 0x13, 0x31, 0x40, 0x11, 0x8d, 0xb0, 0x69, 0x13, 0xda, 0x38, 0x78, 0x8b, 0xd0, 0x81, - 0x56, 0x56, 0x58, 0x07, 0x2a, 0x5e, 0x3c, 0x85, 0x2b, 0x90, 0x7e, 0xb6, 0x3a, 0xa3, 0xd5, 0x94, - 0xae, 0xf8, 0x1f, 0x03, 0xf8, 0x97, 0x3f, 0x9f, 0xc0, 0x7d, 0x7c, 0x22, 0xfd, 0xb7, 0xa0, 0x47, - 0xc8, 0xd1, 0x15, 0x28, 0x97, 0x71, 0x29, 0x17, 0x34, 0x44, 0x79, 0x90, 0x59, 0xa7, 0x53, 0xf1, - 0x75, 0x3f, 0xe2, 0xbf, 0x13, 0x90, 0xce, 0x30, 0xc5, 0x8f, 0x5b, 0x19, 0x5a, 0x2e, 0x8e, 0x40, - 0x25, 0xc2, 0x93, 0xe3, 0xab, 0xe6, 0xa1, 0xe2, 0x5d, 0x08, 0x2a, 0xa5, 0x89, 0xe3, 0xc6, 0x2d, - 0xbf, 0x1f, 0x39, 0x14, 0xe9, 0x6b, 0x25, 0x35, 0x4f, 0xfc, 0xcc, 0x2f, 0x4d, 0x47, 0xdc, 0x58, - 0x3f, 0xf8, 0xf1, 0xd1, 0x2f, 0xf8, 0x8d, 0x3f, 0x4f, 0x42, 0x57, 0x2b, 0xb0, 0x3a, 0xf3, 0x5a, - 0xff, 0x4d, 0xd2, 0x13, 0x7a, 0xf9, 0xb3, 0x9a, 0x9a, 0x79, 0xdc, 0xef, 0x0c, 0xfc, 0xcf, 0x6a, - 0x84, 0xbf, 0xac, 0x51, 0xf0, 0xe5, 0x47, 0x53, 0xe1, 0x66, 0xd9, 0x05, 0xfe, 0xb7, 0x1e, 0xe6, - 0x6a, 0xaf, 0x0b, 0x5d, 0xac, 0x1e, 0x0a, 0xe5, 0xc0, 0x28, 0x2e, 0x1f, 0xfa, 0x3f, 0xd9, 0xc3, - 0xfc, 0x4f, 0x36, 0xbf, 0xf8, 0x6e, 0x10, 0x5c, 0xac, 0x79, 0xe8, 0xd1, 0xff, 0x02, 0x00, 0x00, - 0xff, 0xff, 0x13, 0x8a, 0x26, 0xfd, 0xe7, 0x0b, 0x00, 0x00, + 0x65, 0xef, 0x56, 0x0e, 0x71, 0x41, 0x33, 0x2d, 0x12, 0x31, 0x06, 0x60, 0x00, 0x8c, 0x2c, 0xe6, + 0xb4, 0xf9, 0x07, 0xc9, 0x5e, 0x72, 0xcd, 0x0f, 0x48, 0x52, 0x79, 0x27, 0x95, 0x53, 0x8e, 0x79, + 0x9f, 0xf3, 0xf8, 0x03, 0xf9, 0x01, 0x79, 0xee, 0x33, 0xd5, 0x98, 0xe1, 0xcc, 0x6c, 0x6a, 0x7d, + 0xca, 0x0d, 0xfd, 0xa1, 0xfb, 0x43, 0xa3, 0xbb, 0xd1, 0x68, 0xd2, 0x8d, 0x75, 0x9a, 0x6a, 0x75, + 0x6f, 0x6e, 0xb4, 0xd3, 0x6c, 0x2b, 0x15, 0xf2, 0x2a, 0xb3, 0xb9, 0x74, 0x2f, 0xdf, 0xda, 0x7f, + 0x4e, 0xd6, 0x26, 0x8e, 0xbb, 0xcc, 0xb2, 0x37, 0x08, 0x01, 0x63, 0xb4, 0x79, 0x1e, 0xeb, 0x04, + 0xf6, 0x82, 0x3b, 0xc1, 0xdd, 0xde, 0xe7, 0x3f, 0x73, 0xef, 0x13, 0x6c, 0xee, 0x1d, 0xa1, 0xda, + 0x40, 0x27, 0x30, 0x6e, 0xc3, 0x72, 0xc9, 0x76, 0xc9, 0x9a, 0x01, 0x6e, 0xb5, 0xda, 0x6b, 0xdc, + 0x09, 0xee, 0xb6, 0xc7, 0x85, 0xb4, 0xff, 0x05, 0xd2, 0x7d, 0x04, 0x8b, 0x67, 0x5c, 0x66, 0x30, + 0xe2, 0xc2, 0x30, 0x4a, 0xc2, 0x17, 0xb0, 0xf0, 0xfc, 0xed, 0x31, 0x2e, 0xd9, 0x36, 0x59, 0xbd, + 0xc2, 0xed, 0xc2, 0x30, 0x17, 0xf6, 0x1f, 0x90, 0xce, 0x23, 0x58, 0x44, 0xdc, 0xf1, 0x57, 0x98, + 0x31, 0xd2, 0x4c, 0xb8, 0xe3, 0xde, 0xaa, 0x3b, 0xf6, 0xeb, 0xfd, 0xdb, 0xa4, 0xd9, 0x97, 0xfa, + 0xa2, 0xa2, 0x0c, 0xfc, 0x66, 0x41, 0xf9, 0x3a, 0x69, 0x1d, 0x26, 0x89, 0x01, 0x6b, 0x59, 0x8f, + 0x34, 0xc4, 0xbc, 0x60, 0x6b, 0x88, 0x39, 0x92, 0xcd, 0xb5, 0x71, 0x9e, 0x2c, 0x1c, 0xfb, 0xf5, + 0xfe, 0x3b, 0x01, 0x69, 0x9d, 0xda, 0x69, 0x9f, 0x5b, 0x60, 0x5f, 0x24, 0xeb, 0xa9, 0x9d, 0x3e, + 0x77, 0x8b, 0xf9, 0x32, 0x34, 0xb7, 0x3f, 0x31, 0x34, 0xa7, 0x76, 0x7a, 0xbe, 0x98, 0xc3, 0xb8, + 0x95, 0xe6, 0x0b, 0xf4, 0x24, 0xb5, 0xd3, 0x61, 0x54, 0x30, 0xe7, 0x02, 0xbb, 0x4d, 0xda, 0x4e, + 0xa4, 0x60, 0x1d, 0x4f, 0xe7, 0x7b, 0xe1, 0x9d, 0xe0, 0x6e, 0x73, 0x5c, 0x01, 0xec, 0x16, 0x59, + 0xb7, 0x3a, 0x33, 0x31, 0x0c, 0xa3, 0xbd, 0xa6, 0x37, 0x2b, 0xe5, 0xfd, 0x37, 0x48, 0xfb, 0xd4, + 0x4e, 0x1f, 0x02, 0x4f, 0xc0, 0xb0, 0xcf, 0x92, 0xe6, 0x05, 0xb7, 0xb9, 0x47, 0x9d, 0x57, 0x7b, + 0x84, 0x37, 0x18, 0x7b, 0xcd, 0xfd, 0xaf, 0x90, 0x6e, 0x74, 0xfa, 0xf8, 0xff, 0x60, 0x40, 0xd7, + 0xed, 0x8c, 0x9b, 0xe4, 0x8c, 0xa7, 0xcb, 0x8c, 0x55, 0xc0, 0xc1, 0x2f, 0x9b, 0xa4, 0x5d, 0x96, + 0x07, 0xeb, 0x90, 0xd6, 0x24, 0x8b, 0x63, 0xb0, 0x96, 0xae, 0xb0, 0x2d, 0xb2, 0xf9, 0x54, 0xc1, + 0xf5, 0x1c, 0x62, 0x07, 0x89, 0xd7, 0xa1, 0x01, 0xbb, 0x41, 0x36, 0x06, 0x5a, 0x29, 0x88, 0xdd, + 0x31, 0x17, 0x12, 0x12, 0xda, 0x60, 0xdb, 0x84, 0x8e, 0xc0, 0xa4, 0xc2, 0x5a, 0xa1, 0x55, 0x04, + 0x4a, 0x40, 0x42, 0x43, 0x76, 0x93, 0x6c, 0x0d, 0xb4, 0x94, 0x10, 0x3b, 0xa1, 0xd5, 0x99, 0x76, + 0x47, 0xd7, 0xc2, 0x3a, 0x4b, 0x9b, 0x48, 0x3b, 0x94, 0x12, 0xa6, 0x5c, 0x1e, 0x9a, 0x69, 0x96, + 0x82, 0x72, 0x74, 0x15, 0x39, 0x0a, 0x30, 0x12, 0x29, 0x28, 0x64, 0xa2, 0xad, 0x1a, 0x3a, 0x54, + 0x09, 0x5c, 0x63, 0x7e, 0xe8, 0x3a, 0x7b, 0x8d, 0xec, 0x14, 0x68, 0xed, 0x00, 0x9e, 0x02, 0x6d, + 0xb3, 0x4d, 0xd2, 0x29, 0xb6, 0xce, 0x9f, 0x8c, 0x1e, 0x51, 0x52, 0x63, 0x18, 0xeb, 0x97, 0x63, + 0x88, 0xb5, 0x49, 0x68, 0xa7, 0xe6, 0xc2, 0x33, 0x88, 0x9d, 0x36, 0xc3, 0x88, 0x76, 0xd1, 0xe1, + 0x02, 0x9c, 0x00, 0x37, 0xf1, 0x6c, 0x0c, 0x36, 0x93, 0x8e, 0x6e, 0x30, 0x4a, 0xba, 0xc7, 0x42, + 0xc2, 0x99, 0x76, 0xc7, 0x3a, 0x53, 0x09, 0xed, 0xb1, 0x1e, 0x21, 0xa7, 0xe0, 0x78, 0x11, 0x81, + 0x4d, 0x3c, 0x76, 0xc0, 0xe3, 0x19, 0x14, 0x00, 0x65, 0xbb, 0x84, 0x0d, 0xb8, 0x52, 0xda, 0x0d, + 0x0c, 0x70, 0x07, 0xc7, 0x5a, 0x26, 0x60, 0xe8, 0x0d, 0x74, 0xe7, 0x63, 0xb8, 0x90, 0x40, 0x59, + 0xa5, 0x1d, 0x81, 0x84, 0x52, 0x7b, 0xab, 0xd2, 0x2e, 0x70, 0xd4, 0xde, 0x46, 0xe7, 0xfb, 0x99, + 0x90, 0x89, 0x0f, 0x49, 0x9e, 0x96, 0x1d, 0xf4, 0xb1, 0x70, 0xfe, 0xec, 0xf1, 0x70, 0x72, 0x4e, + 0x77, 0xd9, 0x0e, 0xb9, 0x51, 0x20, 0xa7, 0xe0, 0x8c, 0x88, 0x7d, 0xf0, 0x6e, 0xa2, 0xab, 0x4f, + 0x32, 0xf7, 0xe4, 0xf2, 0x14, 0x52, 0x6d, 0x16, 0x74, 0x0f, 0x13, 0xea, 0x99, 0x96, 0x29, 0xa2, + 0xaf, 0xe1, 0x09, 0x47, 0xe9, 0xdc, 0x2d, 0xaa, 0xf0, 0xd2, 0x5b, 0x8c, 0x91, 0x8d, 0x28, 0x1a, + 0xc3, 0xd7, 0x32, 0xb0, 0x6e, 0xcc, 0x63, 0xa0, 0x7f, 0x6b, 0x1d, 0xbc, 0x45, 0x88, 0xb7, 0xc5, + 0x86, 0x04, 0x8c, 0x91, 0x5e, 0x25, 0x9d, 0x69, 0x05, 0x74, 0x85, 0x75, 0xc9, 0xfa, 0x53, 0x25, + 0xac, 0xcd, 0x20, 0xa1, 0x01, 0xc6, 0x6d, 0xa8, 0x46, 0x46, 0x4f, 0xf1, 0x49, 0xd3, 0x06, 0xee, + 0x1e, 0x0b, 0x25, 0xec, 0xcc, 0x57, 0x0c, 0x21, 0x6b, 0x45, 0x00, 0x9b, 0x07, 0x96, 0x74, 0x27, + 0x30, 0xc5, 0xe2, 0xc8, 0xb9, 0xb7, 0x09, 0xad, 0xcb, 0x15, 0x7b, 0xe9, 0x76, 0x80, 0xc5, 0x7b, + 0x62, 0xf4, 0x4b, 0xa1, 0xa6, 0xb4, 0x81, 0x64, 0x13, 0xe0, 0xd2, 0x13, 0x77, 0x48, 0xeb, 0x58, + 0x66, 0xfe, 0x94, 0xa6, 0x3f, 0x13, 0x05, 0x54, 0x5b, 0xc5, 0xad, 0xc8, 0xe8, 0xf9, 0x1c, 0x12, + 0xba, 0x76, 0xf0, 0xab, 0xb6, 0xef, 0x1f, 0xbe, 0x0d, 0x6c, 0x90, 0xf6, 0x53, 0x95, 0xc0, 0xa5, + 0x50, 0x90, 0xd0, 0x15, 0x9f, 0x0a, 0x9f, 0xb2, 0x5a, 0x4c, 0x12, 0xbc, 0x31, 0x5a, 0xd7, 0x30, + 0xc0, 0x78, 0x3e, 0xe4, 0xb6, 0x06, 0x5d, 0x62, 0x7e, 0x23, 0xb0, 0xb1, 0x11, 0x17, 0x75, 0xf3, + 0x29, 0xc6, 0x79, 0x32, 0xd3, 0x2f, 0x2b, 0xcc, 0xd2, 0x19, 0x9e, 0x74, 0x02, 0x6e, 0xb2, 0xb0, + 0x0e, 0xd2, 0x81, 0x56, 0x97, 0x62, 0x6a, 0xa9, 0xc0, 0x93, 0x1e, 0x6b, 0x9e, 0xd4, 0xcc, 0xbf, + 0x8a, 0x19, 0x1e, 0x83, 0x04, 0x6e, 0xeb, 0xac, 0x2f, 0x7c, 0x31, 0x7a, 0x57, 0x0f, 0xa5, 0xe0, + 0x96, 0x4a, 0xbc, 0x0a, 0x7a, 0x99, 0x8b, 0x29, 0x26, 0xe1, 0x50, 0x3a, 0x30, 0xb9, 0xac, 0xd8, + 0x36, 0xd9, 0xcc, 0xf5, 0x47, 0xdc, 0x38, 0xe1, 0x49, 0x7e, 0x1d, 0xf8, 0x74, 0x1b, 0x3d, 0xaf, + 0xb0, 0xdf, 0xe0, 0xdb, 0xef, 0x3e, 0xe4, 0xb6, 0x82, 0x7e, 0x1b, 0xb0, 0x5d, 0x72, 0x63, 0x79, + 0xb5, 0x0a, 0xff, 0x5d, 0xc0, 0xb6, 0x48, 0x0f, 0xaf, 0x56, 0x62, 0x96, 0xfe, 0xde, 0x83, 0x78, + 0x89, 0x1a, 0xf8, 0x07, 0xcf, 0x50, 0xdc, 0xa2, 0x86, 0xff, 0xd1, 0x1f, 0x86, 0x0c, 0x45, 0xd6, + 0x2d, 0x7d, 0x37, 0x40, 0x4f, 0x97, 0x87, 0x15, 0x30, 0x7d, 0xcf, 0x2b, 0x22, 0x6b, 0xa9, 0xf8, + 0xbe, 0x57, 0x2c, 0x38, 0x4b, 0xf4, 0x03, 0x8f, 0x3e, 0xe4, 0x2a, 0xd1, 0x97, 0x97, 0x25, 0xfa, + 0x61, 0xc0, 0xf6, 0xc8, 0x16, 0x9a, 0xf7, 0xb9, 0xe4, 0x2a, 0xae, 0xf4, 0x3f, 0x0a, 0xd8, 0x0e, + 0xa1, 0xff, 0x73, 0x9c, 0xa5, 0x6f, 0x37, 0x18, 0x5d, 0xc6, 0xd7, 0x17, 0x3b, 0xfd, 0x6e, 0xc3, + 0xc7, 0xaa, 0x50, 0xcc, 0xb1, 0xef, 0x35, 0x58, 0x2f, 0x0f, 0x7a, 0x2e, 0x7f, 0xbf, 0xc1, 0x3a, + 0x64, 0x6d, 0xa8, 0x2c, 0x18, 0x47, 0xbf, 0x89, 0x05, 0xb9, 0x96, 0x3f, 0x69, 0xfa, 0x2d, 0x2c, + 0xfb, 0x55, 0x5f, 0x90, 0xf4, 0x1d, 0xbf, 0x91, 0x37, 0x1f, 0xfa, 0xf7, 0xd0, 0x47, 0xa0, 0xde, + 0x89, 0xfe, 0x11, 0xe2, 0x49, 0x27, 0xe0, 0xaa, 0x57, 0x46, 0xff, 0x19, 0xb2, 0x5b, 0x64, 0x67, + 0x89, 0xf9, 0xbe, 0x50, 0xbe, 0xaf, 0x7f, 0x85, 0xec, 0x36, 0xb9, 0x79, 0x02, 0xae, 0x2a, 0x0f, + 0x34, 0x12, 0xd6, 0x89, 0xd8, 0xd2, 0x7f, 0x87, 0xec, 0x53, 0x64, 0xf7, 0x04, 0x5c, 0x19, 0xf6, + 0xda, 0xe6, 0x7f, 0x42, 0xb6, 0x41, 0xd6, 0xc7, 0xd8, 0x38, 0xe0, 0x0a, 0xe8, 0xbb, 0x21, 0xe6, + 0x6e, 0x29, 0x16, 0xee, 0xbc, 0x17, 0x62, 0x44, 0xdf, 0xe4, 0x2e, 0x9e, 0x45, 0xe9, 0x60, 0xc6, + 0x95, 0x02, 0x69, 0xe9, 0xfb, 0x21, 0xc6, 0x6d, 0x0c, 0xa9, 0xbe, 0x82, 0x1a, 0xfc, 0x01, 0x7e, + 0x08, 0xcc, 0x2b, 0x7f, 0x29, 0x03, 0xb3, 0x28, 0x37, 0x3e, 0x0c, 0x31, 0x03, 0xb9, 0xfe, 0xc7, + 0x77, 0x3e, 0x0a, 0xd9, 0xa7, 0xc9, 0x5e, 0xfe, 0x88, 0x97, 0xf1, 0xc7, 0xcd, 0x29, 0x0c, 0xd5, + 0xa5, 0xa6, 0x6f, 0x37, 0x4b, 0xc6, 0x08, 0xa4, 0xe3, 0xa5, 0xdd, 0x37, 0x9a, 0x98, 0xa2, 0xc2, + 0xc2, 0xab, 0xfe, 0xa9, 0xc9, 0x36, 0x09, 0xc9, 0x9f, 0x94, 0x07, 0xfe, 0xdc, 0x44, 0xd7, 0x4f, + 0xc0, 0xe1, 0x8f, 0x70, 0x05, 0x66, 0xe1, 0xd1, 0xbf, 0x2c, 0xd1, 0x7a, 0xa7, 0xa1, 0x7f, 0x6d, + 0x62, 0x28, 0xce, 0x45, 0x0a, 0xe7, 0x22, 0x7e, 0x41, 0x7f, 0xd0, 0xc6, 0x50, 0x78, 0x4f, 0xcf, + 0x74, 0x02, 0xa8, 0x63, 0xe9, 0x0f, 0xdb, 0x98, 0x6f, 0x2c, 0xa3, 0x3c, 0xdf, 0x3f, 0xf2, 0x72, + 0xd1, 0x2c, 0x87, 0x11, 0xfd, 0x31, 0xfe, 0x4c, 0xa4, 0x90, 0xcf, 0x27, 0x4f, 0xe8, 0x4f, 0xda, + 0x78, 0xd4, 0xa1, 0x94, 0x3a, 0xe6, 0xae, 0x2c, 0xe6, 0x9f, 0xb6, 0xf1, 0x35, 0xd4, 0x4e, 0x2f, + 0xb2, 0xf1, 0xb3, 0x36, 0xc6, 0xb4, 0xc0, 0x7d, 0xad, 0x44, 0xd8, 0xff, 0x7e, 0xee, 0x59, 0x71, + 0xe0, 0x42, 0x4f, 0xce, 0x1d, 0xfd, 0x45, 0xfb, 0x60, 0x9f, 0xb4, 0x22, 0x2b, 0x7d, 0x07, 0x6b, + 0x91, 0x30, 0xb2, 0x92, 0xae, 0xe0, 0x83, 0xef, 0x6b, 0x2d, 0x8f, 0xae, 0xe7, 0xe6, 0xd9, 0xe7, + 0x68, 0x70, 0xd0, 0x27, 0x9b, 0x03, 0x9d, 0xce, 0x79, 0x59, 0x11, 0xbe, 0x69, 0xe5, 0xdd, 0x0e, + 0x92, 0xfc, 0xd6, 0x2b, 0xd8, 0x35, 0x8e, 0xae, 0x21, 0xce, 0x1c, 0x36, 0xca, 0x00, 0x45, 0x34, + 0xc2, 0xa2, 0x4d, 0x68, 0xe3, 0xe0, 0x2d, 0x42, 0x07, 0x5a, 0x59, 0x61, 0x1d, 0xa8, 0x78, 0xf1, + 0x18, 0xae, 0x40, 0xfa, 0x96, 0xeb, 0x8c, 0x56, 0x53, 0xba, 0xe2, 0x07, 0x09, 0xf0, 0x03, 0x41, + 0xde, 0x98, 0xfb, 0xf8, 0x73, 0xfa, 0x69, 0xa1, 0x47, 0xc8, 0xd1, 0x15, 0x28, 0x97, 0x71, 0x29, + 0x17, 0x34, 0x44, 0x79, 0x90, 0x59, 0xa7, 0x53, 0xf1, 0x75, 0xdf, 0xf9, 0xbf, 0x1d, 0x90, 0xce, + 0x30, 0xc5, 0x79, 0xae, 0x74, 0x2d, 0x17, 0x47, 0xa0, 0x12, 0xe1, 0xc9, 0xf1, 0xb3, 0xf3, 0x50, + 0xf1, 0x5d, 0x04, 0x95, 0xd2, 0xc4, 0x71, 0xe3, 0x96, 0x53, 0x49, 0x0e, 0x45, 0xfa, 0xa5, 0x92, + 0x9a, 0x27, 0xfe, 0x2b, 0x28, 0x4d, 0x47, 0xdc, 0x58, 0xff, 0x1f, 0xe0, 0x2c, 0x50, 0xf0, 0x1b, + 0x7f, 0x9f, 0x84, 0xae, 0x56, 0x60, 0x75, 0xe7, 0xb5, 0xfe, 0x9b, 0xa4, 0x27, 0xf4, 0x72, 0xe0, + 0x9a, 0x9a, 0x79, 0xdc, 0xef, 0x0c, 0xfc, 0xc0, 0x35, 0xc2, 0xe1, 0x6b, 0x14, 0x7c, 0xf9, 0xc1, + 0x54, 0xb8, 0x59, 0x76, 0x81, 0x63, 0xd8, 0xfd, 0x5c, 0xed, 0x75, 0xa1, 0x8b, 0xd5, 0x7d, 0xa1, + 0x1c, 0x18, 0xc5, 0xe5, 0x7d, 0x3f, 0xaa, 0xdd, 0xcf, 0x47, 0xb5, 0xf9, 0xc5, 0x77, 0x82, 0xe0, + 0x62, 0xcd, 0x43, 0x0f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x5a, 0x7d, 0x9d, 0x36, 0xfe, 0x0b, + 0x00, 0x00, } diff --git a/internal/proto/query_coord.proto b/internal/proto/query_coord.proto index 85b329e3f6..32bf99db4e 100644 --- a/internal/proto/query_coord.proto +++ b/internal/proto/query_coord.proto @@ -202,11 +202,11 @@ message SegmentLoadInfo { repeated data.FieldBinlog statslogs = 8; repeated data.FieldBinlog deltalogs = 9; repeated int64 compactionFrom = 10; // segmentIDs compacted from - repeated VecFieldIndexInfo index_infos = 11; + repeated FieldIndexInfo index_infos = 11; int64 segment_size = 12; } -message VecFieldIndexInfo { +message FieldIndexInfo { int64 fieldID =1; bool enable_index = 2; string index_name = 3; @@ -321,7 +321,7 @@ message SegmentInfo { repeated int64 compactionFrom = 10; bool createdByCompaction = 11; common.SegmentState segment_state = 12; - repeated VecFieldIndexInfo index_infos = 13; + repeated FieldIndexInfo index_infos = 13; repeated int64 replica_ids = 14; repeated int64 node_ids = 15; } diff --git a/internal/proto/querypb/query_coord.pb.go b/internal/proto/querypb/query_coord.pb.go index f4427bef4c..2d21a5bb9c 100644 --- a/internal/proto/querypb/query_coord.pb.go +++ b/internal/proto/querypb/query_coord.pb.go @@ -1351,7 +1351,7 @@ type SegmentLoadInfo struct { Statslogs []*datapb.FieldBinlog `protobuf:"bytes,8,rep,name=statslogs,proto3" json:"statslogs,omitempty"` Deltalogs []*datapb.FieldBinlog `protobuf:"bytes,9,rep,name=deltalogs,proto3" json:"deltalogs,omitempty"` CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"` - IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,11,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` + IndexInfos []*FieldIndexInfo `protobuf:"bytes,11,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` SegmentSize int64 `protobuf:"varint,12,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1453,7 +1453,7 @@ func (m *SegmentLoadInfo) GetCompactionFrom() []int64 { return nil } -func (m *SegmentLoadInfo) GetIndexInfos() []*VecFieldIndexInfo { +func (m *SegmentLoadInfo) GetIndexInfos() []*FieldIndexInfo { if m != nil { return m.IndexInfos } @@ -1467,7 +1467,7 @@ func (m *SegmentLoadInfo) GetSegmentSize() int64 { return 0 } -type VecFieldIndexInfo struct { +type FieldIndexInfo struct { FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"` EnableIndex bool `protobuf:"varint,2,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"` IndexName string `protobuf:"bytes,3,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"` @@ -1481,81 +1481,81 @@ type VecFieldIndexInfo struct { XXX_sizecache int32 `json:"-"` } -func (m *VecFieldIndexInfo) Reset() { *m = VecFieldIndexInfo{} } -func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) } -func (*VecFieldIndexInfo) ProtoMessage() {} -func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) { +func (m *FieldIndexInfo) Reset() { *m = FieldIndexInfo{} } +func (m *FieldIndexInfo) String() string { return proto.CompactTextString(m) } +func (*FieldIndexInfo) ProtoMessage() {} +func (*FieldIndexInfo) Descriptor() ([]byte, []int) { return fileDescriptor_aab7cc9a69ed26e8, []int{20} } -func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_VecFieldIndexInfo.Unmarshal(m, b) +func (m *FieldIndexInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FieldIndexInfo.Unmarshal(m, b) } -func (m *VecFieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_VecFieldIndexInfo.Marshal(b, m, deterministic) +func (m *FieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FieldIndexInfo.Marshal(b, m, deterministic) } -func (m *VecFieldIndexInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_VecFieldIndexInfo.Merge(m, src) +func (m *FieldIndexInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_FieldIndexInfo.Merge(m, src) } -func (m *VecFieldIndexInfo) XXX_Size() int { - return xxx_messageInfo_VecFieldIndexInfo.Size(m) +func (m *FieldIndexInfo) XXX_Size() int { + return xxx_messageInfo_FieldIndexInfo.Size(m) } -func (m *VecFieldIndexInfo) XXX_DiscardUnknown() { - xxx_messageInfo_VecFieldIndexInfo.DiscardUnknown(m) +func (m *FieldIndexInfo) XXX_DiscardUnknown() { + xxx_messageInfo_FieldIndexInfo.DiscardUnknown(m) } -var xxx_messageInfo_VecFieldIndexInfo proto.InternalMessageInfo +var xxx_messageInfo_FieldIndexInfo proto.InternalMessageInfo -func (m *VecFieldIndexInfo) GetFieldID() int64 { +func (m *FieldIndexInfo) GetFieldID() int64 { if m != nil { return m.FieldID } return 0 } -func (m *VecFieldIndexInfo) GetEnableIndex() bool { +func (m *FieldIndexInfo) GetEnableIndex() bool { if m != nil { return m.EnableIndex } return false } -func (m *VecFieldIndexInfo) GetIndexName() string { +func (m *FieldIndexInfo) GetIndexName() string { if m != nil { return m.IndexName } return "" } -func (m *VecFieldIndexInfo) GetIndexID() int64 { +func (m *FieldIndexInfo) GetIndexID() int64 { if m != nil { return m.IndexID } return 0 } -func (m *VecFieldIndexInfo) GetBuildID() int64 { +func (m *FieldIndexInfo) GetBuildID() int64 { if m != nil { return m.BuildID } return 0 } -func (m *VecFieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair { +func (m *FieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair { if m != nil { return m.IndexParams } return nil } -func (m *VecFieldIndexInfo) GetIndexFilePaths() []string { +func (m *FieldIndexInfo) GetIndexFilePaths() []string { if m != nil { return m.IndexFilePaths } return nil } -func (m *VecFieldIndexInfo) GetIndexSize() int64 { +func (m *FieldIndexInfo) GetIndexSize() int64 { if m != nil { return m.IndexSize } @@ -2152,7 +2152,7 @@ type SegmentInfo struct { CompactionFrom []int64 `protobuf:"varint,10,rep,packed,name=compactionFrom,proto3" json:"compactionFrom,omitempty"` CreatedByCompaction bool `protobuf:"varint,11,opt,name=createdByCompaction,proto3" json:"createdByCompaction,omitempty"` SegmentState commonpb.SegmentState `protobuf:"varint,12,opt,name=segment_state,json=segmentState,proto3,enum=milvus.proto.common.SegmentState" json:"segment_state,omitempty"` - IndexInfos []*VecFieldIndexInfo `protobuf:"bytes,13,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` + IndexInfos []*FieldIndexInfo `protobuf:"bytes,13,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` ReplicaIds []int64 `protobuf:"varint,14,rep,packed,name=replica_ids,json=replicaIds,proto3" json:"replica_ids,omitempty"` NodeIds []int64 `protobuf:"varint,15,rep,packed,name=node_ids,json=nodeIds,proto3" json:"node_ids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -2269,7 +2269,7 @@ func (m *SegmentInfo) GetSegmentState() commonpb.SegmentState { return commonpb.SegmentState_SegmentStateNone } -func (m *SegmentInfo) GetIndexInfos() []*VecFieldIndexInfo { +func (m *SegmentInfo) GetIndexInfos() []*FieldIndexInfo { if m != nil { return m.IndexInfos } @@ -2732,7 +2732,7 @@ func init() { proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest") proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest") proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo") - proto.RegisterType((*VecFieldIndexInfo)(nil), "milvus.proto.query.VecFieldIndexInfo") + proto.RegisterType((*FieldIndexInfo)(nil), "milvus.proto.query.FieldIndexInfo") proto.RegisterType((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest") proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest") proto.RegisterType((*SearchRequest)(nil), "milvus.proto.query.SearchRequest") @@ -2755,174 +2755,174 @@ func init() { func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) } var fileDescriptor_aab7cc9a69ed26e8 = []byte{ - // 2667 bytes of a gzipped FileDescriptorProto + // 2664 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x1a, 0x4d, 0x6f, 0x1c, 0x49, - 0xd5, 0x3d, 0x5f, 0xf6, 0xbc, 0xf9, 0x74, 0x39, 0x31, 0x93, 0x61, 0x77, 0xe3, 0x74, 0xd6, 0x49, - 0xc8, 0xb2, 0x4e, 0x70, 0x16, 0x89, 0x15, 0x70, 0x58, 0xdb, 0xc4, 0x6b, 0xb2, 0xf1, 0x3a, 0x6d, - 0x27, 0x40, 0x14, 0x69, 0xe8, 0x99, 0x2e, 0x8f, 0x5b, 0xe9, 0x8f, 0x49, 0x57, 0xcf, 0x26, 0x0e, - 0xd7, 0x15, 0xe2, 0x43, 0x08, 0x71, 0x45, 0x88, 0x13, 0x08, 0xf6, 0xb0, 0x17, 0xce, 0x1c, 0xb8, - 0x70, 0xe3, 0x17, 0x70, 0x40, 0xdc, 0xe0, 0x0f, 0x70, 0x44, 0xa0, 0xfa, 0xea, 0xe9, 0x8f, 0x1a, - 0xbb, 0x6d, 0x6f, 0x36, 0x11, 0xe2, 0x36, 0xf5, 0xfa, 0xd5, 0x7b, 0xaf, 0xde, 0x77, 0xd5, 0x1b, - 0x98, 0x7f, 0x32, 0xc6, 0xc1, 0x61, 0x6f, 0xe0, 0xfb, 0x81, 0xb5, 0x32, 0x0a, 0xfc, 0xd0, 0x47, - 0xc8, 0xb5, 0x9d, 0x8f, 0xc6, 0x84, 0xaf, 0x56, 0xd8, 0xf7, 0x6e, 0x7d, 0xe0, 0xbb, 0xae, 0xef, - 0x71, 0x58, 0xb7, 0x1e, 0xc7, 0xe8, 0x36, 0x6d, 0x2f, 0xc4, 0x81, 0x67, 0x3a, 0xf2, 0x2b, 0x19, - 0x1c, 0x60, 0xd7, 0x14, 0xab, 0xb6, 0x65, 0x86, 0x66, 0x9c, 0xbe, 0xfe, 0xb1, 0x06, 0x8b, 0xbb, - 0x07, 0xfe, 0xd3, 0x75, 0xdf, 0x71, 0xf0, 0x20, 0xb4, 0x7d, 0x8f, 0x18, 0xf8, 0xc9, 0x18, 0x93, - 0x10, 0xdd, 0x84, 0x52, 0xdf, 0x24, 0xb8, 0xa3, 0x2d, 0x69, 0xd7, 0x6a, 0xab, 0xaf, 0xad, 0x24, - 0x24, 0x11, 0x22, 0xdc, 0x25, 0xc3, 0x35, 0x93, 0x60, 0x83, 0x61, 0x22, 0x04, 0x25, 0xab, 0xbf, - 0xb5, 0xd1, 0x29, 0x2c, 0x69, 0xd7, 0x8a, 0x06, 0xfb, 0x8d, 0xde, 0x84, 0xc6, 0x20, 0xa2, 0xbd, - 0xb5, 0x41, 0x3a, 0xc5, 0xa5, 0xe2, 0xb5, 0xa2, 0x91, 0x04, 0xea, 0xbf, 0xd3, 0xe0, 0x0b, 0x19, - 0x31, 0xc8, 0xc8, 0xf7, 0x08, 0x46, 0xb7, 0xa0, 0x42, 0x42, 0x33, 0x1c, 0x13, 0x21, 0xc9, 0x17, - 0x95, 0x92, 0xec, 0x32, 0x14, 0x43, 0xa0, 0x66, 0xd9, 0x16, 0x14, 0x6c, 0xd1, 0x57, 0xe0, 0x9c, - 0xed, 0xdd, 0xc5, 0xae, 0x1f, 0x1c, 0xf6, 0x46, 0x38, 0x18, 0x60, 0x2f, 0x34, 0x87, 0x58, 0xca, - 0xb8, 0x20, 0xbf, 0xed, 0x4c, 0x3e, 0xe9, 0xbf, 0xd5, 0xe0, 0x3c, 0x95, 0x74, 0xc7, 0x0c, 0x42, - 0xfb, 0x05, 0xe8, 0x4b, 0x87, 0x7a, 0x5c, 0xc6, 0x4e, 0x91, 0x7d, 0x4b, 0xc0, 0x28, 0xce, 0x48, - 0xb2, 0xa7, 0x67, 0x2b, 0x31, 0x71, 0x13, 0x30, 0xfd, 0x37, 0xc2, 0xb0, 0x71, 0x39, 0xcf, 0xa2, - 0xd0, 0x34, 0xcf, 0x42, 0x96, 0xe7, 0x69, 0xd4, 0xf9, 0x0f, 0x0d, 0xce, 0x7f, 0xe0, 0x9b, 0xd6, - 0xc4, 0xf0, 0x9f, 0xbf, 0x3a, 0xbf, 0x09, 0x15, 0x1e, 0x25, 0x9d, 0x12, 0xe3, 0xb5, 0x9c, 0xe4, - 0x25, 0x22, 0x68, 0x22, 0xe1, 0x2e, 0x03, 0x18, 0x62, 0x13, 0x5a, 0x86, 0x66, 0x80, 0x47, 0x8e, - 0x3d, 0x30, 0x7b, 0xde, 0xd8, 0xed, 0xe3, 0xa0, 0x53, 0x5e, 0xd2, 0xae, 0x95, 0x8d, 0x86, 0x80, - 0x6e, 0x33, 0xa0, 0xfe, 0x2b, 0x0d, 0x3a, 0x06, 0x76, 0xb0, 0x49, 0xf0, 0xcb, 0x3c, 0xec, 0x22, - 0x54, 0x3c, 0xdf, 0xc2, 0x5b, 0x1b, 0xec, 0xb0, 0x45, 0x43, 0xac, 0xf4, 0x9f, 0x16, 0xb8, 0x21, - 0x5e, 0x71, 0xbf, 0x8e, 0x19, 0xab, 0xfc, 0xd9, 0x18, 0xab, 0xa2, 0x32, 0xd6, 0x9f, 0x26, 0xc6, - 0x7a, 0xd5, 0x15, 0x32, 0x31, 0x68, 0x39, 0x61, 0xd0, 0xef, 0xc1, 0x85, 0xf5, 0x00, 0x9b, 0x21, - 0xbe, 0x47, 0x8b, 0xc6, 0xfa, 0x81, 0xe9, 0x79, 0xd8, 0x91, 0x47, 0x48, 0x33, 0xd7, 0x14, 0xcc, - 0x3b, 0x30, 0x3b, 0x0a, 0xfc, 0x67, 0x87, 0x91, 0xdc, 0x72, 0xa9, 0xff, 0x5e, 0x83, 0xae, 0x8a, - 0xf6, 0x59, 0xf2, 0xcb, 0x65, 0x68, 0x88, 0xea, 0xc7, 0xa9, 0x31, 0x9e, 0x55, 0xa3, 0xfe, 0x24, - 0xc6, 0x01, 0xdd, 0x84, 0x73, 0x1c, 0x29, 0xc0, 0x64, 0xec, 0x84, 0x11, 0x6e, 0x91, 0xe1, 0x22, - 0xf6, 0xcd, 0x60, 0x9f, 0xc4, 0x0e, 0xfd, 0x13, 0x0d, 0x2e, 0x6c, 0xe2, 0x30, 0x32, 0x22, 0xe5, - 0x8a, 0x5f, 0xd1, 0x94, 0xfd, 0xa9, 0x06, 0x5d, 0x95, 0xac, 0x67, 0x51, 0xeb, 0x43, 0x58, 0x8c, - 0x78, 0xf4, 0x2c, 0x4c, 0x06, 0x81, 0x3d, 0x62, 0xce, 0xcc, 0x12, 0x78, 0x6d, 0xf5, 0xf2, 0x4a, - 0xb6, 0xc1, 0x58, 0x49, 0x4b, 0x70, 0x3e, 0x22, 0xb1, 0x11, 0xa3, 0xa0, 0xff, 0x4c, 0x83, 0xf3, - 0x9b, 0x38, 0xdc, 0xc5, 0x43, 0x17, 0x7b, 0xe1, 0x96, 0xb7, 0xef, 0x9f, 0x5e, 0xaf, 0x6f, 0x00, - 0x10, 0x41, 0x27, 0x2a, 0x2e, 0x31, 0x48, 0x1e, 0x1d, 0xb3, 0x5e, 0x26, 0x2d, 0xcf, 0x59, 0x74, - 0xf7, 0x55, 0x28, 0xdb, 0xde, 0xbe, 0x2f, 0x55, 0x75, 0x51, 0xa5, 0xaa, 0x38, 0x33, 0x8e, 0xad, - 0xff, 0xbb, 0x00, 0x8b, 0xef, 0x59, 0x96, 0x2a, 0xec, 0x4e, 0xae, 0x97, 0x49, 0x74, 0x17, 0xe2, - 0xd1, 0x9d, 0xcb, 0xe7, 0x32, 0x21, 0x55, 0x3a, 0x41, 0x48, 0x95, 0xa7, 0x85, 0x14, 0xda, 0x84, - 0x06, 0xc1, 0xf8, 0x71, 0x6f, 0xe4, 0x13, 0xe6, 0x13, 0x2c, 0x83, 0xd6, 0x56, 0xf5, 0xe4, 0x69, - 0xa2, 0x3e, 0xf4, 0x2e, 0x19, 0xee, 0x08, 0x4c, 0xa3, 0x4e, 0x37, 0xca, 0x15, 0xba, 0x0f, 0x8b, - 0x43, 0xc7, 0xef, 0x9b, 0x4e, 0x8f, 0x60, 0xd3, 0xc1, 0x56, 0x4f, 0xd8, 0x9b, 0x74, 0x66, 0xf3, - 0x29, 0xfc, 0x1c, 0xdf, 0xbe, 0xcb, 0x76, 0x8b, 0x0f, 0x44, 0xff, 0xbb, 0x06, 0x17, 0x0c, 0xec, - 0xfa, 0x1f, 0xe1, 0xff, 0x55, 0x13, 0xe8, 0xbf, 0xd0, 0xa0, 0x4e, 0x8b, 0xf5, 0x5d, 0x1c, 0x9a, - 0x54, 0x13, 0xe8, 0x5d, 0xa8, 0x3a, 0xbe, 0x69, 0xf5, 0xc2, 0xc3, 0x11, 0x3f, 0x5a, 0x33, 0x7d, - 0x34, 0xae, 0x3d, 0xba, 0x69, 0xef, 0x70, 0x84, 0x8d, 0x39, 0x47, 0xfc, 0xca, 0x1c, 0xa3, 0x90, - 0x23, 0x7b, 0x15, 0x55, 0x0d, 0x67, 0x11, 0x16, 0xbf, 0x63, 0x86, 0x83, 0x83, 0x0d, 0x57, 0x88, - 0x49, 0x5e, 0x8e, 0xce, 0xf3, 0x14, 0xcd, 0x28, 0xb4, 0xcb, 0x2a, 0x4f, 0xa3, 0xb7, 0xa4, 0x95, - 0x07, 0xc2, 0x0c, 0xb1, 0xd0, 0x8e, 0x35, 0x1f, 0x95, 0xd3, 0x34, 0x1f, 0xeb, 0xd0, 0xc0, 0xcf, - 0x06, 0xce, 0xd8, 0xc2, 0x3d, 0xce, 0x9d, 0xfb, 0xf9, 0x1b, 0x0a, 0xee, 0x71, 0x37, 0xaf, 0x8b, - 0x4d, 0x5b, 0x42, 0x06, 0x6e, 0x6a, 0x17, 0x87, 0x66, 0x67, 0x8e, 0x89, 0xb1, 0x34, 0xcd, 0xd4, - 0xd2, 0x3f, 0xb8, 0xb9, 0xe9, 0x4a, 0xff, 0x8f, 0x06, 0x17, 0xb8, 0x99, 0xb0, 0x13, 0x9a, 0x2f, - 0xd7, 0x52, 0x91, 0x15, 0x4a, 0x27, 0xb4, 0x42, 0x4c, 0x03, 0xd5, 0x13, 0x6b, 0xe0, 0x97, 0x25, - 0x68, 0x09, 0xf5, 0x52, 0x0c, 0x16, 0x3f, 0xaf, 0x41, 0x35, 0x2a, 0x36, 0xa2, 0x19, 0x9a, 0x00, - 0xd0, 0x12, 0xd4, 0x62, 0xde, 0x23, 0x0e, 0x1a, 0x07, 0xe5, 0x3a, 0xad, 0x6c, 0x1d, 0x4a, 0xb1, - 0xd6, 0xe1, 0x75, 0x80, 0x7d, 0x67, 0x4c, 0x0e, 0x7a, 0xa1, 0xed, 0x62, 0xd1, 0xc0, 0x55, 0x19, - 0x64, 0xcf, 0x76, 0x31, 0x7a, 0x0f, 0xea, 0x7d, 0xdb, 0x73, 0xfc, 0x61, 0x6f, 0x64, 0x86, 0x07, - 0xa4, 0x53, 0x99, 0xea, 0x2f, 0xb7, 0x6d, 0xec, 0x58, 0x6b, 0x0c, 0xd7, 0xa8, 0xf1, 0x3d, 0x3b, - 0x74, 0x0b, 0x7a, 0x03, 0x6a, 0xde, 0xd8, 0xed, 0xf9, 0xfb, 0xbd, 0xc0, 0x7f, 0x4a, 0x3d, 0x8e, - 0xb1, 0xf0, 0xc6, 0xee, 0x87, 0xfb, 0x86, 0xff, 0x94, 0xa0, 0x6f, 0x40, 0x95, 0x96, 0x3b, 0xe2, - 0xf8, 0x43, 0xd2, 0x99, 0xcb, 0x45, 0x7f, 0xb2, 0x81, 0xee, 0xb6, 0xa8, 0x1f, 0xb1, 0xdd, 0xd5, - 0x7c, 0xbb, 0xa3, 0x0d, 0xe8, 0x0a, 0x34, 0x07, 0xbe, 0x3b, 0x32, 0x99, 0x86, 0x6e, 0x07, 0xbe, - 0xdb, 0x01, 0x16, 0xab, 0x29, 0x28, 0xba, 0x0d, 0x35, 0xdb, 0xb3, 0xf0, 0x33, 0x11, 0x35, 0x35, - 0xc6, 0x67, 0x59, 0x65, 0xf2, 0x07, 0x78, 0xc0, 0x78, 0x6d, 0x51, 0x74, 0x66, 0x77, 0xb0, 0xe5, - 0x4f, 0x82, 0x2e, 0x41, 0x5d, 0x18, 0xb5, 0x47, 0xec, 0xe7, 0xb8, 0x53, 0xe7, 0x86, 0x14, 0xb0, - 0x5d, 0xfb, 0x39, 0xd6, 0xff, 0x50, 0x80, 0xf9, 0x0c, 0x11, 0xda, 0x0a, 0xef, 0x33, 0x88, 0x74, - 0x0e, 0xb9, 0xa4, 0x24, 0xb1, 0x67, 0xf6, 0x1d, 0x1a, 0xd1, 0x16, 0x7e, 0xc6, 0x7c, 0x63, 0xce, - 0xa8, 0x71, 0x18, 0x23, 0x40, 0x6d, 0xcc, 0xa5, 0xf7, 0x4c, 0x17, 0x8b, 0x56, 0xb5, 0xca, 0x20, - 0xdb, 0xa6, 0x8b, 0x29, 0x6d, 0x2e, 0xa2, 0xf4, 0x0c, 0xb9, 0xa4, 0x5f, 0xfa, 0x63, 0x9b, 0x71, - 0xe5, 0x9e, 0x21, 0x97, 0x68, 0x03, 0xea, 0x9c, 0xe4, 0xc8, 0x0c, 0x4c, 0x57, 0xfa, 0xc5, 0x25, - 0x65, 0xb8, 0xde, 0xc1, 0x87, 0x0f, 0x4c, 0x67, 0x8c, 0x77, 0x4c, 0x3b, 0x30, 0xb8, 0x1e, 0x77, - 0xd8, 0x2e, 0x74, 0x0d, 0xda, 0x9c, 0xca, 0xbe, 0xed, 0x60, 0xe1, 0x61, 0x34, 0x23, 0x55, 0x8d, - 0x26, 0x83, 0xdf, 0xb6, 0x1d, 0xcc, 0x9d, 0x28, 0x3a, 0x02, 0x53, 0xdb, 0x1c, 0xf7, 0x21, 0x06, - 0x61, 0x4a, 0xfb, 0x67, 0x01, 0x16, 0x68, 0x28, 0xc9, 0x12, 0x7c, 0xfa, 0x6c, 0xf2, 0x3a, 0x80, - 0x45, 0xc2, 0x5e, 0x22, 0xa3, 0x54, 0x2d, 0x12, 0x6e, 0xf3, 0xa4, 0xf2, 0xae, 0x4c, 0x18, 0xc5, - 0xe9, 0xcd, 0x6b, 0x2a, 0xb4, 0xb3, 0xa9, 0xfb, 0x54, 0x97, 0xfc, 0xcb, 0xd0, 0x20, 0xfe, 0x38, - 0x18, 0xe0, 0x5e, 0xe2, 0xb2, 0x55, 0xe7, 0xc0, 0x6d, 0x75, 0xce, 0xab, 0x28, 0x1f, 0x1b, 0x62, - 0xc9, 0x6b, 0xf6, 0xc4, 0xc9, 0xeb, 0x6f, 0x1a, 0x2c, 0x8a, 0x8b, 0xe9, 0xd9, 0xb5, 0x3d, 0x2d, - 0x77, 0xcb, 0x4c, 0x55, 0x3c, 0xe2, 0x92, 0x53, 0xca, 0x51, 0x79, 0xcb, 0x8a, 0xca, 0x9b, 0x6c, - 0xf4, 0x2b, 0xe9, 0x46, 0x5f, 0xff, 0xa1, 0x06, 0x8d, 0x5d, 0x6c, 0x06, 0x83, 0x03, 0x79, 0xae, - 0x77, 0xa0, 0x18, 0xe0, 0x27, 0xe2, 0x58, 0xa9, 0x2e, 0x53, 0x2c, 0x12, 0x1b, 0x0c, 0x8a, 0x8e, - 0x2e, 0x42, 0xcd, 0x72, 0x9d, 0xd4, 0x6d, 0x12, 0x2c, 0xd7, 0x91, 0x5d, 0x57, 0x52, 0x90, 0x62, - 0x46, 0x90, 0x8f, 0x35, 0xa8, 0xdf, 0xe3, 0xad, 0x17, 0x97, 0xe3, 0x56, 0x5c, 0x8e, 0x4b, 0x4a, - 0x39, 0xe2, 0xf8, 0x9f, 0x91, 0x18, 0x3f, 0xd7, 0x60, 0xf1, 0x7d, 0xd3, 0xb3, 0xfc, 0xfd, 0xfd, - 0xb3, 0x1b, 0x7c, 0x3d, 0x4a, 0x80, 0x5b, 0x27, 0xb9, 0xd8, 0x24, 0x36, 0xe9, 0x3f, 0x2a, 0x00, - 0xa2, 0xde, 0xb9, 0x66, 0x3a, 0xa6, 0x37, 0xc0, 0xa7, 0x97, 0x66, 0x19, 0x9a, 0x89, 0x98, 0x8a, - 0x1e, 0x69, 0xe3, 0x41, 0x45, 0xd0, 0x1d, 0x68, 0xf6, 0x39, 0xab, 0x5e, 0x80, 0x4d, 0xe2, 0x7b, - 0xcc, 0x2f, 0x9b, 0xab, 0x6f, 0xaa, 0xc4, 0xde, 0x0b, 0xec, 0xe1, 0x10, 0x07, 0xeb, 0xbe, 0x67, - 0xf1, 0x2b, 0x47, 0xa3, 0x2f, 0xc5, 0xa4, 0x5b, 0x99, 0x3d, 0xa2, 0x04, 0x23, 0x7b, 0x43, 0x88, - 0x32, 0x0c, 0x41, 0x6f, 0xc1, 0x7c, 0xf2, 0x36, 0x32, 0x71, 0xe4, 0x36, 0x89, 0x5f, 0x34, 0xa8, - 0x71, 0x7e, 0x00, 0x28, 0xea, 0x76, 0x59, 0x53, 0xc5, 0xaa, 0x45, 0x9e, 0xc7, 0x95, 0xd7, 0xa0, - 0x6a, 0xc9, 0x9d, 0xc2, 0x2b, 0x26, 0x00, 0x9a, 0x6d, 0xb8, 0x84, 0x3d, 0x1a, 0xf8, 0xd8, 0x92, - 0xfd, 0x04, 0x07, 0x7e, 0xc0, 0x60, 0xfa, 0xa7, 0x05, 0x68, 0xc7, 0x6f, 0x38, 0xb9, 0x79, 0xbf, - 0x98, 0xa7, 0x96, 0x23, 0xae, 0x73, 0xa5, 0x33, 0x5c, 0xe7, 0xb2, 0xd7, 0xcd, 0xf2, 0xe9, 0xae, - 0x9b, 0xfa, 0xaf, 0x35, 0x68, 0xa5, 0x5e, 0x36, 0xd2, 0x9d, 0x9d, 0x96, 0xed, 0xec, 0xbe, 0x06, - 0x65, 0xda, 0xee, 0x60, 0xa6, 0xa4, 0x66, 0x9a, 0xad, 0xea, 0xbd, 0xc4, 0xe0, 0x1b, 0xd0, 0x0d, - 0x58, 0x50, 0xbc, 0x86, 0x0b, 0x53, 0xa2, 0xec, 0x63, 0xb8, 0xfe, 0xc7, 0x12, 0xd4, 0x62, 0xfa, - 0x38, 0xa6, 0x29, 0xcd, 0x73, 0x6f, 0x4b, 0x1d, 0xaf, 0x98, 0x3d, 0xde, 0x94, 0xe7, 0x60, 0x74, - 0x01, 0xe6, 0x5c, 0xec, 0xf2, 0x7a, 0x2f, 0x9a, 0x0f, 0x17, 0xbb, 0xb4, 0xda, 0xd3, 0x4f, 0xb4, - 0xa3, 0x64, 0xed, 0x24, 0xaf, 0x70, 0xb3, 0xde, 0xd8, 0x65, 0xcd, 0x64, 0xb2, 0xd5, 0x99, 0x3d, - 0xa2, 0xd5, 0x99, 0x4b, 0xb6, 0x3a, 0x89, 0x70, 0xa8, 0xa6, 0xc3, 0x21, 0x6f, 0x9f, 0x78, 0x13, - 0x16, 0x06, 0xec, 0x59, 0xd2, 0x5a, 0x3b, 0x5c, 0x8f, 0x3e, 0x75, 0x6a, 0xac, 0x27, 0x53, 0x7d, - 0x42, 0xb7, 0xa9, 0x73, 0x89, 0x8e, 0x90, 0x59, 0xb9, 0xce, 0xac, 0xac, 0xee, 0xa4, 0x84, 0x6d, - 0xb8, 0x91, 0x65, 0x4e, 0x64, 0xab, 0x74, 0x87, 0xda, 0x38, 0x6d, 0x87, 0x7a, 0x11, 0x6a, 0xf2, - 0x79, 0xda, 0xb6, 0x48, 0xa7, 0xc9, 0xd3, 0x93, 0x00, 0x6d, 0x59, 0x84, 0x29, 0xdf, 0xa7, 0xf7, - 0x47, 0x8b, 0x74, 0x5a, 0xec, 0xeb, 0x2c, 0xb3, 0x98, 0x45, 0xf4, 0x4f, 0x8a, 0xd0, 0x9c, 0xf4, - 0x2f, 0xb9, 0xb3, 0x41, 0x9e, 0xc1, 0xce, 0x36, 0xb4, 0x27, 0xaf, 0x88, 0x4c, 0x51, 0x47, 0xb6, - 0x60, 0xe9, 0xf7, 0xc3, 0xd6, 0x28, 0x15, 0x76, 0x89, 0xe7, 0x8a, 0xd2, 0x89, 0x9e, 0x2b, 0xce, - 0xf8, 0xfe, 0x7f, 0x0b, 0xce, 0x07, 0xbc, 0x7d, 0xb2, 0x7a, 0x89, 0x63, 0xf3, 0x4e, 0xe4, 0x9c, - 0xfc, 0xb8, 0x13, 0x3f, 0xfe, 0x94, 0x48, 0x9e, 0x9d, 0x16, 0xc9, 0x69, 0x33, 0xce, 0xa5, 0xcd, - 0xa8, 0xdf, 0x87, 0x85, 0xfb, 0x1e, 0x19, 0xf7, 0xc9, 0x20, 0xb0, 0xfb, 0x58, 0xde, 0xc2, 0x73, - 0xd9, 0xab, 0x0b, 0x73, 0x22, 0x17, 0x73, 0x5b, 0x55, 0x8d, 0x68, 0xad, 0xff, 0x44, 0x83, 0xc5, - 0x2c, 0x5d, 0xe6, 0x0a, 0x93, 0x40, 0xd7, 0x12, 0x81, 0xfe, 0x5d, 0x58, 0x98, 0x90, 0xef, 0x25, - 0x28, 0xd7, 0x56, 0xaf, 0xaa, 0x8c, 0xa2, 0x10, 0xdc, 0x40, 0x13, 0x1a, 0x12, 0xa6, 0xff, 0x4b, - 0x83, 0x79, 0x11, 0x32, 0x14, 0x36, 0x64, 0xef, 0x17, 0xb4, 0xf8, 0xf8, 0x9e, 0x63, 0x7b, 0x51, - 0x23, 0x2d, 0xce, 0xc8, 0x81, 0xa2, 0x91, 0x7e, 0x1f, 0x5a, 0x02, 0x29, 0xaa, 0x21, 0x39, 0x5b, - 0x95, 0x26, 0xdf, 0x17, 0x55, 0x8f, 0x65, 0x68, 0xfa, 0xfb, 0xfb, 0x71, 0x7e, 0x3c, 0x09, 0x36, - 0x04, 0x54, 0x30, 0xfc, 0x36, 0xb4, 0x25, 0xda, 0x49, 0xab, 0x56, 0x4b, 0x6c, 0x8c, 0xde, 0x1f, - 0x7f, 0xac, 0x41, 0x27, 0x59, 0xc3, 0x62, 0xc7, 0x3f, 0x79, 0x97, 0xf4, 0xf5, 0xe4, 0x2b, 0xf4, - 0xf2, 0x11, 0xf2, 0x4c, 0xf8, 0xc8, 0xb7, 0xe8, 0xbf, 0x6a, 0x50, 0x33, 0x84, 0xdb, 0x51, 0xf6, - 0xaf, 0x03, 0x4c, 0x1c, 0x53, 0xd6, 0x94, 0xc8, 0x2f, 0xa9, 0x71, 0x62, 0xce, 0x60, 0x5b, 0x8a, - 0xa2, 0xc2, 0x90, 0x26, 0xc9, 0x80, 0xba, 0x77, 0xe6, 0x35, 0xd0, 0xa2, 0x55, 0xbb, 0x49, 0x0e, - 0xcc, 0xc0, 0xea, 0x09, 0xe2, 0x52, 0x9d, 0xca, 0xbb, 0xce, 0x2e, 0xc5, 0x14, 0x62, 0x1a, 0x0d, - 0x12, 0x5b, 0x25, 0x13, 0x5e, 0x39, 0x99, 0xf0, 0xb6, 0xa1, 0x1e, 0xdf, 0x49, 0x5d, 0xdc, 0xc1, - 0xa6, 0x85, 0x03, 0xe9, 0xe2, 0x7c, 0x85, 0xae, 0x40, 0xcb, 0x72, 0xa5, 0x6b, 0xf3, 0xd2, 0xc4, - 0x3b, 0x9e, 0x46, 0x54, 0x62, 0x68, 0x79, 0xba, 0xfe, 0x1c, 0x9a, 0xc9, 0xcc, 0x85, 0xea, 0x30, - 0xb7, 0xed, 0x87, 0xdf, 0x7a, 0x66, 0x93, 0xb0, 0x3d, 0x83, 0x9a, 0x00, 0xdb, 0x7e, 0xb8, 0x13, - 0x60, 0x82, 0xbd, 0xb0, 0xad, 0x21, 0x80, 0xca, 0x87, 0xde, 0x86, 0x4d, 0x1e, 0xb7, 0x0b, 0x68, - 0x41, 0xf4, 0x16, 0xa6, 0xb3, 0x25, 0xd2, 0x41, 0xbb, 0x48, 0xb7, 0x47, 0xab, 0x12, 0x6a, 0x43, - 0x3d, 0x42, 0xd9, 0xdc, 0xb9, 0xdf, 0x2e, 0xa3, 0x2a, 0x94, 0xf9, 0xcf, 0xca, 0x75, 0x0b, 0xda, - 0xe9, 0xd6, 0x95, 0xd2, 0xbc, 0xef, 0xdd, 0xf1, 0xfc, 0xa7, 0x11, 0xa8, 0x3d, 0x83, 0x6a, 0x30, - 0x2b, 0xae, 0x03, 0x6d, 0x0d, 0xb5, 0xa0, 0x16, 0xeb, 0xc4, 0xdb, 0x05, 0x0a, 0xd8, 0x0c, 0x46, - 0x03, 0xd1, 0x93, 0x73, 0x11, 0xa8, 0x8b, 0x6f, 0xf8, 0x4f, 0xbd, 0x76, 0xe9, 0xfa, 0x1a, 0xcc, - 0xc9, 0x94, 0x4a, 0x51, 0x39, 0x75, 0x8f, 0x2e, 0xdb, 0x33, 0x68, 0x1e, 0x1a, 0x89, 0x01, 0x70, - 0x5b, 0x43, 0x08, 0x9a, 0xc9, 0xe1, 0x7c, 0xbb, 0xb0, 0xfa, 0xe7, 0x1a, 0x00, 0x6f, 0x3b, 0x7d, - 0x3f, 0xb0, 0xd0, 0x08, 0xd0, 0x26, 0x0e, 0x69, 0x49, 0xf5, 0x3d, 0x59, 0x0e, 0x09, 0xba, 0x39, - 0xa5, 0x3b, 0xcb, 0xa2, 0x0a, 0x51, 0xbb, 0x57, 0xa6, 0xec, 0x48, 0xa1, 0xeb, 0x33, 0xc8, 0x65, - 0x1c, 0xf7, 0x6c, 0x17, 0xef, 0xd9, 0x83, 0xc7, 0x51, 0xbf, 0x3a, 0x9d, 0x63, 0x0a, 0x55, 0x72, - 0xbc, 0xac, 0xbe, 0x4a, 0x86, 0x81, 0xed, 0x0d, 0xe5, 0xe0, 0x48, 0x9f, 0x41, 0x4f, 0xe0, 0xdc, - 0x26, 0x66, 0xdc, 0x6d, 0x12, 0xda, 0x03, 0x22, 0x19, 0xae, 0x4e, 0x67, 0x98, 0x41, 0x3e, 0x21, - 0x4b, 0x07, 0x5a, 0xa9, 0x3f, 0xc3, 0xa0, 0xeb, 0xea, 0xb8, 0x51, 0xfd, 0x71, 0xa7, 0xfb, 0x56, - 0x2e, 0xdc, 0x88, 0x9b, 0x0d, 0xcd, 0xe4, 0x1f, 0x45, 0xd0, 0x97, 0xa6, 0x11, 0xc8, 0xcc, 0xc2, - 0xbb, 0xd7, 0xf3, 0xa0, 0x46, 0xac, 0x1e, 0x72, 0x7f, 0x3a, 0x8e, 0x95, 0xf2, 0x7f, 0x08, 0xdd, - 0xa3, 0x66, 0x76, 0xfa, 0x0c, 0xfa, 0x3e, 0xcc, 0x67, 0x26, 0xf6, 0xe8, 0xcb, 0x2a, 0xf2, 0xd3, - 0x06, 0xfb, 0xc7, 0x71, 0x78, 0x98, 0x8e, 0x86, 0xe9, 0xd2, 0x67, 0xfe, 0xe1, 0x91, 0x5f, 0xfa, - 0x18, 0xf9, 0xa3, 0xa4, 0x3f, 0x31, 0x87, 0x31, 0xa0, 0xec, 0xcc, 0x1e, 0xbd, 0xad, 0x62, 0x31, - 0xf5, 0x7f, 0x03, 0xdd, 0x95, 0xbc, 0xe8, 0x91, 0xc9, 0xc7, 0x2c, 0x5a, 0xd3, 0xf7, 0x2e, 0x25, - 0xdb, 0xa9, 0x73, 0x7a, 0x35, 0xdb, 0xe9, 0xa3, 0x72, 0xee, 0xd4, 0xc9, 0x51, 0xb0, 0xda, 0x56, - 0xca, 0xf1, 0xb5, 0xda, 0xa9, 0xd5, 0x93, 0x65, 0x7d, 0x06, 0xed, 0x25, 0x92, 0x30, 0xba, 0x32, - 0xcd, 0x27, 0x92, 0xef, 0x25, 0xc7, 0x99, 0xab, 0x07, 0xb0, 0x89, 0xc3, 0xbb, 0x38, 0x0c, 0xec, - 0x01, 0x49, 0x13, 0x15, 0x8b, 0x09, 0x82, 0x24, 0x7a, 0xf5, 0x58, 0x3c, 0x29, 0xf6, 0xea, 0x5f, - 0x6a, 0x50, 0x65, 0x36, 0xa3, 0xf5, 0xe1, 0xff, 0x69, 0xfc, 0x05, 0xa4, 0xf1, 0x47, 0xd0, 0x4a, - 0xfd, 0x0f, 0x40, 0x9d, 0xc6, 0xd5, 0x7f, 0x16, 0x38, 0xce, 0x41, 0xfa, 0x80, 0xb2, 0x53, 0x6e, - 0x75, 0x60, 0x4d, 0x9d, 0x86, 0x1f, 0xc7, 0xe3, 0x11, 0xb4, 0x52, 0x23, 0x5d, 0xf5, 0x09, 0xd4, - 0x73, 0xdf, 0x1c, 0x27, 0xc8, 0x4e, 0x22, 0xd5, 0x27, 0x98, 0x3a, 0xb1, 0x3c, 0x8e, 0xc7, 0x03, - 0x3e, 0x28, 0x8f, 0xee, 0x03, 0x57, 0xa7, 0x45, 0x67, 0xea, 0x71, 0xf5, 0xe5, 0xe7, 0xeb, 0x17, - 0x5f, 0xcf, 0x1e, 0x41, 0x2b, 0x35, 0x4a, 0x50, 0x5b, 0x57, 0x3d, 0x6f, 0x38, 0x8e, 0xfa, 0xe7, - 0x98, 0x81, 0xef, 0x41, 0x85, 0x4f, 0x00, 0xd0, 0x25, 0xf5, 0xed, 0x28, 0x36, 0x1d, 0xe8, 0x1e, - 0x3d, 0x41, 0x20, 0x63, 0x27, 0xa4, 0xd2, 0x6f, 0x43, 0x99, 0xc5, 0x0b, 0x52, 0x5e, 0x58, 0xe2, - 0xef, 0xfc, 0xdd, 0x23, 0x47, 0x01, 0x92, 0xde, 0x8b, 0x4e, 0xe7, 0x6b, 0xef, 0x3c, 0x5c, 0x1d, - 0xda, 0xe1, 0xc1, 0xb8, 0x4f, 0x0d, 0x71, 0x83, 0x63, 0xbe, 0x6d, 0xfb, 0xe2, 0xd7, 0x0d, 0x99, - 0xd7, 0x6e, 0x30, 0x4a, 0x37, 0xd8, 0x31, 0x46, 0xfd, 0x7e, 0x85, 0x2d, 0x6f, 0xfd, 0x37, 0x00, - 0x00, 0xff, 0xff, 0x49, 0x2f, 0x9e, 0xbd, 0x7a, 0x2e, 0x00, 0x00, + 0xd5, 0x3d, 0x5f, 0xf6, 0xbc, 0xf9, 0x4c, 0x39, 0x31, 0x93, 0x61, 0x77, 0xe3, 0x74, 0x36, 0x1f, + 0x64, 0x59, 0x27, 0x38, 0x8b, 0xc4, 0x0a, 0x38, 0xac, 0x6d, 0xe2, 0x35, 0xd9, 0x78, 0x9d, 0xb6, + 0x13, 0x20, 0x8a, 0x34, 0xf4, 0x4c, 0x97, 0xc7, 0xad, 0xf4, 0xc7, 0xa4, 0xab, 0x67, 0x13, 0x87, + 0xeb, 0x0a, 0xf1, 0x21, 0x84, 0x38, 0x71, 0x41, 0x9c, 0x40, 0xb0, 0x87, 0x15, 0x67, 0x6e, 0x5c, + 0xb8, 0xf1, 0x0b, 0x38, 0x20, 0x6e, 0xf0, 0x07, 0x38, 0x22, 0x50, 0x7d, 0xf5, 0x74, 0xf7, 0x54, + 0xdb, 0x3d, 0xf6, 0x66, 0x13, 0x21, 0x6e, 0x53, 0xaf, 0x5f, 0xbd, 0xf7, 0xea, 0x7d, 0x57, 0xbd, + 0x81, 0x33, 0x4f, 0xc6, 0x38, 0x38, 0xec, 0x0d, 0x7c, 0x3f, 0xb0, 0x56, 0x46, 0x81, 0x1f, 0xfa, + 0x08, 0xb9, 0xb6, 0xf3, 0xd1, 0x98, 0xf0, 0xd5, 0x0a, 0xfb, 0xde, 0xad, 0x0f, 0x7c, 0xd7, 0xf5, + 0x3d, 0x0e, 0xeb, 0xd6, 0xe3, 0x18, 0xdd, 0xa6, 0xed, 0x85, 0x38, 0xf0, 0x4c, 0x47, 0x7e, 0x25, + 0x83, 0x03, 0xec, 0x9a, 0x62, 0xd5, 0xb6, 0xcc, 0xd0, 0x8c, 0xd3, 0xd7, 0x3f, 0xd6, 0x60, 0x69, + 0xf7, 0xc0, 0x7f, 0xba, 0xee, 0x3b, 0x0e, 0x1e, 0x84, 0xb6, 0xef, 0x11, 0x03, 0x3f, 0x19, 0x63, + 0x12, 0xa2, 0x9b, 0x50, 0xea, 0x9b, 0x04, 0x77, 0xb4, 0x65, 0xed, 0x5a, 0x6d, 0xf5, 0xb5, 0x95, + 0x84, 0x24, 0x42, 0x84, 0xbb, 0x64, 0xb8, 0x66, 0x12, 0x6c, 0x30, 0x4c, 0x84, 0xa0, 0x64, 0xf5, + 0xb7, 0x36, 0x3a, 0x85, 0x65, 0xed, 0x5a, 0xd1, 0x60, 0xbf, 0xd1, 0x9b, 0xd0, 0x18, 0x44, 0xb4, + 0xb7, 0x36, 0x48, 0xa7, 0xb8, 0x5c, 0xbc, 0x56, 0x34, 0x92, 0x40, 0xfd, 0x77, 0x1a, 0x7c, 0x61, + 0x4a, 0x0c, 0x32, 0xf2, 0x3d, 0x82, 0xd1, 0x2d, 0xa8, 0x90, 0xd0, 0x0c, 0xc7, 0x44, 0x48, 0xf2, + 0x45, 0xa5, 0x24, 0xbb, 0x0c, 0xc5, 0x10, 0xa8, 0xd3, 0x6c, 0x0b, 0x0a, 0xb6, 0xe8, 0x2b, 0x70, + 0xd6, 0xf6, 0xee, 0x62, 0xd7, 0x0f, 0x0e, 0x7b, 0x23, 0x1c, 0x0c, 0xb0, 0x17, 0x9a, 0x43, 0x2c, + 0x65, 0x5c, 0x94, 0xdf, 0x76, 0x26, 0x9f, 0xf4, 0xdf, 0x6a, 0x70, 0x8e, 0x4a, 0xba, 0x63, 0x06, + 0xa1, 0xfd, 0x02, 0xf4, 0xa5, 0x43, 0x3d, 0x2e, 0x63, 0xa7, 0xc8, 0xbe, 0x25, 0x60, 0x14, 0x67, + 0x24, 0xd9, 0xd3, 0xb3, 0x95, 0x98, 0xb8, 0x09, 0x98, 0xfe, 0x1b, 0x61, 0xd8, 0xb8, 0x9c, 0xa7, + 0x51, 0x68, 0x9a, 0x67, 0x61, 0x9a, 0xe7, 0x49, 0xd4, 0xf9, 0x0f, 0x0d, 0xce, 0x7d, 0xe0, 0x9b, + 0xd6, 0xc4, 0xf0, 0x9f, 0xbf, 0x3a, 0xbf, 0x09, 0x15, 0x1e, 0x25, 0x9d, 0x12, 0xe3, 0x75, 0x39, + 0xc9, 0x4b, 0x44, 0xd0, 0x44, 0xc2, 0x5d, 0x06, 0x30, 0xc4, 0x26, 0x74, 0x19, 0x9a, 0x01, 0x1e, + 0x39, 0xf6, 0xc0, 0xec, 0x79, 0x63, 0xb7, 0x8f, 0x83, 0x4e, 0x79, 0x59, 0xbb, 0x56, 0x36, 0x1a, + 0x02, 0xba, 0xcd, 0x80, 0xfa, 0xaf, 0x34, 0xe8, 0x18, 0xd8, 0xc1, 0x26, 0xc1, 0x2f, 0xf3, 0xb0, + 0x4b, 0x50, 0xf1, 0x7c, 0x0b, 0x6f, 0x6d, 0xb0, 0xc3, 0x16, 0x0d, 0xb1, 0xd2, 0x7f, 0x5a, 0xe0, + 0x86, 0x78, 0xc5, 0xfd, 0x3a, 0x66, 0xac, 0xf2, 0x67, 0x63, 0xac, 0x8a, 0xca, 0x58, 0x7f, 0x9a, + 0x18, 0xeb, 0x55, 0x57, 0xc8, 0xc4, 0xa0, 0xe5, 0x84, 0x41, 0xbf, 0x07, 0xe7, 0xd7, 0x03, 0x6c, + 0x86, 0xf8, 0x1e, 0x2d, 0x1a, 0xeb, 0x07, 0xa6, 0xe7, 0x61, 0x47, 0x1e, 0x21, 0xcd, 0x5c, 0x53, + 0x30, 0xef, 0xc0, 0xfc, 0x28, 0xf0, 0x9f, 0x1d, 0x46, 0x72, 0xcb, 0xa5, 0xfe, 0x7b, 0x0d, 0xba, + 0x2a, 0xda, 0xa7, 0xc9, 0x2f, 0x97, 0xa0, 0x21, 0xaa, 0x1f, 0xa7, 0xc6, 0x78, 0x56, 0x8d, 0xfa, + 0x93, 0x18, 0x07, 0x74, 0x13, 0xce, 0x72, 0xa4, 0x00, 0x93, 0xb1, 0x13, 0x46, 0xb8, 0x45, 0x86, + 0x8b, 0xd8, 0x37, 0x83, 0x7d, 0x12, 0x3b, 0xf4, 0x4f, 0x34, 0x38, 0xbf, 0x89, 0xc3, 0xc8, 0x88, + 0x94, 0x2b, 0x7e, 0x45, 0x53, 0xf6, 0xa7, 0x1a, 0x74, 0x55, 0xb2, 0x9e, 0x46, 0xad, 0x0f, 0x61, + 0x29, 0xe2, 0xd1, 0xb3, 0x30, 0x19, 0x04, 0xf6, 0x88, 0x39, 0x33, 0x4b, 0xe0, 0xb5, 0xd5, 0x4b, + 0x2b, 0xd3, 0x0d, 0xc6, 0x4a, 0x5a, 0x82, 0x73, 0x11, 0x89, 0x8d, 0x18, 0x05, 0xfd, 0x67, 0x1a, + 0x9c, 0xdb, 0xc4, 0xe1, 0x2e, 0x1e, 0xba, 0xd8, 0x0b, 0xb7, 0xbc, 0x7d, 0xff, 0xe4, 0x7a, 0x7d, + 0x03, 0x80, 0x08, 0x3a, 0x51, 0x71, 0x89, 0x41, 0xf2, 0xe8, 0x98, 0xf5, 0x32, 0x69, 0x79, 0x4e, + 0xa3, 0xbb, 0xaf, 0x42, 0xd9, 0xf6, 0xf6, 0x7d, 0xa9, 0xaa, 0x0b, 0x2a, 0x55, 0xc5, 0x99, 0x71, + 0x6c, 0xfd, 0xdf, 0x05, 0x58, 0x7a, 0xcf, 0xb2, 0x54, 0x61, 0x37, 0xbb, 0x5e, 0x26, 0xd1, 0x5d, + 0x88, 0x47, 0x77, 0x2e, 0x9f, 0x9b, 0x0a, 0xa9, 0xd2, 0x0c, 0x21, 0x55, 0xce, 0x0a, 0x29, 0xb4, + 0x09, 0x0d, 0x82, 0xf1, 0xe3, 0xde, 0xc8, 0x27, 0xcc, 0x27, 0x58, 0x06, 0xad, 0xad, 0xea, 0xc9, + 0xd3, 0x44, 0x7d, 0xe8, 0x5d, 0x32, 0xdc, 0x11, 0x98, 0x46, 0x9d, 0x6e, 0x94, 0x2b, 0x74, 0x1f, + 0x96, 0x86, 0x8e, 0xdf, 0x37, 0x9d, 0x1e, 0xc1, 0xa6, 0x83, 0xad, 0x9e, 0xb0, 0x37, 0xe9, 0xcc, + 0xe7, 0x53, 0xf8, 0x59, 0xbe, 0x7d, 0x97, 0xed, 0x16, 0x1f, 0x88, 0xfe, 0x77, 0x0d, 0xce, 0x1b, + 0xd8, 0xf5, 0x3f, 0xc2, 0xff, 0xab, 0x26, 0xd0, 0x7f, 0xa1, 0x41, 0x9d, 0x16, 0xeb, 0xbb, 0x38, + 0x34, 0xa9, 0x26, 0xd0, 0xbb, 0x50, 0x75, 0x7c, 0xd3, 0xea, 0x85, 0x87, 0x23, 0x7e, 0xb4, 0x66, + 0xfa, 0x68, 0x5c, 0x7b, 0x74, 0xd3, 0xde, 0xe1, 0x08, 0x1b, 0x0b, 0x8e, 0xf8, 0x35, 0x75, 0x8c, + 0x42, 0x8e, 0xec, 0x55, 0x54, 0x35, 0x9c, 0x45, 0x58, 0xfa, 0x8e, 0x19, 0x0e, 0x0e, 0x36, 0x5c, + 0x21, 0x26, 0x79, 0x39, 0x3a, 0xcf, 0x53, 0x34, 0xa3, 0xd0, 0x2e, 0xab, 0x3c, 0x8d, 0xde, 0x92, + 0x56, 0x1e, 0x08, 0x33, 0xc4, 0x42, 0x3b, 0xd6, 0x7c, 0x54, 0x4e, 0xd2, 0x7c, 0xac, 0x43, 0x03, + 0x3f, 0x1b, 0x38, 0x63, 0x0b, 0xf7, 0x38, 0x77, 0xee, 0xe7, 0x6f, 0x28, 0xb8, 0xc7, 0xdd, 0xbc, + 0x2e, 0x36, 0x6d, 0x09, 0x19, 0xb8, 0xa9, 0x5d, 0x1c, 0x9a, 0x9d, 0x05, 0x26, 0xc6, 0x72, 0x96, + 0xa9, 0xa5, 0x7f, 0x70, 0x73, 0xd3, 0x95, 0xfe, 0x1f, 0x0d, 0xce, 0x73, 0x33, 0x61, 0x27, 0x34, + 0x5f, 0xae, 0xa5, 0x22, 0x2b, 0x94, 0x66, 0xb4, 0x42, 0x4c, 0x03, 0xd5, 0x99, 0x35, 0xf0, 0xcb, + 0x12, 0xb4, 0x84, 0x7a, 0x29, 0x06, 0x8b, 0x9f, 0xd7, 0xa0, 0x1a, 0x15, 0x1b, 0xd1, 0x0c, 0x4d, + 0x00, 0x68, 0x19, 0x6a, 0x31, 0xef, 0x11, 0x07, 0x8d, 0x83, 0x72, 0x9d, 0x56, 0xb6, 0x0e, 0xa5, + 0x58, 0xeb, 0xf0, 0x3a, 0xc0, 0xbe, 0x33, 0x26, 0x07, 0xbd, 0xd0, 0x76, 0xb1, 0x68, 0xe0, 0xaa, + 0x0c, 0xb2, 0x67, 0xbb, 0x18, 0xbd, 0x07, 0xf5, 0xbe, 0xed, 0x39, 0xfe, 0xb0, 0x37, 0x32, 0xc3, + 0x03, 0xd2, 0xa9, 0x64, 0xfa, 0xcb, 0x6d, 0x1b, 0x3b, 0xd6, 0x1a, 0xc3, 0x35, 0x6a, 0x7c, 0xcf, + 0x0e, 0xdd, 0x82, 0xde, 0x80, 0x9a, 0x37, 0x76, 0x7b, 0xfe, 0x7e, 0x2f, 0xf0, 0x9f, 0x52, 0x8f, + 0x63, 0x2c, 0xbc, 0xb1, 0xfb, 0xe1, 0xbe, 0xe1, 0x3f, 0x25, 0xe8, 0x1b, 0x50, 0xa5, 0xe5, 0x8e, + 0x38, 0xfe, 0x90, 0x74, 0x16, 0x72, 0xd1, 0x9f, 0x6c, 0xa0, 0xbb, 0x2d, 0xea, 0x47, 0x6c, 0x77, + 0x35, 0xdf, 0xee, 0x68, 0x03, 0xba, 0x02, 0xcd, 0x81, 0xef, 0x8e, 0x4c, 0xa6, 0xa1, 0xdb, 0x81, + 0xef, 0x76, 0x80, 0xc5, 0x6a, 0x0a, 0x8a, 0xd6, 0xa1, 0x66, 0x7b, 0x16, 0x7e, 0x26, 0xa2, 0xa6, + 0xc6, 0xf8, 0xe8, 0x2a, 0x93, 0x33, 0x46, 0x5b, 0x14, 0x97, 0x19, 0x1d, 0x6c, 0xf9, 0x93, 0xa0, + 0x8b, 0x50, 0x17, 0x16, 0xed, 0x11, 0xfb, 0x39, 0xee, 0xd4, 0xb9, 0x15, 0x05, 0x6c, 0xd7, 0x7e, + 0x8e, 0xf5, 0x3f, 0x14, 0xa0, 0x99, 0xa4, 0x40, 0x9b, 0xe0, 0x7d, 0x06, 0x91, 0x6e, 0x21, 0x97, + 0x94, 0x1e, 0xf6, 0xcc, 0xbe, 0x43, 0x63, 0xd9, 0xc2, 0xcf, 0x98, 0x57, 0x2c, 0x18, 0x35, 0x0e, + 0x63, 0x04, 0xa8, 0x75, 0xb9, 0xdc, 0x9e, 0xe9, 0x62, 0xd1, 0xa4, 0x56, 0x19, 0x64, 0xdb, 0x74, + 0x31, 0xa5, 0xcd, 0xe5, 0x93, 0x3e, 0x21, 0x97, 0xf4, 0x4b, 0x7f, 0x6c, 0x33, 0xae, 0xdc, 0x27, + 0xe4, 0x12, 0x6d, 0x40, 0x9d, 0x93, 0x1c, 0x99, 0x81, 0xe9, 0x4a, 0x8f, 0xb8, 0xa8, 0x0c, 0xd4, + 0x3b, 0xf8, 0xf0, 0x81, 0xe9, 0x8c, 0xf1, 0x8e, 0x69, 0x07, 0x06, 0xd7, 0xe0, 0x0e, 0xdb, 0x85, + 0xae, 0x41, 0x9b, 0x53, 0xd9, 0xb7, 0x1d, 0x2c, 0x7c, 0x8b, 0xe6, 0xa2, 0xaa, 0xd1, 0x64, 0xf0, + 0xdb, 0xb6, 0x83, 0xb9, 0xfb, 0x44, 0x47, 0x60, 0x3a, 0x5b, 0xe0, 0xde, 0xc3, 0x20, 0x4c, 0x63, + 0xff, 0x2c, 0xc0, 0x22, 0x0d, 0x22, 0x59, 0x7c, 0x4f, 0x9e, 0x47, 0x5e, 0x07, 0xb0, 0x48, 0xd8, + 0x4b, 0xe4, 0x92, 0xaa, 0x45, 0xc2, 0x6d, 0x9e, 0x4e, 0xde, 0x95, 0xa9, 0xa2, 0x98, 0xdd, 0xb6, + 0xa6, 0x82, 0x7a, 0x3a, 0x69, 0x9f, 0xe8, 0x7a, 0x7f, 0x09, 0x1a, 0xc4, 0x1f, 0x07, 0x03, 0xdc, + 0x4b, 0x5c, 0xb3, 0xea, 0x1c, 0xb8, 0xad, 0xce, 0x76, 0x15, 0xe5, 0x33, 0x43, 0x2c, 0x6d, 0xcd, + 0xcf, 0x9c, 0xb6, 0xfe, 0xa6, 0xc1, 0x92, 0xb8, 0x92, 0x9e, 0x5e, 0xdb, 0x59, 0x59, 0x5b, 0xe6, + 0xa8, 0xe2, 0x11, 0xd7, 0x9b, 0x52, 0x8e, 0x9a, 0x5b, 0x56, 0xd4, 0xdc, 0x64, 0x8b, 0x5f, 0x49, + 0xb7, 0xf8, 0xfa, 0x0f, 0x35, 0x68, 0xec, 0x62, 0x33, 0x18, 0x1c, 0xc8, 0x73, 0xbd, 0x03, 0xc5, + 0x00, 0x3f, 0x11, 0xc7, 0x4a, 0xc5, 0xbb, 0x58, 0x24, 0x36, 0x18, 0x14, 0x1d, 0x5d, 0x80, 0x9a, + 0xe5, 0x3a, 0xa9, 0x7b, 0x24, 0x58, 0xae, 0x23, 0xfb, 0xad, 0xa4, 0x20, 0xc5, 0x29, 0x41, 0x3e, + 0xd6, 0xa0, 0x7e, 0x8f, 0x37, 0x5d, 0x5c, 0x8e, 0x5b, 0x71, 0x39, 0x2e, 0x2a, 0xe5, 0x88, 0xe3, + 0x7f, 0x46, 0x62, 0xfc, 0x5c, 0x83, 0xa5, 0xf7, 0x4d, 0xcf, 0xf2, 0xf7, 0xf7, 0x4f, 0x6f, 0xf0, + 0xf5, 0x28, 0xfb, 0x6d, 0xcd, 0x72, 0xa5, 0x49, 0x6c, 0xd2, 0x7f, 0x54, 0x00, 0x44, 0xbd, 0x73, + 0xcd, 0x74, 0x4c, 0x6f, 0x80, 0x4f, 0x2e, 0xcd, 0x65, 0x68, 0x26, 0x62, 0x2a, 0x7a, 0x9e, 0x8d, + 0x07, 0x15, 0x41, 0x77, 0xa0, 0xd9, 0xe7, 0xac, 0x7a, 0x01, 0x36, 0x89, 0xef, 0x31, 0xbf, 0x6c, + 0xae, 0xbe, 0xa9, 0x12, 0x7b, 0x2f, 0xb0, 0x87, 0x43, 0x1c, 0xac, 0xfb, 0x9e, 0xc5, 0x2f, 0x1b, + 0x8d, 0xbe, 0x14, 0x93, 0x6e, 0x65, 0xf6, 0x88, 0x12, 0x8c, 0xec, 0x0a, 0x21, 0xca, 0x30, 0x04, + 0xbd, 0x05, 0x67, 0x92, 0xf7, 0x90, 0x89, 0x23, 0xb7, 0x49, 0xfc, 0x8a, 0x41, 0x8d, 0xf3, 0x03, + 0x40, 0x51, 0x9f, 0xcb, 0xda, 0x29, 0x56, 0x2d, 0xf2, 0x3c, 0xab, 0xbc, 0x06, 0x55, 0x4b, 0xee, + 0x14, 0x5e, 0x31, 0x01, 0xd0, 0x6c, 0xc3, 0x25, 0xec, 0xd1, 0xc0, 0xc7, 0x96, 0xec, 0x24, 0x38, + 0xf0, 0x03, 0x06, 0xd3, 0x3f, 0x2d, 0x40, 0x3b, 0x7e, 0xb7, 0xc9, 0xcd, 0xfb, 0xc5, 0x3c, 0xb2, + 0x1c, 0x71, 0x91, 0x2b, 0x9d, 0xe2, 0x22, 0x37, 0x7d, 0xd1, 0x2c, 0x9f, 0xec, 0xa2, 0xa9, 0xff, + 0x5a, 0x83, 0x56, 0xea, 0x4d, 0x23, 0xdd, 0xd3, 0x69, 0xd3, 0x3d, 0xdd, 0xd7, 0xa0, 0x4c, 0x1b, + 0x1d, 0xcc, 0x94, 0xd4, 0x54, 0xf7, 0x1b, 0x49, 0xaa, 0x06, 0xdf, 0x80, 0x6e, 0xc0, 0xa2, 0xe2, + 0x1d, 0x5c, 0x98, 0x12, 0x4d, 0x3f, 0x83, 0xeb, 0x7f, 0x2c, 0x41, 0x2d, 0xa6, 0x8f, 0x63, 0xda, + 0xd1, 0x3c, 0x37, 0xb6, 0xd4, 0xf1, 0x8a, 0xd3, 0xc7, 0xcb, 0x78, 0x08, 0x46, 0xe7, 0x61, 0xc1, + 0xc5, 0x2e, 0xaf, 0xf7, 0xa2, 0xf9, 0x70, 0xb1, 0x4b, 0xab, 0x3d, 0xfd, 0x44, 0x7b, 0x49, 0xd6, + 0x48, 0xf2, 0x0a, 0x37, 0xef, 0x8d, 0x5d, 0xd6, 0x46, 0x26, 0x5b, 0x9d, 0xf9, 0x23, 0x5a, 0x9d, + 0x85, 0x64, 0xab, 0x93, 0x08, 0x87, 0x6a, 0x3a, 0x1c, 0xf2, 0x76, 0x88, 0x37, 0x61, 0x71, 0xc0, + 0x1e, 0x24, 0xad, 0xb5, 0xc3, 0xf5, 0xe8, 0x53, 0xa7, 0xc6, 0x7a, 0x32, 0xd5, 0x27, 0x74, 0x9b, + 0x3a, 0x97, 0x68, 0x07, 0x99, 0x95, 0xeb, 0xcc, 0xca, 0xea, 0x4e, 0x4a, 0xd8, 0x86, 0x1b, 0x59, + 0xe6, 0x44, 0xb6, 0x4a, 0xf7, 0xa6, 0x8d, 0x13, 0xf5, 0xa6, 0x17, 0xa0, 0x26, 0x5f, 0xa5, 0x6d, + 0x8b, 0x74, 0x9a, 0x3c, 0x37, 0x09, 0xd0, 0x96, 0x45, 0x98, 0xe6, 0x7d, 0x7a, 0x6d, 0xb4, 0x48, + 0xa7, 0xc5, 0xbe, 0xce, 0x33, 0x73, 0x59, 0x44, 0xff, 0xa4, 0x08, 0xcd, 0x49, 0xf3, 0x92, 0x3b, + 0x15, 0xe4, 0x99, 0xe7, 0x6c, 0x43, 0x7b, 0xf2, 0x78, 0xc8, 0xb4, 0x74, 0x64, 0xff, 0x95, 0x7e, + 0x36, 0x6c, 0x8d, 0x52, 0x31, 0x97, 0x78, 0xa5, 0x28, 0xcd, 0xf4, 0x4a, 0x71, 0xca, 0x67, 0xff, + 0x5b, 0x70, 0x2e, 0xe0, 0xbd, 0x93, 0xd5, 0x4b, 0x1c, 0x9b, 0xb7, 0x21, 0x67, 0xe5, 0xc7, 0x9d, + 0xf8, 0xf1, 0x33, 0xc2, 0x78, 0x3e, 0x2b, 0x8c, 0xd3, 0x66, 0x5c, 0x48, 0x9b, 0x51, 0xbf, 0x0f, + 0x8b, 0xf7, 0x3d, 0x32, 0xee, 0x93, 0x41, 0x60, 0xf7, 0xb1, 0xbc, 0x7c, 0xe7, 0xb2, 0x57, 0x17, + 0x16, 0x44, 0x22, 0xe6, 0xb6, 0xaa, 0x1a, 0xd1, 0x5a, 0xff, 0x89, 0x06, 0x4b, 0xd3, 0x74, 0x99, + 0x2b, 0x4c, 0xa2, 0x5c, 0x4b, 0x44, 0xf9, 0x77, 0x61, 0x71, 0x42, 0xbe, 0x97, 0xa0, 0x5c, 0x5b, + 0xbd, 0xaa, 0x32, 0x8a, 0x42, 0x70, 0x03, 0x4d, 0x68, 0x48, 0x98, 0xfe, 0x2f, 0x0d, 0xce, 0x88, + 0x78, 0xa1, 0xb0, 0x21, 0x7b, 0xb6, 0xa0, 0x95, 0xc7, 0xf7, 0x1c, 0xdb, 0x8b, 0xba, 0x68, 0x71, + 0x46, 0x0e, 0x14, 0x5d, 0xf4, 0xfb, 0xd0, 0x12, 0x48, 0x51, 0x01, 0xc9, 0xd9, 0xa7, 0x34, 0xf9, + 0xbe, 0xa8, 0x74, 0x5c, 0x86, 0xa6, 0xbf, 0xbf, 0x1f, 0xe7, 0xc7, 0x33, 0x60, 0x43, 0x40, 0x05, + 0xc3, 0x6f, 0x43, 0x5b, 0xa2, 0xcd, 0x5a, 0xb2, 0x5a, 0x62, 0x63, 0xf4, 0xec, 0xf8, 0x63, 0x0d, + 0x3a, 0xc9, 0x02, 0x16, 0x3b, 0xfe, 0xec, 0x2d, 0xd2, 0xd7, 0x93, 0x8f, 0xcf, 0x97, 0x8f, 0x90, + 0x67, 0xc2, 0x47, 0x3e, 0x41, 0xff, 0x55, 0x83, 0x9a, 0x21, 0xdc, 0x8e, 0xb2, 0x7f, 0x1d, 0x60, + 0xe2, 0x98, 0xb2, 0xa0, 0x44, 0x7e, 0x49, 0x8d, 0x13, 0x73, 0x06, 0xdb, 0x52, 0x54, 0x14, 0x86, + 0x34, 0x49, 0x06, 0xd4, 0xbd, 0xa7, 0x1e, 0x01, 0x2d, 0x5a, 0xb2, 0x9b, 0xe4, 0xc0, 0x0c, 0xac, + 0x9e, 0x20, 0x2e, 0xd5, 0xa9, 0xbc, 0xe8, 0xec, 0x52, 0x4c, 0x21, 0xa6, 0xd1, 0x20, 0xb1, 0x55, + 0x32, 0xe1, 0x95, 0x93, 0x09, 0x6f, 0x1b, 0xea, 0xf1, 0x9d, 0xd4, 0xc5, 0x1d, 0x6c, 0x5a, 0x38, + 0x90, 0x2e, 0xce, 0x57, 0xe8, 0x0a, 0xb4, 0x2c, 0x57, 0xba, 0x36, 0xaf, 0x4b, 0xbc, 0xdd, 0x69, + 0x44, 0xf5, 0x85, 0xd6, 0xa6, 0xeb, 0xcf, 0xa1, 0x99, 0xcc, 0x5c, 0xa8, 0x0e, 0x0b, 0xdb, 0x7e, + 0xf8, 0xad, 0x67, 0x36, 0x09, 0xdb, 0x73, 0xa8, 0x09, 0xb0, 0xed, 0x87, 0x3b, 0x01, 0x26, 0xd8, + 0x0b, 0xdb, 0x1a, 0x02, 0xa8, 0x7c, 0xe8, 0x6d, 0xd8, 0xe4, 0x71, 0xbb, 0x80, 0x16, 0x45, 0x63, + 0x61, 0x3a, 0x5b, 0x22, 0x1d, 0xb4, 0x8b, 0x74, 0x7b, 0xb4, 0x2a, 0xa1, 0x36, 0xd4, 0x23, 0x94, + 0xcd, 0x9d, 0xfb, 0xed, 0x32, 0xaa, 0x42, 0x99, 0xff, 0xac, 0x5c, 0xb7, 0xa0, 0x9d, 0xee, 0x5b, + 0x29, 0xcd, 0xfb, 0xde, 0x1d, 0xcf, 0x7f, 0x1a, 0x81, 0xda, 0x73, 0xa8, 0x06, 0xf3, 0xe2, 0x2e, + 0xd0, 0xd6, 0x50, 0x0b, 0x6a, 0xb1, 0x36, 0xbc, 0x5d, 0xa0, 0x80, 0xcd, 0x60, 0x34, 0x10, 0x0d, + 0x39, 0x17, 0x81, 0xba, 0xf8, 0x86, 0xff, 0xd4, 0x6b, 0x97, 0xae, 0xaf, 0xc1, 0x82, 0x4c, 0xa9, + 0x14, 0x95, 0x53, 0xf7, 0xe8, 0xb2, 0x3d, 0x87, 0xce, 0x40, 0x23, 0x31, 0xf7, 0x6d, 0x6b, 0x08, + 0x41, 0x33, 0x39, 0x93, 0x6f, 0x17, 0x56, 0xff, 0x5c, 0x03, 0xe0, 0x3d, 0xa7, 0xef, 0x07, 0x16, + 0x1a, 0x01, 0xda, 0xc4, 0x21, 0xad, 0xa7, 0xbe, 0x27, 0x6b, 0x21, 0x41, 0x37, 0x33, 0x5a, 0xb3, + 0x69, 0x54, 0x21, 0x6a, 0xf7, 0x4a, 0xc6, 0x8e, 0x14, 0xba, 0x3e, 0x87, 0x5c, 0xc6, 0x71, 0xcf, + 0x76, 0xf1, 0x9e, 0x3d, 0x78, 0x1c, 0x35, 0xab, 0xd9, 0x1c, 0x53, 0xa8, 0x92, 0xe3, 0x25, 0xf5, + 0x3d, 0x32, 0x0c, 0x6c, 0x6f, 0x28, 0xe7, 0x45, 0xfa, 0x1c, 0x7a, 0x02, 0x67, 0x37, 0x31, 0xe3, + 0x6e, 0x93, 0xd0, 0x1e, 0x10, 0xc9, 0x70, 0x35, 0x9b, 0xe1, 0x14, 0xf2, 0x8c, 0x2c, 0x1d, 0x68, + 0xa5, 0xfe, 0x03, 0x83, 0xae, 0xab, 0xe3, 0x46, 0xf5, 0x7f, 0x9d, 0xee, 0x5b, 0xb9, 0x70, 0x23, + 0x6e, 0x36, 0x34, 0x93, 0xff, 0x0f, 0x41, 0x5f, 0xca, 0x22, 0x30, 0x35, 0x02, 0xef, 0x5e, 0xcf, + 0x83, 0x1a, 0xb1, 0x7a, 0xc8, 0xfd, 0xe9, 0x38, 0x56, 0xca, 0xbf, 0x1f, 0x74, 0x8f, 0x1a, 0xd5, + 0xe9, 0x73, 0xe8, 0xfb, 0x70, 0x66, 0x6a, 0x50, 0x8f, 0xbe, 0xac, 0x22, 0x9f, 0x35, 0xcf, 0x3f, + 0x8e, 0xc3, 0xc3, 0x74, 0x34, 0x64, 0x4b, 0x3f, 0xf5, 0xc7, 0x8e, 0xfc, 0xd2, 0xc7, 0xc8, 0x1f, + 0x25, 0xfd, 0xcc, 0x1c, 0xc6, 0x80, 0xa6, 0x47, 0xf5, 0xe8, 0x6d, 0x15, 0x8b, 0xcc, 0xbf, 0x0b, + 0x74, 0x57, 0xf2, 0xa2, 0x47, 0x26, 0x1f, 0xb3, 0x68, 0x4d, 0x5f, 0xba, 0x94, 0x6c, 0x33, 0xc7, + 0xf3, 0x6a, 0xb6, 0xd9, 0x13, 0x72, 0xee, 0xd4, 0xc9, 0x09, 0xb0, 0xda, 0x56, 0xca, 0xa9, 0xb5, + 0xda, 0xa9, 0xd5, 0x03, 0x65, 0x7d, 0x0e, 0xed, 0x25, 0x92, 0x30, 0xba, 0x92, 0xe5, 0x13, 0xc9, + 0xc7, 0x92, 0xe3, 0xcc, 0xd5, 0x03, 0xd8, 0xc4, 0xe1, 0x5d, 0x1c, 0x06, 0xf6, 0x80, 0xa4, 0x89, + 0x8a, 0xc5, 0x04, 0x41, 0x12, 0xbd, 0x7a, 0x2c, 0x9e, 0x14, 0x7b, 0xf5, 0x2f, 0x35, 0xa8, 0x32, + 0x9b, 0xd1, 0xfa, 0xf0, 0xff, 0x34, 0xfe, 0x02, 0xd2, 0xf8, 0x23, 0x68, 0xa5, 0xc6, 0xff, 0xea, + 0x34, 0xae, 0xfe, 0x8f, 0xc0, 0x71, 0x0e, 0xd2, 0x07, 0x34, 0x3d, 0xdc, 0x56, 0x07, 0x56, 0xe6, + 0x10, 0xfc, 0x38, 0x1e, 0x8f, 0xa0, 0x95, 0x9a, 0xe4, 0xaa, 0x4f, 0xa0, 0x1e, 0xf7, 0xe6, 0x38, + 0xc1, 0xf4, 0x00, 0x52, 0x7d, 0x82, 0xcc, 0x41, 0xe5, 0x71, 0x3c, 0x1e, 0xf0, 0xf9, 0x78, 0x74, + 0x1f, 0xb8, 0x9a, 0x15, 0x9d, 0xa9, 0x97, 0xd5, 0x97, 0x9f, 0xaf, 0x5f, 0x7c, 0x3d, 0x7b, 0x04, + 0xad, 0xd4, 0x1c, 0x41, 0x6d, 0x5d, 0xf5, 0xb0, 0xe1, 0x38, 0xea, 0x9f, 0x63, 0x06, 0xbe, 0x07, + 0x15, 0xfe, 0xfc, 0x8f, 0x2e, 0xaa, 0x6f, 0x47, 0xb1, 0xd1, 0x40, 0xf7, 0xe8, 0xf1, 0x01, 0x19, + 0x3b, 0x21, 0x95, 0x7e, 0x1b, 0xca, 0x2c, 0x5e, 0x90, 0xf2, 0xc2, 0x12, 0x7f, 0xe4, 0xef, 0x1e, + 0x39, 0x07, 0x90, 0xf4, 0x5e, 0x74, 0x3a, 0x5f, 0x7b, 0xe7, 0xe1, 0xea, 0xd0, 0x0e, 0x0f, 0xc6, + 0x7d, 0x6a, 0x88, 0x1b, 0x1c, 0xf3, 0x6d, 0xdb, 0x17, 0xbf, 0x6e, 0xc8, 0xbc, 0x76, 0x83, 0x51, + 0xba, 0xc1, 0x8e, 0x31, 0xea, 0xf7, 0x2b, 0x6c, 0x79, 0xeb, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0xa5, 0x1e, 0x78, 0x64, 0x71, 0x2e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/internal/proto/root_coord.proto b/internal/proto/root_coord.proto index 7c0d07eb01..fe1153cf9c 100644 --- a/internal/proto/root_coord.proto +++ b/internal/proto/root_coord.proto @@ -8,6 +8,7 @@ import "milvus.proto"; import "internal.proto"; import "proxy.proto"; import "data_coord.proto"; +import "etcd_meta.proto"; service RootCoord { rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {} @@ -92,6 +93,7 @@ service RootCoord { rpc DescribeSegment(milvus.DescribeSegmentRequest) returns (milvus.DescribeSegmentResponse) {} rpc ShowSegments(milvus.ShowSegmentsRequest) returns (milvus.ShowSegmentsResponse) {} + rpc DescribeSegments(DescribeSegmentsRequest) returns (DescribeSegmentsResponse) {} rpc CreateIndex(milvus.CreateIndexRequest) returns (common.Status) {} rpc DescribeIndex(milvus.DescribeIndexRequest) returns (milvus.DescribeIndexResponse) {} @@ -143,4 +145,30 @@ message ImportResult { repeated int64 auto_ids = 6; // auto-generated ids for auto-id primary key int64 row_count = 7; // how many rows are imported by this task repeated common.KeyValuePair infos = 8; // more informations about the task, file path, failed reason, etc. -} \ No newline at end of file +} + +// TODO: find a proper place for these segment-related messages. + +message DescribeSegmentsRequest { + common.MsgBase base = 1; + int64 collectionID = 2; + repeated int64 segmentIDs = 3; +} + +message SegmentBaseInfo { + int64 collectionID = 1; // in which collection. + int64 partitionID = 2; // in which partition. + int64 segmentID = 3; +} + +message SegmentInfos { + SegmentBaseInfo base_info = 1; // base information. + repeated etcd.SegmentIndexInfo index_infos = 2; // multiple index infos. + map extra_index_infos = 3; // index_id -> IndexInfo{index_name, index_id, index_params} +} + +message DescribeSegmentsResponse { + common.Status status = 1; + int64 collectionID = 2; + map segment_infos = 3; // segment_id -> segment infos +} diff --git a/internal/proto/rootcoordpb/root_coord.pb.go b/internal/proto/rootcoordpb/root_coord.pb.go index 2f2ee7addf..29fa53c146 100644 --- a/internal/proto/rootcoordpb/root_coord.pb.go +++ b/internal/proto/rootcoordpb/root_coord.pb.go @@ -9,6 +9,7 @@ import ( proto "github.com/golang/protobuf/proto" commonpb "github.com/milvus-io/milvus/internal/proto/commonpb" datapb "github.com/milvus-io/milvus/internal/proto/datapb" + etcdpb "github.com/milvus-io/milvus/internal/proto/etcdpb" internalpb "github.com/milvus-io/milvus/internal/proto/internalpb" milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb" proxypb "github.com/milvus-io/milvus/internal/proto/proxypb" @@ -328,83 +329,325 @@ func (m *ImportResult) GetInfos() []*commonpb.KeyValuePair { return nil } +type DescribeSegmentsRequest struct { + Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` + CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + SegmentIDs []int64 `protobuf:"varint,3,rep,packed,name=segmentIDs,proto3" json:"segmentIDs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DescribeSegmentsRequest) Reset() { *m = DescribeSegmentsRequest{} } +func (m *DescribeSegmentsRequest) String() string { return proto.CompactTextString(m) } +func (*DescribeSegmentsRequest) ProtoMessage() {} +func (*DescribeSegmentsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_4513485a144f6b06, []int{5} +} + +func (m *DescribeSegmentsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DescribeSegmentsRequest.Unmarshal(m, b) +} +func (m *DescribeSegmentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DescribeSegmentsRequest.Marshal(b, m, deterministic) +} +func (m *DescribeSegmentsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DescribeSegmentsRequest.Merge(m, src) +} +func (m *DescribeSegmentsRequest) XXX_Size() int { + return xxx_messageInfo_DescribeSegmentsRequest.Size(m) +} +func (m *DescribeSegmentsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DescribeSegmentsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DescribeSegmentsRequest proto.InternalMessageInfo + +func (m *DescribeSegmentsRequest) GetBase() *commonpb.MsgBase { + if m != nil { + return m.Base + } + return nil +} + +func (m *DescribeSegmentsRequest) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *DescribeSegmentsRequest) GetSegmentIDs() []int64 { + if m != nil { + return m.SegmentIDs + } + return nil +} + +type SegmentBaseInfo struct { + CollectionID int64 `protobuf:"varint,1,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + SegmentID int64 `protobuf:"varint,3,opt,name=segmentID,proto3" json:"segmentID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SegmentBaseInfo) Reset() { *m = SegmentBaseInfo{} } +func (m *SegmentBaseInfo) String() string { return proto.CompactTextString(m) } +func (*SegmentBaseInfo) ProtoMessage() {} +func (*SegmentBaseInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_4513485a144f6b06, []int{6} +} + +func (m *SegmentBaseInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SegmentBaseInfo.Unmarshal(m, b) +} +func (m *SegmentBaseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SegmentBaseInfo.Marshal(b, m, deterministic) +} +func (m *SegmentBaseInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SegmentBaseInfo.Merge(m, src) +} +func (m *SegmentBaseInfo) XXX_Size() int { + return xxx_messageInfo_SegmentBaseInfo.Size(m) +} +func (m *SegmentBaseInfo) XXX_DiscardUnknown() { + xxx_messageInfo_SegmentBaseInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_SegmentBaseInfo proto.InternalMessageInfo + +func (m *SegmentBaseInfo) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *SegmentBaseInfo) GetPartitionID() int64 { + if m != nil { + return m.PartitionID + } + return 0 +} + +func (m *SegmentBaseInfo) GetSegmentID() int64 { + if m != nil { + return m.SegmentID + } + return 0 +} + +type SegmentInfos struct { + BaseInfo *SegmentBaseInfo `protobuf:"bytes,1,opt,name=base_info,json=baseInfo,proto3" json:"base_info,omitempty"` + IndexInfos []*etcdpb.SegmentIndexInfo `protobuf:"bytes,2,rep,name=index_infos,json=indexInfos,proto3" json:"index_infos,omitempty"` + ExtraIndexInfos map[int64]*etcdpb.IndexInfo `protobuf:"bytes,3,rep,name=extra_index_infos,json=extraIndexInfos,proto3" json:"extra_index_infos,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SegmentInfos) Reset() { *m = SegmentInfos{} } +func (m *SegmentInfos) String() string { return proto.CompactTextString(m) } +func (*SegmentInfos) ProtoMessage() {} +func (*SegmentInfos) Descriptor() ([]byte, []int) { + return fileDescriptor_4513485a144f6b06, []int{7} +} + +func (m *SegmentInfos) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SegmentInfos.Unmarshal(m, b) +} +func (m *SegmentInfos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SegmentInfos.Marshal(b, m, deterministic) +} +func (m *SegmentInfos) XXX_Merge(src proto.Message) { + xxx_messageInfo_SegmentInfos.Merge(m, src) +} +func (m *SegmentInfos) XXX_Size() int { + return xxx_messageInfo_SegmentInfos.Size(m) +} +func (m *SegmentInfos) XXX_DiscardUnknown() { + xxx_messageInfo_SegmentInfos.DiscardUnknown(m) +} + +var xxx_messageInfo_SegmentInfos proto.InternalMessageInfo + +func (m *SegmentInfos) GetBaseInfo() *SegmentBaseInfo { + if m != nil { + return m.BaseInfo + } + return nil +} + +func (m *SegmentInfos) GetIndexInfos() []*etcdpb.SegmentIndexInfo { + if m != nil { + return m.IndexInfos + } + return nil +} + +func (m *SegmentInfos) GetExtraIndexInfos() map[int64]*etcdpb.IndexInfo { + if m != nil { + return m.ExtraIndexInfos + } + return nil +} + +type DescribeSegmentsResponse struct { + Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + SegmentInfos map[int64]*SegmentInfos `protobuf:"bytes,3,rep,name=segment_infos,json=segmentInfos,proto3" json:"segment_infos,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DescribeSegmentsResponse) Reset() { *m = DescribeSegmentsResponse{} } +func (m *DescribeSegmentsResponse) String() string { return proto.CompactTextString(m) } +func (*DescribeSegmentsResponse) ProtoMessage() {} +func (*DescribeSegmentsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4513485a144f6b06, []int{8} +} + +func (m *DescribeSegmentsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DescribeSegmentsResponse.Unmarshal(m, b) +} +func (m *DescribeSegmentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DescribeSegmentsResponse.Marshal(b, m, deterministic) +} +func (m *DescribeSegmentsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DescribeSegmentsResponse.Merge(m, src) +} +func (m *DescribeSegmentsResponse) XXX_Size() int { + return xxx_messageInfo_DescribeSegmentsResponse.Size(m) +} +func (m *DescribeSegmentsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DescribeSegmentsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DescribeSegmentsResponse proto.InternalMessageInfo + +func (m *DescribeSegmentsResponse) GetStatus() *commonpb.Status { + if m != nil { + return m.Status + } + return nil +} + +func (m *DescribeSegmentsResponse) GetCollectionID() int64 { + if m != nil { + return m.CollectionID + } + return 0 +} + +func (m *DescribeSegmentsResponse) GetSegmentInfos() map[int64]*SegmentInfos { + if m != nil { + return m.SegmentInfos + } + return nil +} + func init() { proto.RegisterType((*AllocTimestampRequest)(nil), "milvus.proto.rootcoord.AllocTimestampRequest") proto.RegisterType((*AllocTimestampResponse)(nil), "milvus.proto.rootcoord.AllocTimestampResponse") proto.RegisterType((*AllocIDRequest)(nil), "milvus.proto.rootcoord.AllocIDRequest") proto.RegisterType((*AllocIDResponse)(nil), "milvus.proto.rootcoord.AllocIDResponse") proto.RegisterType((*ImportResult)(nil), "milvus.proto.rootcoord.ImportResult") + proto.RegisterType((*DescribeSegmentsRequest)(nil), "milvus.proto.rootcoord.DescribeSegmentsRequest") + proto.RegisterType((*SegmentBaseInfo)(nil), "milvus.proto.rootcoord.SegmentBaseInfo") + proto.RegisterType((*SegmentInfos)(nil), "milvus.proto.rootcoord.SegmentInfos") + proto.RegisterMapType((map[int64]*etcdpb.IndexInfo)(nil), "milvus.proto.rootcoord.SegmentInfos.ExtraIndexInfosEntry") + proto.RegisterType((*DescribeSegmentsResponse)(nil), "milvus.proto.rootcoord.DescribeSegmentsResponse") + proto.RegisterMapType((map[int64]*SegmentInfos)(nil), "milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry") } func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) } var fileDescriptor_4513485a144f6b06 = []byte{ - // 1031 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0x7f, 0x6f, 0xda, 0x46, - 0x18, 0xc7, 0x43, 0x48, 0x48, 0xf2, 0x40, 0x48, 0x74, 0x6a, 0x52, 0x46, 0x2b, 0x8d, 0xb2, 0xad, - 0x25, 0x4d, 0x0b, 0x15, 0x95, 0xba, 0xfd, 0x9b, 0x80, 0x96, 0xa2, 0x2d, 0x52, 0x6b, 0xda, 0x69, - 0xbf, 0x2a, 0x74, 0xd8, 0xcf, 0xc0, 0x8a, 0xed, 0x73, 0x7c, 0xc7, 0xd2, 0xfe, 0xb9, 0xb7, 0xb6, - 0x17, 0xb1, 0xd7, 0x33, 0x9d, 0xed, 0x33, 0xb6, 0xb1, 0x89, 0xb3, 0xf5, 0x3f, 0xce, 0xf7, 0xb9, - 0xef, 0xf7, 0x9e, 0xe7, 0x7e, 0x3d, 0xc0, 0xa1, 0xc7, 0x98, 0x98, 0xe8, 0x8c, 0x79, 0x46, 0xd7, - 0xf5, 0x98, 0x60, 0xe4, 0xd8, 0x36, 0xad, 0x3f, 0x17, 0x3c, 0x68, 0x75, 0x65, 0xb7, 0xdf, 0xdb, - 0xac, 0xe9, 0xcc, 0xb6, 0x99, 0x13, 0x7c, 0x6f, 0xd6, 0xe2, 0x54, 0xb3, 0x6e, 0x3a, 0x02, 0x3d, - 0x87, 0x5a, 0x61, 0xbb, 0xea, 0x7a, 0xec, 0xe3, 0xa7, 0xb0, 0x71, 0x68, 0x50, 0x41, 0xe3, 0x16, - 0xed, 0x09, 0x1c, 0x9d, 0x59, 0x16, 0xd3, 0xdf, 0x99, 0x36, 0x72, 0x41, 0x6d, 0x57, 0xc3, 0xeb, - 0x05, 0x72, 0x41, 0x5e, 0xc0, 0xd6, 0x94, 0x72, 0x6c, 0x94, 0x5a, 0xa5, 0x4e, 0xb5, 0xff, 0xb0, - 0x9b, 0x98, 0x4a, 0xe8, 0x7f, 0xc9, 0x67, 0xe7, 0x94, 0xa3, 0xe6, 0x93, 0xe4, 0x1e, 0x6c, 0xeb, - 0x6c, 0xe1, 0x88, 0x46, 0xb9, 0x55, 0xea, 0xec, 0x6b, 0x41, 0xa3, 0xfd, 0x57, 0x09, 0x8e, 0xd3, - 0x0e, 0xdc, 0x65, 0x0e, 0x47, 0xf2, 0x12, 0x2a, 0x5c, 0x50, 0xb1, 0xe0, 0xa1, 0xc9, 0x83, 0x4c, - 0x93, 0xb1, 0x8f, 0x68, 0x21, 0x4a, 0x1e, 0xc2, 0x9e, 0x50, 0x4a, 0x8d, 0xcd, 0x56, 0xa9, 0xb3, - 0xa5, 0x2d, 0x3f, 0xe4, 0xcc, 0xe1, 0x67, 0xa8, 0xfb, 0x53, 0x18, 0x0d, 0x3f, 0x43, 0x74, 0x9b, - 0x71, 0x65, 0x0b, 0x0e, 0x22, 0xe5, 0xff, 0x13, 0x55, 0x1d, 0x36, 0x47, 0x43, 0x5f, 0xba, 0xac, - 0x6d, 0x8e, 0x86, 0x39, 0x71, 0xfc, 0xbd, 0x09, 0xb5, 0x91, 0xed, 0x32, 0x4f, 0x68, 0xc8, 0x17, - 0x96, 0xf8, 0x6f, 0x5e, 0xf7, 0x61, 0x47, 0x50, 0x7e, 0x35, 0x31, 0x8d, 0xd0, 0xb0, 0x22, 0x9b, - 0x23, 0x83, 0x7c, 0x09, 0x55, 0xb9, 0x3f, 0x1c, 0x66, 0xa0, 0xec, 0x2c, 0xfb, 0x9d, 0xa0, 0x3e, - 0x8d, 0x0c, 0xf2, 0x0a, 0xb6, 0xa5, 0x06, 0x36, 0xb6, 0x5a, 0xa5, 0x4e, 0xbd, 0xdf, 0xca, 0x74, - 0x0b, 0x26, 0x28, 0x3d, 0x51, 0x0b, 0x70, 0xd2, 0x84, 0x5d, 0x8e, 0x33, 0x1b, 0x1d, 0xc1, 0x1b, - 0xdb, 0xad, 0x72, 0xa7, 0xac, 0x45, 0x6d, 0xf2, 0x05, 0xec, 0xd2, 0x85, 0x60, 0x13, 0xd3, 0xe0, - 0x8d, 0x8a, 0xdf, 0xb7, 0x23, 0xdb, 0x23, 0x83, 0x93, 0x07, 0xb0, 0xe7, 0xb1, 0x9b, 0x49, 0x90, - 0x88, 0x1d, 0x7f, 0x36, 0xbb, 0x1e, 0xbb, 0x19, 0xc8, 0x36, 0xf9, 0x16, 0xb6, 0x4d, 0xe7, 0x0f, - 0xc6, 0x1b, 0xbb, 0xad, 0x72, 0xa7, 0xda, 0x7f, 0x94, 0x39, 0x97, 0x1f, 0xf0, 0xd3, 0x4f, 0xd4, - 0x5a, 0xe0, 0x1b, 0x6a, 0x7a, 0x5a, 0xc0, 0xf7, 0xff, 0x39, 0x86, 0x3d, 0x8d, 0x31, 0x31, 0x90, - 0xa7, 0x80, 0xb8, 0x40, 0x2e, 0x50, 0x0c, 0x98, 0xed, 0x32, 0x07, 0x9d, 0x60, 0xda, 0x9c, 0xbc, - 0x48, 0xaa, 0x45, 0x47, 0x6a, 0x15, 0x0d, 0x37, 0x54, 0xf3, 0x71, 0xce, 0x88, 0x14, 0xde, 0xde, - 0x20, 0xb6, 0xef, 0x28, 0x4f, 0xc3, 0x3b, 0x53, 0xbf, 0x1a, 0xcc, 0xa9, 0xe3, 0xa0, 0xb5, 0xce, - 0x31, 0x85, 0x2a, 0xc7, 0xaf, 0x92, 0x23, 0xc2, 0xc6, 0x58, 0x78, 0xa6, 0x33, 0x53, 0x9b, 0xb1, - 0xbd, 0x41, 0xae, 0xe1, 0xde, 0x05, 0xfa, 0xee, 0x26, 0x17, 0xa6, 0xce, 0x95, 0x61, 0x3f, 0xdf, - 0x70, 0x05, 0xbe, 0xa3, 0xe5, 0x04, 0x0e, 0x07, 0x1e, 0x52, 0x81, 0x03, 0x66, 0x59, 0xa8, 0x0b, - 0x93, 0x39, 0xe4, 0x59, 0xe6, 0xd0, 0x34, 0xa6, 0x8c, 0xd6, 0xed, 0xe3, 0xf6, 0x06, 0xf9, 0x0d, - 0xea, 0x43, 0x8f, 0xb9, 0x31, 0xf9, 0xa7, 0x99, 0xf2, 0x49, 0xa8, 0xa0, 0xf8, 0x04, 0xf6, 0x5f, - 0x53, 0x1e, 0xd3, 0x3e, 0xc9, 0xd4, 0x4e, 0x30, 0x4a, 0xfa, 0x51, 0x26, 0x7a, 0xce, 0x98, 0x15, - 0x4b, 0xcf, 0x0d, 0x90, 0x21, 0x72, 0xdd, 0x33, 0xa7, 0xf1, 0x04, 0x75, 0xb3, 0x23, 0x58, 0x01, - 0x95, 0x55, 0xaf, 0x30, 0x1f, 0x19, 0xbf, 0x87, 0x6a, 0x90, 0xf0, 0x33, 0xcb, 0xa4, 0x9c, 0x3c, - 0x59, 0xb3, 0x24, 0x3e, 0x51, 0x30, 0x61, 0x6f, 0x61, 0x4f, 0x26, 0x3a, 0x10, 0xfd, 0x26, 0x77, - 0x21, 0xee, 0x22, 0x39, 0x06, 0x38, 0xb3, 0x04, 0x7a, 0x81, 0xe6, 0xe3, 0x4c, 0xcd, 0x25, 0x50, - 0x50, 0xd4, 0x81, 0x83, 0xf1, 0x5c, 0x5e, 0x1f, 0x2a, 0x35, 0x9c, 0x9c, 0x66, 0x6f, 0xe8, 0x24, - 0xa5, 0xe4, 0x9f, 0x15, 0x83, 0xa3, 0x74, 0x7f, 0x80, 0x83, 0x20, 0x99, 0x6f, 0xa8, 0x27, 0x4c, - 0x7f, 0x91, 0x4f, 0xd7, 0xa4, 0x3c, 0xa2, 0x0a, 0x86, 0xf3, 0x0b, 0xec, 0xcb, 0xb4, 0x2e, 0xc5, - 0x4f, 0x72, 0x53, 0x7f, 0x57, 0xe9, 0x0f, 0x50, 0x7b, 0x4d, 0xf9, 0x52, 0xb9, 0x93, 0x77, 0x02, - 0x56, 0x84, 0x0b, 0x1d, 0x80, 0x2b, 0xa8, 0xcb, 0xac, 0x45, 0x83, 0x79, 0xce, 0xf1, 0x4d, 0x42, - 0xca, 0xe2, 0xb4, 0x10, 0x1b, 0x99, 0x39, 0x70, 0xa0, 0x0e, 0xc5, 0x38, 0x78, 0x73, 0x72, 0x56, - 0x21, 0x45, 0xad, 0x5f, 0xf5, 0x15, 0x38, 0xf2, 0x43, 0xa8, 0xc9, 0xb9, 0x8c, 0xd5, 0xfb, 0xd6, - 0xc9, 0x9d, 0xae, 0x42, 0x94, 0xd3, 0x49, 0x01, 0x72, 0xf5, 0x2c, 0x8f, 0x1c, 0x03, 0x3f, 0xae, - 0x3d, 0xcb, 0x3e, 0x51, 0x70, 0xe5, 0xe7, 0xb0, 0xaf, 0x42, 0x0b, 0x84, 0x4f, 0xd6, 0x86, 0x9f, - 0x90, 0x7e, 0x5a, 0x04, 0x8d, 0x02, 0x08, 0x6f, 0x8d, 0xc0, 0x25, 0xff, 0xd6, 0xb8, 0xcb, 0xe4, - 0xaf, 0xc3, 0x32, 0x2f, 0xaa, 0x34, 0xc9, 0xf3, 0x6e, 0x76, 0x05, 0xdd, 0xcd, 0xac, 0x79, 0x9b, - 0xdd, 0xa2, 0x78, 0x14, 0xc5, 0xef, 0xb0, 0x13, 0xd6, 0x7f, 0xe9, 0x5b, 0x2a, 0x35, 0x38, 0x2a, - 0x3d, 0x9b, 0x4f, 0x6e, 0xe5, 0x22, 0x75, 0x0a, 0x47, 0xef, 0x5d, 0x43, 0xbe, 0x90, 0xc1, 0x3b, - 0xac, 0x2a, 0x81, 0xf4, 0xaa, 0x2c, 0xab, 0x8d, 0x24, 0x77, 0xc9, 0x67, 0xb7, 0xe5, 0xcc, 0x82, - 0xfb, 0x1a, 0x5a, 0x48, 0x39, 0x0e, 0xdf, 0xfe, 0x78, 0x89, 0x9c, 0xd3, 0x19, 0x8e, 0x85, 0x87, - 0xd4, 0x4e, 0x57, 0x08, 0xc1, 0xff, 0x88, 0x1c, 0xb8, 0xe0, 0x0a, 0xe9, 0x70, 0x14, 0xee, 0xe5, - 0xef, 0xad, 0x05, 0x9f, 0xcb, 0xe2, 0xc8, 0x42, 0x81, 0x46, 0xfa, 0x48, 0xca, 0x9a, 0xb3, 0x9b, - 0x49, 0x16, 0x08, 0x69, 0x02, 0x70, 0x81, 0xe2, 0x12, 0x85, 0x67, 0xea, 0x79, 0x8f, 0xc7, 0x12, - 0xc8, 0x59, 0x96, 0x0c, 0x2e, 0x5a, 0x96, 0x31, 0x54, 0x82, 0x22, 0x97, 0xb4, 0x33, 0x07, 0xa9, - 0x12, 0x7d, 0x5d, 0xd1, 0x14, 0x95, 0xf1, 0xb1, 0x4b, 0xf1, 0x02, 0x45, 0xac, 0x78, 0xce, 0xb9, - 0x14, 0x93, 0xd0, 0xfa, 0x4b, 0x31, 0xcd, 0xc6, 0x22, 0xa8, 0x69, 0x28, 0x3b, 0xc2, 0x38, 0xbe, - 0xce, 0xdb, 0x93, 0xf1, 0x7f, 0x1b, 0xb7, 0xe4, 0xfd, 0xfc, 0xbb, 0x5f, 0x5f, 0xcd, 0x4c, 0x31, - 0x5f, 0x4c, 0x65, 0x4f, 0x2f, 0x40, 0x9f, 0x9b, 0x2c, 0xfc, 0xd5, 0x53, 0x9b, 0xb4, 0xe7, 0x8f, - 0xee, 0x45, 0x1e, 0xee, 0x74, 0x5a, 0xf1, 0x3f, 0xbd, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x05, - 0xc9, 0x1e, 0x16, 0x02, 0x0f, 0x00, 0x00, + // 1295 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xed, 0x72, 0xda, 0x46, + 0x14, 0x35, 0xe0, 0xcf, 0x0b, 0x06, 0x67, 0xc7, 0x8e, 0x29, 0xc9, 0xb4, 0x84, 0xb6, 0x31, 0xce, + 0x07, 0x78, 0xc8, 0x4c, 0x9a, 0xe6, 0x9f, 0x0d, 0xa9, 0xc3, 0xb4, 0x9e, 0x49, 0x44, 0xd2, 0xe9, + 0x57, 0x46, 0x15, 0xd2, 0x0d, 0xd6, 0x58, 0x68, 0xb1, 0x76, 0x89, 0xed, 0x9f, 0x7d, 0x82, 0xbe, + 0x53, 0xfb, 0x00, 0x7d, 0x88, 0xbe, 0x48, 0x67, 0xb5, 0x92, 0x90, 0x84, 0x84, 0xe5, 0xa4, 0xff, + 0xd8, 0xd5, 0xd1, 0x39, 0xf7, 0x9e, 0xbb, 0xba, 0xbb, 0x0b, 0x6c, 0x39, 0x94, 0x72, 0x55, 0xa7, + 0xd4, 0x31, 0x5a, 0x13, 0x87, 0x72, 0x4a, 0x6e, 0x8f, 0x4d, 0xeb, 0xc3, 0x94, 0xc9, 0x51, 0x4b, + 0x3c, 0x76, 0x9f, 0xd6, 0x4a, 0x3a, 0x1d, 0x8f, 0xa9, 0x2d, 0xe7, 0x6b, 0xa5, 0x30, 0xaa, 0x56, + 0x36, 0x6d, 0x8e, 0x8e, 0xad, 0x59, 0xde, 0xb8, 0x38, 0x71, 0xe8, 0xe5, 0x95, 0x37, 0xd8, 0x32, + 0x34, 0xae, 0x85, 0x25, 0x6a, 0x15, 0xe4, 0xba, 0xa1, 0x8e, 0x91, 0x6b, 0x72, 0xa2, 0xa1, 0xc2, + 0xce, 0xa1, 0x65, 0x51, 0xfd, 0x8d, 0x39, 0x46, 0xc6, 0xb5, 0xf1, 0x44, 0xc1, 0xf3, 0x29, 0x32, + 0x4e, 0x0e, 0x60, 0x79, 0xa8, 0x31, 0xac, 0xe6, 0xea, 0xb9, 0x66, 0xb1, 0x73, 0xb7, 0x15, 0x89, + 0xcd, 0x0b, 0xe8, 0x84, 0x8d, 0x8e, 0x34, 0x86, 0x8a, 0x8b, 0x24, 0xdb, 0xb0, 0xa2, 0xd3, 0xa9, + 0xcd, 0xab, 0x85, 0x7a, 0xae, 0xb9, 0xa9, 0xc8, 0x41, 0xe3, 0x8f, 0x1c, 0xdc, 0x8e, 0x2b, 0xb0, + 0x09, 0xb5, 0x19, 0x92, 0x27, 0xb0, 0xca, 0xb8, 0xc6, 0xa7, 0xcc, 0x13, 0xb9, 0x93, 0x28, 0x32, + 0x70, 0x21, 0x8a, 0x07, 0x25, 0x77, 0x61, 0x83, 0xfb, 0x4c, 0xd5, 0x7c, 0x3d, 0xd7, 0x5c, 0x56, + 0x66, 0x13, 0x29, 0x31, 0xfc, 0x04, 0x65, 0x37, 0x84, 0x7e, 0xef, 0x7f, 0xc8, 0x2e, 0x1f, 0x66, + 0xb6, 0xa0, 0x12, 0x30, 0x7f, 0x4a, 0x56, 0x65, 0xc8, 0xf7, 0x7b, 0x2e, 0x75, 0x41, 0xc9, 0xf7, + 0x7b, 0x29, 0x79, 0xfc, 0x95, 0x87, 0x52, 0x7f, 0x3c, 0xa1, 0x0e, 0x57, 0x90, 0x4d, 0x2d, 0xfe, + 0x71, 0x5a, 0xbb, 0xb0, 0xc6, 0x35, 0x76, 0xa6, 0x9a, 0x86, 0x27, 0xb8, 0x2a, 0x86, 0x7d, 0x83, + 0x7c, 0x01, 0x45, 0xb1, 0x60, 0x6c, 0x6a, 0xa0, 0x78, 0x58, 0x70, 0x1f, 0x82, 0x3f, 0xd5, 0x37, + 0xc8, 0x53, 0x58, 0x11, 0x1c, 0x58, 0x5d, 0xae, 0xe7, 0x9a, 0xe5, 0x4e, 0x3d, 0x51, 0x4d, 0x06, + 0x28, 0x34, 0x51, 0x91, 0x70, 0x52, 0x83, 0x75, 0x86, 0xa3, 0x31, 0xda, 0x9c, 0x55, 0x57, 0xea, + 0x85, 0x66, 0x41, 0x09, 0xc6, 0xe4, 0x33, 0x58, 0xd7, 0xa6, 0x9c, 0xaa, 0xa6, 0xc1, 0xaa, 0xab, + 0xee, 0xb3, 0x35, 0x31, 0xee, 0x1b, 0x8c, 0xdc, 0x81, 0x0d, 0x87, 0x5e, 0xa8, 0xd2, 0x88, 0x35, + 0x37, 0x9a, 0x75, 0x87, 0x5e, 0x74, 0xc5, 0x98, 0x7c, 0x03, 0x2b, 0xa6, 0xfd, 0x9e, 0xb2, 0xea, + 0x7a, 0xbd, 0xd0, 0x2c, 0x76, 0xee, 0x25, 0xc6, 0xf2, 0x3d, 0x5e, 0xfd, 0xa8, 0x59, 0x53, 0x7c, + 0xa5, 0x99, 0x8e, 0x22, 0xf1, 0x8d, 0x3f, 0x73, 0xb0, 0xdb, 0x43, 0xa6, 0x3b, 0xe6, 0x10, 0x07, + 0x5e, 0x14, 0x1f, 0xbf, 0x2c, 0x1a, 0x50, 0xd2, 0xa9, 0x65, 0xa1, 0xce, 0x4d, 0x6a, 0x07, 0x25, + 0x8c, 0xcc, 0x91, 0xcf, 0x01, 0xbc, 0x74, 0xfb, 0x3d, 0x56, 0x2d, 0xb8, 0x49, 0x86, 0x66, 0x1a, + 0x53, 0xa8, 0x78, 0x81, 0x08, 0xe2, 0xbe, 0xfd, 0x9e, 0xce, 0xd1, 0xe6, 0x12, 0x68, 0xeb, 0x50, + 0x9c, 0x68, 0x0e, 0x37, 0x23, 0xca, 0xe1, 0x29, 0xf1, 0xad, 0x04, 0x32, 0x5e, 0x39, 0x67, 0x13, + 0x8d, 0x7f, 0xf3, 0x50, 0xf2, 0x74, 0x85, 0x26, 0x23, 0x3d, 0xd8, 0x10, 0x39, 0xa9, 0xc2, 0x27, + 0xcf, 0x82, 0xbd, 0x56, 0x72, 0x4f, 0x6a, 0xc5, 0x02, 0x56, 0xd6, 0x87, 0x7e, 0xe8, 0x3d, 0x28, + 0x9a, 0xb6, 0x81, 0x97, 0xaa, 0x2c, 0x4f, 0xde, 0x2d, 0xcf, 0x97, 0x51, 0x1e, 0xd1, 0x85, 0x5a, + 0x81, 0xb6, 0x81, 0x97, 0x2e, 0x07, 0x98, 0xfe, 0x4f, 0x46, 0x10, 0x6e, 0xe1, 0x25, 0x77, 0x34, + 0x35, 0xcc, 0x55, 0x70, 0xb9, 0xbe, 0xbd, 0x26, 0x26, 0x97, 0xa0, 0xf5, 0x42, 0xbc, 0x1d, 0x70, + 0xb3, 0x17, 0x36, 0x77, 0xae, 0x94, 0x0a, 0x46, 0x67, 0x6b, 0xbf, 0xc3, 0x76, 0x12, 0x90, 0x6c, + 0x41, 0xe1, 0x0c, 0xaf, 0x3c, 0xdb, 0xc5, 0x4f, 0xd2, 0x81, 0x95, 0x0f, 0x62, 0x29, 0xb9, 0x3e, + 0xcf, 0xad, 0x0d, 0x37, 0xa1, 0x59, 0x26, 0x12, 0xfa, 0x3c, 0xff, 0x2c, 0xd7, 0xf8, 0x3b, 0x0f, + 0xd5, 0xf9, 0xe5, 0xf6, 0x29, 0xbd, 0x22, 0xcb, 0x92, 0x1b, 0xc1, 0xa6, 0x57, 0xe8, 0x88, 0x75, + 0x47, 0x69, 0xd6, 0xa5, 0x45, 0x18, 0xf1, 0x54, 0x7a, 0x58, 0x62, 0xa1, 0xa9, 0x1a, 0xc2, 0xad, + 0x39, 0x48, 0x82, 0x7b, 0xcf, 0xa3, 0xee, 0x7d, 0x95, 0xa5, 0x84, 0x21, 0x17, 0x3b, 0xff, 0xec, + 0xc2, 0x86, 0x42, 0x29, 0xef, 0x0a, 0x14, 0x99, 0x00, 0x39, 0x46, 0xde, 0xa5, 0xe3, 0x09, 0xb5, + 0xd1, 0x96, 0xbd, 0x86, 0x91, 0x83, 0x28, 0x69, 0xb0, 0x31, 0xce, 0x43, 0xbd, 0xcf, 0xbd, 0x76, + 0x3f, 0xe5, 0x8d, 0x18, 0xbc, 0xb1, 0x44, 0xc6, 0xae, 0xa2, 0xd8, 0xc2, 0xde, 0x98, 0xfa, 0x59, + 0xf7, 0x54, 0xb3, 0x6d, 0xb4, 0x16, 0x29, 0xc6, 0xa0, 0xbe, 0x62, 0xec, 0x3b, 0xf0, 0x06, 0x03, + 0xee, 0x98, 0xf6, 0xc8, 0xf7, 0xbc, 0xb1, 0x44, 0xce, 0x61, 0xfb, 0x18, 0x5d, 0x75, 0x93, 0x71, + 0x53, 0x67, 0xbe, 0x60, 0x27, 0x5d, 0x70, 0x0e, 0x7c, 0x43, 0x49, 0x15, 0xb6, 0xba, 0x0e, 0x6a, + 0x1c, 0xbb, 0xc1, 0x3a, 0x22, 0x8f, 0x12, 0x5f, 0x8d, 0xc3, 0x7c, 0xa1, 0x45, 0x8b, 0xb7, 0xb1, + 0x44, 0x7e, 0x85, 0x72, 0xcf, 0xa1, 0x93, 0x10, 0xfd, 0x83, 0x44, 0xfa, 0x28, 0x28, 0x23, 0xb9, + 0x0a, 0x9b, 0x2f, 0x35, 0x16, 0xe2, 0xde, 0x4f, 0xe4, 0x8e, 0x60, 0x7c, 0xea, 0x7b, 0x89, 0xd0, + 0x23, 0x4a, 0xad, 0x90, 0x3d, 0x17, 0x40, 0xfc, 0x6f, 0x24, 0xa4, 0xd2, 0x4a, 0xce, 0x60, 0x0e, + 0xe8, 0x4b, 0xb5, 0x33, 0xe3, 0x03, 0xe1, 0xb7, 0x50, 0x94, 0x86, 0x1f, 0x5a, 0xa6, 0xc6, 0xc8, + 0xde, 0x82, 0x92, 0xb8, 0x88, 0x8c, 0x86, 0xbd, 0x86, 0x0d, 0x61, 0xb4, 0x24, 0xfd, 0x3a, 0xb5, + 0x10, 0x37, 0xa1, 0x1c, 0x00, 0x1c, 0x5a, 0x1c, 0x1d, 0xc9, 0x79, 0x3f, 0x91, 0x73, 0x06, 0xc8, + 0x48, 0x6a, 0x43, 0x65, 0x70, 0x2a, 0xf6, 0x7c, 0xdf, 0x1a, 0x46, 0x1e, 0x26, 0x2f, 0xe8, 0x28, + 0xca, 0xa7, 0x7f, 0x94, 0x0d, 0x1c, 0xd8, 0xfd, 0x0e, 0x2a, 0xd2, 0xcc, 0x57, 0xfe, 0x3e, 0x9a, + 0xa2, 0x17, 0x43, 0x65, 0x4c, 0xe7, 0x67, 0xd8, 0x14, 0xb6, 0xce, 0xc8, 0xf7, 0x53, 0xad, 0xbf, + 0x29, 0xf5, 0x3b, 0x28, 0xbd, 0xd4, 0xd8, 0x8c, 0xb9, 0x99, 0xf6, 0x05, 0xcc, 0x11, 0x67, 0xfa, + 0x00, 0xce, 0xa0, 0x2c, 0x5c, 0x0b, 0x5e, 0x66, 0x29, 0x9f, 0x6f, 0x14, 0xe4, 0x4b, 0x3c, 0xcc, + 0x84, 0x0d, 0xc4, 0x6c, 0xa8, 0xc4, 0x76, 0xa4, 0x94, 0x2a, 0xc4, 0x50, 0x8b, 0xab, 0x3e, 0x07, + 0x0e, 0xf4, 0x10, 0x4a, 0x22, 0x16, 0x7f, 0xf7, 0x4b, 0xf1, 0x2e, 0x0c, 0xf1, 0x95, 0xf6, 0x33, + 0x20, 0x43, 0x4d, 0x64, 0x2b, 0xbe, 0xd1, 0x92, 0x76, 0xf6, 0x2d, 0x59, 0x2a, 0x1e, 0xdc, 0x74, + 0x0f, 0x0f, 0x37, 0x11, 0xf7, 0x88, 0xb2, 0xb0, 0x89, 0xb8, 0x88, 0x8c, 0x4b, 0xee, 0x14, 0x36, + 0x7d, 0x51, 0x49, 0xbc, 0xbf, 0xd0, 0xf7, 0x08, 0xf5, 0x83, 0x2c, 0xd0, 0x20, 0x01, 0xaf, 0x5d, + 0x49, 0x95, 0xf4, 0x76, 0x75, 0x93, 0xe0, 0xcf, 0xbd, 0x4b, 0x61, 0x70, 0x2f, 0x25, 0x8f, 0xd3, + 0x9c, 0x4d, 0xbc, 0x21, 0xd7, 0x5a, 0x59, 0xe1, 0x41, 0x16, 0xbf, 0xc1, 0x9a, 0x77, 0x5b, 0x8c, + 0xb7, 0xc7, 0xd8, 0xcb, 0xc1, 0x45, 0xb5, 0xb6, 0x77, 0x2d, 0x2e, 0x60, 0xd7, 0x60, 0xe7, 0xed, + 0xc4, 0x10, 0x5b, 0xb3, 0x3c, 0x00, 0xf8, 0x47, 0x90, 0x78, 0x55, 0x66, 0xc7, 0x9c, 0x28, 0xee, + 0x84, 0x8d, 0xae, 0xf3, 0xcc, 0x82, 0x5d, 0x05, 0x2d, 0xd4, 0x18, 0xf6, 0x5e, 0xff, 0x70, 0x82, + 0x8c, 0x69, 0x23, 0x1c, 0x70, 0x07, 0xb5, 0x71, 0xfc, 0x68, 0x22, 0xff, 0x86, 0x48, 0x01, 0x67, + 0xac, 0x90, 0x0e, 0x3b, 0xde, 0x5a, 0xfe, 0xce, 0x9a, 0xb2, 0x53, 0x71, 0x2a, 0xb3, 0x90, 0xa3, + 0x11, 0xef, 0x05, 0xe2, 0x86, 0xda, 0x4a, 0x44, 0x66, 0x48, 0x49, 0x05, 0x38, 0x46, 0x7e, 0x82, + 0xdc, 0x31, 0xf5, 0xb4, 0x5d, 0x6b, 0x06, 0x48, 0x29, 0x4b, 0x02, 0x2e, 0x28, 0xcb, 0x00, 0x56, + 0xe5, 0x95, 0x98, 0x34, 0x12, 0x5f, 0xf2, 0x2f, 0xf4, 0x8b, 0x4e, 0x6b, 0xc1, 0xa5, 0x3f, 0xd4, + 0x8d, 0x8f, 0x91, 0x87, 0xae, 0xda, 0x29, 0xdd, 0x38, 0x0a, 0x5a, 0xdc, 0x8d, 0xe3, 0xd8, 0x50, + 0x06, 0x25, 0x05, 0xc5, 0x03, 0x2f, 0x8f, 0xd4, 0xd3, 0x7b, 0xf8, 0xbf, 0x89, 0x6b, 0x7c, 0x3f, + 0x7a, 0xf6, 0xcb, 0xd3, 0x91, 0xc9, 0x4f, 0xa7, 0x43, 0xf1, 0xa4, 0x2d, 0xa1, 0x8f, 0x4d, 0xea, + 0xfd, 0x6a, 0xfb, 0x8b, 0xb4, 0xed, 0xbe, 0xdd, 0x0e, 0x34, 0x26, 0xc3, 0xe1, 0xaa, 0x3b, 0xf5, + 0xe4, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4f, 0x2c, 0xbd, 0x42, 0x41, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -482,6 +725,7 @@ type RootCoordClient interface { ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionsRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionsResponse, error) DescribeSegment(ctx context.Context, in *milvuspb.DescribeSegmentRequest, opts ...grpc.CallOption) (*milvuspb.DescribeSegmentResponse, error) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequest, opts ...grpc.CallOption) (*milvuspb.ShowSegmentsResponse, error) + DescribeSegments(ctx context.Context, in *DescribeSegmentsRequest, opts ...grpc.CallOption) (*DescribeSegmentsResponse, error) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRequest, opts ...grpc.CallOption) (*milvuspb.DescribeIndexResponse, error) DropIndex(ctx context.Context, in *milvuspb.DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) @@ -659,6 +903,15 @@ func (c *rootCoordClient) ShowSegments(ctx context.Context, in *milvuspb.ShowSeg return out, nil } +func (c *rootCoordClient) DescribeSegments(ctx context.Context, in *DescribeSegmentsRequest, opts ...grpc.CallOption) (*DescribeSegmentsResponse, error) { + out := new(DescribeSegmentsResponse) + err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/DescribeSegments", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *rootCoordClient) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { out := new(commonpb.Status) err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/CreateIndex", in, out, opts...) @@ -832,6 +1085,7 @@ type RootCoordServer interface { ShowPartitions(context.Context, *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) DescribeSegment(context.Context, *milvuspb.DescribeSegmentRequest) (*milvuspb.DescribeSegmentResponse, error) ShowSegments(context.Context, *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) + DescribeSegments(context.Context, *DescribeSegmentsRequest) (*DescribeSegmentsResponse, error) CreateIndex(context.Context, *milvuspb.CreateIndexRequest) (*commonpb.Status, error) DescribeIndex(context.Context, *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error) DropIndex(context.Context, *milvuspb.DropIndexRequest) (*commonpb.Status, error) @@ -903,6 +1157,9 @@ func (*UnimplementedRootCoordServer) DescribeSegment(ctx context.Context, req *m func (*UnimplementedRootCoordServer) ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ShowSegments not implemented") } +func (*UnimplementedRootCoordServer) DescribeSegments(ctx context.Context, req *DescribeSegmentsRequest) (*DescribeSegmentsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DescribeSegments not implemented") +} func (*UnimplementedRootCoordServer) CreateIndex(ctx context.Context, req *milvuspb.CreateIndexRequest) (*commonpb.Status, error) { return nil, status.Errorf(codes.Unimplemented, "method CreateIndex not implemented") } @@ -1250,6 +1507,24 @@ func _RootCoord_ShowSegments_Handler(srv interface{}, ctx context.Context, dec f return interceptor(ctx, in, info, handler) } +func _RootCoord_DescribeSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DescribeSegmentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RootCoordServer).DescribeSegments(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/milvus.proto.rootcoord.RootCoord/DescribeSegments", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RootCoordServer).DescribeSegments(ctx, req.(*DescribeSegmentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _RootCoord_CreateIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(milvuspb.CreateIndexRequest) if err := dec(in); err != nil { @@ -1538,6 +1813,10 @@ var _RootCoord_serviceDesc = grpc.ServiceDesc{ MethodName: "ShowSegments", Handler: _RootCoord_ShowSegments_Handler, }, + { + MethodName: "DescribeSegments", + Handler: _RootCoord_DescribeSegments_Handler, + }, { MethodName: "CreateIndex", Handler: _RootCoord_CreateIndex_Handler, diff --git a/internal/proxy/rootcoord_mock_test.go b/internal/proxy/rootcoord_mock_test.go index a722b2088d..e08c7cbfe6 100644 --- a/internal/proxy/rootcoord_mock_test.go +++ b/internal/proxy/rootcoord_mock_test.go @@ -874,6 +874,10 @@ func (coord *RootCoordMock) ShowSegments(ctx context.Context, req *milvuspb.Show }, nil } +func (coord *RootCoordMock) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + panic("implement me") +} + func (coord *RootCoordMock) ReleaseDQLMessageStream(ctx context.Context, in *proxypb.ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) { code := coord.state.Load().(internalpb.StateCode) if code != internalpb.StateCode_Healthy { diff --git a/internal/querycoord/global_meta_broker.go b/internal/querycoord/global_meta_broker.go index a8fb864593..696665395b 100644 --- a/internal/querycoord/global_meta_broker.go +++ b/internal/querycoord/global_meta_broker.go @@ -6,6 +6,8 @@ import ( "fmt" "path" + "github.com/milvus-io/milvus/internal/proto/rootcoordpb" + "go.uber.org/zap" "github.com/milvus-io/milvus/internal/log" @@ -191,7 +193,7 @@ func (broker *globalMetaBroker) getIndexFilePaths(ctx context.Context, buildID i return pathResponse.FilePaths, nil } -func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID UniqueID, indexInfo *querypb.VecFieldIndexInfo) error { +func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID UniqueID, indexInfo *querypb.FieldIndexInfo) error { if !indexInfo.EnableIndex { log.Debug(fmt.Sprintf("fieldID %d of segment %d don't has index", indexInfo.FieldID, segmentID)) return nil @@ -267,41 +269,148 @@ func (broker *globalMetaBroker) parseIndexInfo(ctx context.Context, segmentID Un return nil } -func (broker *globalMetaBroker) getIndexInfo(ctx context.Context, collectionID UniqueID, segmentID UniqueID, schema *schemapb.CollectionSchema) ([]*querypb.VecFieldIndexInfo, error) { - // TODO:: collection has multi vec field, and build index for every vec field, get indexInfo by fieldID - // Currently, each collection can only have one vector field - vecFieldIDs := funcutil.GetVecFieldIDs(schema) - if len(vecFieldIDs) != 1 { - err := fmt.Errorf("collection %d has multi vec field, num of vec fields = %d", collectionID, len(vecFieldIDs)) - log.Error("get index info failed", - zap.Int64("collectionID", collectionID), - zap.Int64("segmentID", segmentID), +// Better to let index params key appear in the file paths first. +func (broker *globalMetaBroker) loadIndexExtraInfo(ctx context.Context, fieldPathInfo *indexpb.IndexFilePathInfo) (*extraIndexInfo, error) { + indexCodec := storage.NewIndexFileBinlogCodec() + for _, indexFilePath := range fieldPathInfo.IndexFilePaths { + // get index params when detecting indexParamPrefix + if path.Base(indexFilePath) == storage.IndexParamsKey { + content, err := broker.cm.MultiRead([]string{indexFilePath}) + if err != nil { + return nil, err + } + + if len(content) <= 0 { + return nil, fmt.Errorf("failed to read index file binlog, path: %s", indexFilePath) + } + + indexPiece := content[0] + _, indexParams, indexName, _, err := indexCodec.Deserialize([]*storage.Blob{{Key: storage.IndexParamsKey, Value: indexPiece}}) + if err != nil { + return nil, err + } + + return &extraIndexInfo{ + indexName: indexName, + indexParams: funcutil.Map2KeyValuePair(indexParams), + }, nil + } + } + return nil, errors.New("failed to load index extra info") +} + +func (broker *globalMetaBroker) describeSegments(ctx context.Context, collectionID UniqueID, segmentIDs []UniqueID) (*rootcoordpb.DescribeSegmentsResponse, error) { + resp, err := broker.rootCoord.DescribeSegments(ctx, &rootcoordpb.DescribeSegmentsRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DescribeSegments, + }, + CollectionID: collectionID, + SegmentIDs: segmentIDs, + }) + if err != nil { + log.Error("failed to describe segments", + zap.Int64("collection", collectionID), + zap.Int64s("segments", segmentIDs), zap.Error(err)) return nil, err } - indexInfo := &querypb.VecFieldIndexInfo{ - FieldID: vecFieldIDs[0], - } - // check the buildID of the segment's index whether exist on rootCoord - enableIndex, buildID, err := broker.getIndexBuildID(ctx, collectionID, segmentID) + + log.Debug("describe segments successfully", + zap.Int64("collection", collectionID), + zap.Int64s("segments", segmentIDs)) + + return resp, nil +} + +// return: segment_id -> segment_index_infos +func (broker *globalMetaBroker) getFullIndexInfos(ctx context.Context, collectionID UniqueID, segmentIDs []UniqueID) (map[UniqueID][]*querypb.FieldIndexInfo, error) { + resp, err := broker.describeSegments(ctx, collectionID, segmentIDs) if err != nil { return nil, err } - // if the segment.EnableIndex == false, then load the segment immediately - if !enableIndex { - indexInfo.EnableIndex = false - } else { - indexInfo.BuildID = buildID - indexInfo.EnableIndex = true - err = broker.parseIndexInfo(ctx, segmentID, indexInfo) - if err != nil { - return nil, err + ret := make(map[UniqueID][]*querypb.FieldIndexInfo) + for _, segmentID := range segmentIDs { + infos, ok := resp.GetSegmentInfos()[segmentID] + if !ok { + log.Warn("segment not found", + zap.Int64("collection", collectionID), + zap.Int64("segment", segmentID)) + return nil, fmt.Errorf("segment not found, collection: %d, segment: %d", collectionID, segmentID) + } + + if _, ok := ret[segmentID]; !ok { + ret[segmentID] = make([]*querypb.FieldIndexInfo, 0, len(infos.IndexInfos)) + } + + for _, info := range infos.IndexInfos { + extraInfo, ok := infos.GetExtraIndexInfos()[info.IndexID] + indexInfo := &querypb.FieldIndexInfo{ + FieldID: info.FieldID, + EnableIndex: info.EnableIndex, + IndexName: "", + IndexID: info.IndexID, + BuildID: info.BuildID, + IndexParams: nil, + IndexFilePaths: nil, + IndexSize: 0, + } + + if !info.EnableIndex { + ret[segmentID] = append(ret[segmentID], indexInfo) + continue + } + + paths, err := broker.getIndexFilePaths(ctx, info.BuildID) + if err != nil { + log.Error("failed to get index file paths", + zap.Int64("collection", collectionID), + zap.Int64("segment", segmentID), + zap.Int64("buildID", info.BuildID), + zap.Error(err)) + return nil, err + } + + if len(paths) <= 0 || len(paths[0].IndexFilePaths) <= 0 { + log.Warn("index not ready", zap.Int64("index_build_id", info.BuildID)) + return nil, fmt.Errorf("index not ready, index build id: %d", info.BuildID) + } + + indexInfo.IndexFilePaths = paths[0].IndexFilePaths + indexInfo.IndexSize = int64(paths[0].SerializedSize) + + if ok { + indexInfo.IndexName = extraInfo.IndexName + indexInfo.IndexParams = extraInfo.IndexParams + } else { + // get index name, index params from binlog. + extra, err := broker.loadIndexExtraInfo(ctx, paths[0]) + if err != nil { + log.Error("failed to load index extra info", + zap.Int64("index build id", info.BuildID), + zap.Error(err)) + return nil, err + } + indexInfo.IndexName = extra.indexName + indexInfo.IndexParams = extra.indexParams + } + + ret[segmentID] = append(ret[segmentID], indexInfo) } } - log.Debug("get index info success", zap.Int64("collectionID", collectionID), zap.Int64("segmentID", segmentID), zap.Bool("enableIndex", enableIndex)) - return []*querypb.VecFieldIndexInfo{indexInfo}, nil + return ret, nil +} + +func (broker *globalMetaBroker) getIndexInfo(ctx context.Context, collectionID UniqueID, segmentID UniqueID, schema *schemapb.CollectionSchema) ([]*querypb.FieldIndexInfo, error) { + segmentIndexInfos, err := broker.getFullIndexInfos(ctx, collectionID, []UniqueID{segmentID}) + if err != nil { + return nil, err + } + if infos, ok := segmentIndexInfos[segmentID]; ok { + return infos, nil + } + return nil, fmt.Errorf("failed to get segment index infos, collection: %d, segment: %d", collectionID, segmentID) } func (broker *globalMetaBroker) generateSegmentLoadInfo(ctx context.Context, diff --git a/internal/querycoord/index_checker.go b/internal/querycoord/index_checker.go index 92022d9a99..1e526d5873 100644 --- a/internal/querycoord/index_checker.go +++ b/internal/querycoord/index_checker.go @@ -30,6 +30,14 @@ import ( "github.com/milvus-io/milvus/internal/proto/querypb" ) +type extraIndexInfo struct { + indexID UniqueID + indexName string + indexParams []*commonpb.KeyValuePair + indexSize uint64 + indexFilePaths []string +} + // IndexChecker checks index type IndexChecker struct { ctx context.Context diff --git a/internal/querycoord/mock_3rd_component_test.go b/internal/querycoord/mock_3rd_component_test.go index 6d664984d3..57b76d099c 100644 --- a/internal/querycoord/mock_3rd_component_test.go +++ b/internal/querycoord/mock_3rd_component_test.go @@ -22,6 +22,10 @@ import ( "fmt" "sync" + "github.com/milvus-io/milvus/internal/proto/etcdpb" + + "github.com/milvus-io/milvus/internal/proto/rootcoordpb" + "github.com/milvus-io/milvus/internal/common" "github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/datapb" @@ -256,6 +260,43 @@ func (rc *rootCoordMock) DescribeSegment(ctx context.Context, req *milvuspb.Desc }, nil } +func (rc *rootCoordMock) DescribeSegments(ctx context.Context, req *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + if rc.returnGrpcError { + return nil, errors.New("describe segment failed") + } + + if rc.returnError { + return &rootcoordpb.DescribeSegmentsResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_UnexpectedError, + Reason: "describe segments failed", + }, + }, nil + } + + ret := &rootcoordpb.DescribeSegmentsResponse{ + Status: &commonpb.Status{ + ErrorCode: commonpb.ErrorCode_Success, + }, + CollectionID: req.GetCollectionID(), + SegmentInfos: make(map[int64]*rootcoordpb.SegmentInfos), + } + + for _, segID := range req.GetSegmentIDs() { + ret.SegmentInfos[segID] = &rootcoordpb.SegmentInfos{ + IndexInfos: []*etcdpb.SegmentIndexInfo{ + { + SegmentID: segID, + EnableIndex: rc.enableIndex, + }, + }, + ExtraIndexInfos: nil, + } + } + + return ret, nil +} + type dataCoordMock struct { types.DataCoord collections []UniqueID diff --git a/internal/querycoord/util.go b/internal/querycoord/util.go index 38b58e5c24..0de55a0da1 100644 --- a/internal/querycoord/util.go +++ b/internal/querycoord/util.go @@ -34,7 +34,7 @@ func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} { func estimateSegmentSize(segmentLoadInfo *querypb.SegmentLoadInfo) int64 { segmentSize := int64(0) - vecFieldID2IndexInfo := make(map[int64]*querypb.VecFieldIndexInfo) + vecFieldID2IndexInfo := make(map[int64]*querypb.FieldIndexInfo) for _, fieldIndexInfo := range segmentLoadInfo.IndexInfos { if fieldIndexInfo.EnableIndex { fieldID := fieldIndexInfo.FieldID diff --git a/internal/querynode/collection_replica.go b/internal/querynode/collection_replica.go index c4be487c43..65b215c7db 100644 --- a/internal/querynode/collection_replica.go +++ b/internal/querynode/collection_replica.go @@ -296,6 +296,21 @@ func (colReplica *collectionReplica) getPartitionIDs(collectionID UniqueID) ([]U return collection.partitionIDs, nil } +func (colReplica *collectionReplica) getIndexedFieldIDByCollectionIDPrivate(collectionID UniqueID, segment *Segment) ([]FieldID, error) { + fields, err := colReplica.getFieldsByCollectionIDPrivate(collectionID) + if err != nil { + return nil, err + } + + fieldIDS := make([]FieldID, 0) + for _, field := range fields { + if segment.hasLoadIndexForIndexedField(field.FieldID) { + fieldIDS = append(fieldIDS, field.FieldID) + } + } + return fieldIDS, nil +} + func (colReplica *collectionReplica) getVecFieldIDsByCollectionIDPrivate(collectionID UniqueID) ([]FieldID, error) { fields, err := colReplica.getFieldsByCollectionIDPrivate(collectionID) if err != nil { @@ -720,16 +735,15 @@ func newCollectionReplica(etcdKv *etcdkv.EtcdKV) ReplicaInterface { func (colReplica *collectionReplica) getSegmentInfo(segment *Segment) *querypb.SegmentInfo { var indexName string var indexID int64 + var indexInfos []*querypb.FieldIndexInfo // TODO:: segment has multi vec column - vecFieldIDs, _ := colReplica.getVecFieldIDsByCollectionIDPrivate(segment.collectionID) - for _, fieldID := range vecFieldIDs { - if segment.hasLoadIndexForVecField(fieldID) { - fieldInfo, err := segment.getVectorFieldInfo(fieldID) - if err == nil { - indexName = fieldInfo.indexInfo.IndexName - indexID = fieldInfo.indexInfo.IndexID - break - } + indexedFieldIDs, _ := colReplica.getIndexedFieldIDByCollectionIDPrivate(segment.collectionID, segment) + for _, fieldID := range indexedFieldIDs { + fieldInfo, err := segment.getIndexedFieldInfo(fieldID) + if err == nil { + indexName = fieldInfo.indexInfo.IndexName + indexID = fieldInfo.indexInfo.IndexID + indexInfos = append(indexInfos, fieldInfo.indexInfo) } } info := &querypb.SegmentInfo{ @@ -743,6 +757,7 @@ func (colReplica *collectionReplica) getSegmentInfo(segment *Segment) *querypb.S IndexID: indexID, DmChannel: segment.vChannelID, SegmentState: segment.segmentType, + IndexInfos: indexInfos, } return info } diff --git a/internal/querynode/collection_replica_test.go b/internal/querynode/collection_replica_test.go index 5261855044..1af630a906 100644 --- a/internal/querynode/collection_replica_test.go +++ b/internal/querynode/collection_replica_test.go @@ -244,8 +244,8 @@ func TestCollectionReplica_getSegmentInfosByColID(t *testing.T) { fieldID := vectorFieldIDDs[0] indexID := UniqueID(10000) - indexInfo := &VectorFieldInfo{ - indexInfo: &querypb.VecFieldIndexInfo{ + indexInfo := &IndexedFieldInfo{ + indexInfo: &querypb.FieldIndexInfo{ IndexName: "test-index-name", IndexID: indexID, EnableIndex: true, @@ -259,7 +259,7 @@ func TestCollectionReplica_getSegmentInfosByColID(t *testing.T) { segment2, err := newSegment(collection, UniqueID(2), defaultPartitionID, collectionID, "", segmentTypeSealed, true) assert.NoError(t, err) - segment2.setVectorFieldInfo(fieldID, indexInfo) + segment2.setIndexedFieldInfo(fieldID, indexInfo) err = node.historical.replica.setSegment(segment2) assert.NoError(t, err) diff --git a/internal/querynode/historical.go b/internal/querynode/historical.go index f4f3f41ded..e6f950b841 100644 --- a/internal/querynode/historical.go +++ b/internal/querynode/historical.go @@ -84,7 +84,7 @@ func (h *historical) retrieve(collID UniqueID, partIDs []UniqueID, vcm storage.C return retrieveResults, retrieveSegmentIDs, retrievePartIDs, err } - if err = seg.fillVectorFieldsData(collID, vcm, result); err != nil { + if err = seg.fillIndexedFieldsData(collID, vcm, result); err != nil { return retrieveResults, retrieveSegmentIDs, retrievePartIDs, err } retrieveResults = append(retrieveResults, result) diff --git a/internal/querynode/impl_test.go b/internal/querynode/impl_test.go index 9e1ed168af..23c84dfecb 100644 --- a/internal/querynode/impl_test.go +++ b/internal/querynode/impl_test.go @@ -341,8 +341,8 @@ func TestImpl_GetSegmentInfo(t *testing.T) { seg, err := node.historical.replica.getSegmentByID(defaultSegmentID) assert.NoError(t, err) - seg.setVectorFieldInfo(simpleVecField.id, &VectorFieldInfo{ - indexInfo: &queryPb.VecFieldIndexInfo{ + seg.setIndexedFieldInfo(simpleVecField.id, &IndexedFieldInfo{ + indexInfo: &queryPb.FieldIndexInfo{ IndexName: "query-node-test", IndexID: UniqueID(0), BuildID: UniqueID(0), diff --git a/internal/querynode/load_index_info.go b/internal/querynode/load_index_info.go index 411587b51a..a397581440 100644 --- a/internal/querynode/load_index_info.go +++ b/internal/querynode/load_index_info.go @@ -59,7 +59,7 @@ func deleteLoadIndexInfo(info *LoadIndexInfo) { C.DeleteLoadIndexInfo(info.cLoadIndexInfo) } -func (li *LoadIndexInfo) appendIndexInfo(bytesIndex [][]byte, indexInfo *querypb.VecFieldIndexInfo) error { +func (li *LoadIndexInfo) appendIndexInfo(bytesIndex [][]byte, indexInfo *querypb.FieldIndexInfo) error { fieldID := indexInfo.FieldID indexParams := funcutil.KeyValuePair2Map(indexInfo.IndexParams) indexPaths := indexInfo.IndexFilePaths diff --git a/internal/querynode/load_index_info_test.go b/internal/querynode/load_index_info_test.go index fd03aa3d88..12de3e11c2 100644 --- a/internal/querynode/load_index_info_test.go +++ b/internal/querynode/load_index_info_test.go @@ -44,7 +44,7 @@ func TestLoadIndexInfo(t *testing.T) { loadIndexInfo, err := newLoadIndexInfo() assert.Nil(t, err) - indexInfo := &querypb.VecFieldIndexInfo{ + indexInfo := &querypb.FieldIndexInfo{ FieldID: UniqueID(0), IndexParams: indexParams, IndexFilePaths: indexPaths, diff --git a/internal/querynode/mock_test.go b/internal/querynode/mock_test.go index 5c4c45ea13..aa9fc34eee 100644 --- a/internal/querynode/mock_test.go +++ b/internal/querynode/mock_test.go @@ -283,7 +283,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI return err } _, indexParams := genIndexParams(indexType, metricType) - indexInfo := &querypb.VecFieldIndexInfo{ + indexInfo := &querypb.FieldIndexInfo{ FieldID: simpleVecField.id, EnableIndex: true, IndexName: indexName, @@ -307,7 +307,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI PartitionID: defaultPartitionID, CollectionID: defaultCollectionID, BinlogPaths: fieldBinlog, - IndexInfos: []*querypb.VecFieldIndexInfo{indexInfo}, + IndexInfos: []*querypb.FieldIndexInfo{indexInfo}, }, }, } @@ -321,7 +321,7 @@ func loadIndexForSegment(ctx context.Context, node *QueryNode, segmentID UniqueI if err != nil { return err } - vecFieldInfo, err := segment.getVectorFieldInfo(simpleVecField.id) + vecFieldInfo, err := segment.getIndexedFieldInfo(simpleVecField.id) if err != nil { return err } @@ -355,6 +355,11 @@ func generateIndex(segmentID UniqueID) ([]string, error) { if err != nil { return nil, err } + defer func() { + if err := index.Delete(); err != nil { + panic(err) + } + }() err = index.Build(indexcgowrapper.GenFloatVecDataset(indexRowData)) if err != nil { @@ -1846,3 +1851,136 @@ func (mm *mockMsgStreamFactory) NewTtMsgStream(ctx context.Context) (msgstream.M func (mm *mockMsgStreamFactory) NewQueryMsgStream(ctx context.Context) (msgstream.MsgStream, error) { return nil, nil } + +type readAtFunc func(path string, offset int64, length int64) ([]byte, error) +type readFunc func(path string) ([]byte, error) + +type mockChunkManager struct { + storage.ChunkManager + readAt readAtFunc + read readFunc +} + +type mockChunkManagerOpt func(*mockChunkManager) + +func defaultReadAt(path string, offset int64, length int64) ([]byte, error) { + return funcutil.RandomBytes(int(length)), nil +} + +func defaultRead(path string) ([]byte, error) { + return []byte(path), nil +} + +func readBool(maxOffset int64) ([]byte, error) { + var arr schemapb.BoolArray + for i := int64(0); i <= maxOffset; i++ { + arr.Data = append(arr.Data, i%2 == 0) + } + return proto.Marshal(&arr) +} + +func readIllegalBool() ([]byte, error) { + return []byte("can convert to bool array"), nil +} + +func readString(maxOffset int64) ([]byte, error) { + var arr schemapb.StringArray + for i := int64(0); i <= maxOffset; i++ { + arr.Data = append(arr.Data, funcutil.GenRandomStr()) + } + return proto.Marshal(&arr) +} + +func readIllegalString() ([]byte, error) { + return []byte("can convert to string array"), nil +} + +func readAtEmptyContent() ([]byte, error) { + return []byte{}, nil +} + +func withReadAt(f readAtFunc) mockChunkManagerOpt { + return func(manager *mockChunkManager) { + manager.readAt = f + } +} + +func withRead(f readFunc) mockChunkManagerOpt { + return func(manager *mockChunkManager) { + manager.read = f + } +} + +func withDefaultReadAt() mockChunkManagerOpt { + return withReadAt(defaultReadAt) +} + +func withDefaultRead() mockChunkManagerOpt { + return withRead(defaultRead) +} + +func withReadErr() mockChunkManagerOpt { + return withRead(func(path string) ([]byte, error) { + return nil, errors.New("mock") + }) +} + +func withReadAtErr() mockChunkManagerOpt { + return withReadAt(func(path string, offset int64, length int64) ([]byte, error) { + return nil, errors.New("mock") + }) +} + +func withReadBool(maxOffset int64) mockChunkManagerOpt { + return withRead(func(path string) ([]byte, error) { + return readBool(maxOffset) + }) +} + +func withReadIllegalBool() mockChunkManagerOpt { + return withRead(func(path string) ([]byte, error) { + return readIllegalBool() + }) +} + +func withReadString(maxOffset int64) mockChunkManagerOpt { + return withRead(func(path string) ([]byte, error) { + return readString(maxOffset) + }) +} + +func withReadIllegalString() mockChunkManagerOpt { + return withRead(func(path string) ([]byte, error) { + return readIllegalString() + }) +} + +func withReadAtEmptyContent() mockChunkManagerOpt { + return withReadAt(func(path string, offset int64, length int64) ([]byte, error) { + return readAtEmptyContent() + }) +} + +func newMockChunkManager(opts ...mockChunkManagerOpt) storage.ChunkManager { + ret := &mockChunkManager{} + for _, opt := range opts { + if opt != nil { + opt(ret) + } + } + return ret +} + +func (m *mockChunkManager) ReadAt(path string, offset int64, length int64) ([]byte, error) { + if m.readAt != nil { + return m.readAt(path, offset, length) + } + return defaultReadAt(path, offset, length) +} + +func (m *mockChunkManager) Read(path string) ([]byte, error) { + if m.read != nil { + return m.read(path) + } + return defaultRead(path) +} diff --git a/internal/querynode/segment.go b/internal/querynode/segment.go index 5ea68e7ae7..1400dd61ae 100644 --- a/internal/querynode/segment.go +++ b/internal/querynode/segment.go @@ -37,6 +37,8 @@ import ( "sync" "unsafe" + "github.com/milvus-io/milvus/internal/util/funcutil" + "github.com/milvus-io/milvus/internal/metrics" "github.com/milvus-io/milvus/internal/util/timerecord" @@ -54,7 +56,6 @@ import ( "github.com/milvus-io/milvus/internal/proto/segcorepb" "github.com/milvus-io/milvus/internal/storage" "github.com/milvus-io/milvus/internal/util/cgoconverter" - "github.com/milvus-io/milvus/internal/util/typeutil" ) type segmentType = commonpb.SegmentState @@ -69,10 +70,10 @@ const ( maxBloomFalsePositive float64 = 0.005 ) -// VectorFieldInfo contains binlog info of vector field -type VectorFieldInfo struct { +// IndexedFieldInfo contains binlog info of vector field +type IndexedFieldInfo struct { fieldBinlog *datapb.FieldBinlog - indexInfo *querypb.VecFieldIndexInfo + indexInfo *querypb.FieldIndexInfo } // Segment is a wrapper of the underlying C-structure segment. @@ -98,8 +99,8 @@ type Segment struct { idBinlogRowSizes []int64 - vectorFieldMutex sync.RWMutex // guards vectorFieldInfos - vectorFieldInfos map[UniqueID]*VectorFieldInfo + indexedFieldMutex sync.RWMutex // guards indexedFieldInfos + indexedFieldInfos map[UniqueID]*IndexedFieldInfo pkFilter *bloom.BloomFilter // bloom filter of pk inside a segment } @@ -149,17 +150,17 @@ func (s *Segment) setOnService(onService bool) { s.onService = onService } -func (s *Segment) setVectorFieldInfo(fieldID UniqueID, info *VectorFieldInfo) { - s.vectorFieldMutex.Lock() - defer s.vectorFieldMutex.Unlock() - s.vectorFieldInfos[fieldID] = info +func (s *Segment) setIndexedFieldInfo(fieldID UniqueID, info *IndexedFieldInfo) { + s.indexedFieldMutex.Lock() + defer s.indexedFieldMutex.Unlock() + s.indexedFieldInfos[fieldID] = info } -func (s *Segment) getVectorFieldInfo(fieldID UniqueID) (*VectorFieldInfo, error) { - s.vectorFieldMutex.RLock() - defer s.vectorFieldMutex.RUnlock() - if info, ok := s.vectorFieldInfos[fieldID]; ok { - return &VectorFieldInfo{ +func (s *Segment) getIndexedFieldInfo(fieldID UniqueID) (*IndexedFieldInfo, error) { + s.indexedFieldMutex.RLock() + defer s.indexedFieldMutex.RUnlock() + if info, ok := s.indexedFieldInfos[fieldID]; ok { + return &IndexedFieldInfo{ fieldBinlog: info.fieldBinlog, indexInfo: info.indexInfo, }, nil @@ -167,11 +168,11 @@ func (s *Segment) getVectorFieldInfo(fieldID UniqueID) (*VectorFieldInfo, error) return nil, errors.New("Invalid fieldID " + strconv.Itoa(int(fieldID))) } -func (s *Segment) hasLoadIndexForVecField(fieldID int64) bool { - s.vectorFieldMutex.RLock() - defer s.vectorFieldMutex.RUnlock() +func (s *Segment) hasLoadIndexForIndexedField(fieldID int64) bool { + s.indexedFieldMutex.RLock() + defer s.indexedFieldMutex.RUnlock() - if fieldInfo, ok := s.vectorFieldInfos[fieldID]; ok { + if fieldInfo, ok := s.indexedFieldInfos[fieldID]; ok { return fieldInfo.indexInfo != nil && fieldInfo.indexInfo.EnableIndex } @@ -207,14 +208,14 @@ func newSegment(collection *Collection, segmentID UniqueID, partitionID UniqueID zap.Int32("segmentType", int32(segType))) var segment = &Segment{ - segmentPtr: segmentPtr, - segmentType: segType, - segmentID: segmentID, - partitionID: partitionID, - collectionID: collectionID, - vChannelID: vChannelID, - onService: onService, - vectorFieldInfos: make(map[UniqueID]*VectorFieldInfo), + segmentPtr: segmentPtr, + segmentType: segType, + segmentID: segmentID, + partitionID: partitionID, + collectionID: collectionID, + vChannelID: vChannelID, + onService: onService, + indexedFieldInfos: make(map[UniqueID]*IndexedFieldInfo), pkFilter: bloom.NewWithEstimates(bloomFilterSize, maxBloomFalsePositive), } @@ -356,68 +357,206 @@ func (s *Segment) retrieve(plan *RetrievePlan) (*segcorepb.RetrieveResults, erro return result, nil } -func (s *Segment) fillVectorFieldsData(collectionID UniqueID, +func (s *Segment) getFieldDataPath(indexedFieldInfo *IndexedFieldInfo, offset int64) (dataPath string, offsetInBinlog int64) { + offsetInBinlog = offset + for index, idBinlogRowSize := range s.idBinlogRowSizes { + if offsetInBinlog < idBinlogRowSize { + dataPath = indexedFieldInfo.fieldBinlog.Binlogs[index].GetLogPath() + break + } else { + offsetInBinlog -= idBinlogRowSize + } + } + return dataPath, offsetInBinlog +} + +func fillBinVecFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + dim := fieldData.GetVectors().GetDim() + rowBytes := dim / 8 + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + x := fieldData.GetVectors().GetData().(*schemapb.VectorField_BinaryVector) + resultLen := dim / 8 + copy(x.BinaryVector[i*int(resultLen):(i+1)*int(resultLen)], content) + return nil +} + +func fillFloatVecFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + dim := fieldData.GetVectors().GetDim() + rowBytes := dim * 4 + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + x := fieldData.GetVectors().GetData().(*schemapb.VectorField_FloatVector) + floatResult := make([]float32, dim) + buf := bytes.NewReader(content) + if err = binary.Read(buf, endian, &floatResult); err != nil { + return err + } + resultLen := dim + copy(x.FloatVector.Data[i*int(resultLen):(i+1)*int(resultLen)], floatResult) + return nil +} + +func fillBoolFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read whole file. + // TODO: optimize here. + content, err := vcm.Read(dataPath) + if err != nil { + return err + } + var arr schemapb.BoolArray + err = proto.Unmarshal(content, &arr) + if err != nil { + return err + } + fieldData.GetScalars().GetBoolData().GetData()[i] = arr.Data[offset] + return nil +} + +func fillStringFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read whole file. + // TODO: optimize here. + content, err := vcm.Read(dataPath) + if err != nil { + return err + } + var arr schemapb.StringArray + err = proto.Unmarshal(content, &arr) + if err != nil { + return err + } + fieldData.GetScalars().GetStringData().GetData()[i] = arr.Data[offset] + return nil +} + +func fillInt8FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(1) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + var i8 int8 + if err := funcutil.ReadBinary(endian, content, &i8); err != nil { + return err + } + fieldData.GetScalars().GetIntData().GetData()[i] = int32(i8) + return nil +} + +func fillInt16FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(2) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + var i16 int16 + if err := funcutil.ReadBinary(endian, content, &i16); err != nil { + return err + } + fieldData.GetScalars().GetIntData().GetData()[i] = int32(i16) + return nil +} + +func fillInt32FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(4) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetIntData().GetData()[i])) +} + +func fillInt64FieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(8) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetLongData().GetData()[i])) +} + +func fillFloatFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(4) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetFloatData().GetData()[i])) +} + +func fillDoubleFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + // read by offset. + rowBytes := int64(8) + content, err := vcm.ReadAt(dataPath, offset*rowBytes, rowBytes) + if err != nil { + return err + } + return funcutil.ReadBinary(endian, content, &(fieldData.GetScalars().GetDoubleData().GetData()[i])) +} + +func fillFieldData(vcm storage.ChunkManager, dataPath string, fieldData *schemapb.FieldData, i int, offset int64, endian binary.ByteOrder) error { + switch fieldData.Type { + case schemapb.DataType_BinaryVector: + return fillBinVecFieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_FloatVector: + return fillFloatVecFieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Bool: + return fillBoolFieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_String, schemapb.DataType_VarChar: + return fillStringFieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Int8: + return fillInt8FieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Int16: + return fillInt16FieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Int32: + return fillInt32FieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Int64: + return fillInt64FieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Float: + return fillFloatFieldData(vcm, dataPath, fieldData, i, offset, endian) + case schemapb.DataType_Double: + return fillDoubleFieldData(vcm, dataPath, fieldData, i, offset, endian) + default: + return fmt.Errorf("invalid data type: %s", fieldData.Type.String()) + } +} + +func (s *Segment) fillIndexedFieldsData(collectionID UniqueID, vcm storage.ChunkManager, result *segcorepb.RetrieveResults) error { for _, fieldData := range result.FieldsData { - if !typeutil.IsVectorType(fieldData.Type) { + // If the vector field doesn't have indexed. Vector data is in memory for + // brute force search. No need to download data from remote. + if !s.hasLoadIndexForIndexedField(fieldData.FieldId) { continue } - vecFieldInfo, err := s.getVectorFieldInfo(fieldData.FieldId) + indexedFieldInfo, err := s.getIndexedFieldInfo(fieldData.FieldId) if err != nil { continue } - // If the vector field doesn't have indexed. Vector data is in memory for - // brute force search. No need to download data from remote. - if !s.hasLoadIndexForVecField(fieldData.FieldId) { - continue - } - - dim := fieldData.GetVectors().GetDim() - log.Debug("FillVectorFieldData", zap.Int64("fieldId", fieldData.FieldId), - zap.Any("datatype", fieldData.Type), zap.Int64("dim", dim)) - + // TODO: optimize here. Now we'll read a whole file from storage every time we retrieve raw data by offset. for i, offset := range result.Offset { - var vecPath string - for index, idBinlogRowSize := range s.idBinlogRowSizes { - if offset < idBinlogRowSize { - vecPath = vecFieldInfo.fieldBinlog.Binlogs[index].GetLogPath() - break - } else { - offset -= idBinlogRowSize - } - } - log.Debug("FillVectorFieldData", zap.String("path", vecPath)) + dataPath, offsetInBinlog := s.getFieldDataPath(indexedFieldInfo, offset) + endian := common.Endian - switch fieldData.Type { - case schemapb.DataType_BinaryVector: - rowBytes := dim / 8 - x := fieldData.GetVectors().GetData().(*schemapb.VectorField_BinaryVector) - content, err := vcm.ReadAt(vecPath, offset*rowBytes, rowBytes) - if err != nil { - return err - } - resultLen := dim / 8 - copy(x.BinaryVector[i*int(resultLen):(i+1)*int(resultLen)], content) - case schemapb.DataType_FloatVector: - x := fieldData.GetVectors().GetData().(*schemapb.VectorField_FloatVector) - rowBytes := dim * 4 - content, err := vcm.ReadAt(vecPath, offset*rowBytes, rowBytes) - if err != nil { - return err - } - floatResult := make([]float32, dim) - buf := bytes.NewReader(content) - if err = binary.Read(buf, common.Endian, &floatResult); err != nil { - return err - } - resultLen := dim - copy(x.FloatVector.Data[i*int(resultLen):(i+1)*int(resultLen)], floatResult) + // fill field data that fieldData[i] = dataPath[offsetInBinlog*rowBytes, (offsetInBinlog+1)*rowBytes] + if err := fillFieldData(vcm, dataPath, fieldData, i, offsetInBinlog, endian); err != nil { + return err } } } + return nil } @@ -677,7 +816,7 @@ func (s *Segment) segmentLoadDeletedRecord(primaryKeys []IntPrimaryKey, timestam return nil } -func (s *Segment) segmentLoadIndexData(bytesIndex [][]byte, indexInfo *querypb.VecFieldIndexInfo) error { +func (s *Segment) segmentLoadIndexData(bytesIndex [][]byte, indexInfo *querypb.FieldIndexInfo) error { loadIndexInfo, err := newLoadIndexInfo() defer deleteLoadIndexInfo(loadIndexInfo) if err != nil { diff --git a/internal/querynode/segment_loader.go b/internal/querynode/segment_loader.go index bcd27fd2cc..a127ef081b 100644 --- a/internal/querynode/segment_loader.go +++ b/internal/querynode/segment_loader.go @@ -189,48 +189,43 @@ func (loader *segmentLoader) loadSegmentInternal(segment *Segment, zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID), zap.Int64("segmentID", segmentID)) - vecFieldIDs, err := loader.historicalReplica.getVecFieldIDsByCollectionID(collectionID) - if err != nil { - return err - } + pkFieldID, err := loader.historicalReplica.getPKFieldIDByCollectionID(collectionID) if err != nil { return err } - var nonVecFieldBinlogs []*datapb.FieldBinlog + var nonIndexedFieldBinlogs []*datapb.FieldBinlog if segment.getType() == segmentTypeSealed { - fieldID2IndexInfo := make(map[int64]*querypb.VecFieldIndexInfo) + fieldID2IndexInfo := make(map[int64]*querypb.FieldIndexInfo) for _, indexInfo := range loadInfo.IndexInfos { fieldID := indexInfo.FieldID fieldID2IndexInfo[fieldID] = indexInfo } - vecFieldInfos := make(map[int64]*VectorFieldInfo) + indexedFieldInfos := make(map[int64]*IndexedFieldInfo) for _, fieldBinlog := range loadInfo.BinlogPaths { fieldID := fieldBinlog.FieldID - if funcutil.SliceContain(vecFieldIDs, fieldID) { - fieldInfo := &VectorFieldInfo{ + if indexInfo, ok := fieldID2IndexInfo[fieldID]; ok { + fieldInfo := &IndexedFieldInfo{ fieldBinlog: fieldBinlog, + indexInfo: indexInfo, } - if indexInfo, ok := fieldID2IndexInfo[fieldID]; ok { - fieldInfo.indexInfo = indexInfo - } - vecFieldInfos[fieldID] = fieldInfo + indexedFieldInfos[fieldID] = fieldInfo } else { - nonVecFieldBinlogs = append(nonVecFieldBinlogs, fieldBinlog) + nonIndexedFieldBinlogs = append(nonIndexedFieldBinlogs, fieldBinlog) } } - err = loader.loadVecFieldData(segment, vecFieldInfos) + err = loader.loadIndexedFieldData(segment, indexedFieldInfos) if err != nil { return err } } else { - nonVecFieldBinlogs = loadInfo.BinlogPaths + nonIndexedFieldBinlogs = loadInfo.BinlogPaths } - err = loader.loadFiledBinlogData(segment, nonVecFieldBinlogs) + err = loader.loadFiledBinlogData(segment, nonIndexedFieldBinlogs) if err != nil { return err } @@ -302,7 +297,7 @@ func (loader *segmentLoader) loadFiledBinlogData(segment *Segment, fieldBinlogs } } -func (loader *segmentLoader) loadVecFieldData(segment *Segment, vecFieldInfos map[int64]*VectorFieldInfo) error { +func (loader *segmentLoader) loadIndexedFieldData(segment *Segment, vecFieldInfos map[int64]*IndexedFieldInfo) error { for fieldID, fieldInfo := range vecFieldInfos { if fieldInfo.indexInfo == nil || !fieldInfo.indexInfo.EnableIndex { fieldBinlog := fieldInfo.fieldBinlog @@ -313,21 +308,22 @@ func (loader *segmentLoader) loadVecFieldData(segment *Segment, vecFieldInfos ma log.Debug("load vector field's binlog data done", zap.Int64("segmentID", segment.ID()), zap.Int64("fieldID", fieldID)) } else { indexInfo := fieldInfo.indexInfo - err := loader.loadVecFieldIndexData(segment, indexInfo) + err := loader.loadFieldIndexData(segment, indexInfo) if err != nil { return err } log.Debug("load vector field's index data done", zap.Int64("segmentID", segment.ID()), zap.Int64("fieldID", fieldID)) } - segment.setVectorFieldInfo(fieldID, fieldInfo) + segment.setIndexedFieldInfo(fieldID, fieldInfo) } return nil } -func (loader *segmentLoader) loadVecFieldIndexData(segment *Segment, indexInfo *querypb.VecFieldIndexInfo) error { +func (loader *segmentLoader) loadFieldIndexData(segment *Segment, indexInfo *querypb.FieldIndexInfo) error { indexBuffer := make([][]byte, 0) indexCodec := storage.NewIndexFileBinlogCodec() + filteredPaths := make([]string, 0, len(indexInfo.IndexFilePaths)) for _, p := range indexInfo.IndexFilePaths { log.Debug("load index file", zap.String("path", p)) indexPiece, err := loader.cm.Read(p) @@ -341,9 +337,11 @@ func (loader *segmentLoader) loadVecFieldIndexData(segment *Segment, indexInfo * return err } indexBuffer = append(indexBuffer, data[0].Value) + filteredPaths = append(filteredPaths, p) } } // 2. use index bytes and index path to update segment + indexInfo.IndexFilePaths = filteredPaths err := segment.segmentLoadIndexData(indexBuffer, indexInfo) return err } diff --git a/internal/querynode/segment_loader_test.go b/internal/querynode/segment_loader_test.go index 67d700e30b..369e306424 100644 --- a/internal/querynode/segment_loader_test.go +++ b/internal/querynode/segment_loader_test.go @@ -464,7 +464,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) { // generate index file for segment indexPaths, err := generateIndex(segmentID) assert.NoError(t, err) - indexInfo := &querypb.VecFieldIndexInfo{ + indexInfo := &querypb.FieldIndexInfo{ FieldID: simpleVecField.id, EnableIndex: true, IndexName: indexName, @@ -493,7 +493,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) { PartitionID: defaultPartitionID, CollectionID: defaultCollectionID, BinlogPaths: fieldBinlog, - IndexInfos: []*querypb.VecFieldIndexInfo{indexInfo}, + IndexInfos: []*querypb.FieldIndexInfo{indexInfo}, }, }, } @@ -503,7 +503,7 @@ func TestSegmentLoader_testLoadSealedSegmentWithIndex(t *testing.T) { segment, err := node.historical.replica.getSegmentByID(segmentID) assert.NoError(t, err) - vecFieldInfo, err := segment.getVectorFieldInfo(simpleVecField.id) + vecFieldInfo, err := segment.getIndexedFieldInfo(simpleVecField.id) assert.NoError(t, err) assert.NotNil(t, vecFieldInfo) assert.Equal(t, true, vecFieldInfo.indexInfo.EnableIndex) diff --git a/internal/querynode/segment_test.go b/internal/querynode/segment_test.go index b78d5acf1c..01c0900876 100644 --- a/internal/querynode/segment_test.go +++ b/internal/querynode/segment_test.go @@ -20,9 +20,12 @@ import ( "context" "log" "math" + "math/rand" "sync" "testing" + "github.com/milvus-io/milvus/internal/storage" + "github.com/golang/protobuf/proto" "github.com/stretchr/testify/assert" @@ -917,7 +920,7 @@ func TestSegment_indexInfo(t *testing.T) { indexID := UniqueID(0) buildID := UniqueID(0) - indexInfo := &querypb.VecFieldIndexInfo{ + indexInfo := &querypb.FieldIndexInfo{ IndexName: indexName, IndexParams: funcutil.Map2KeyValuePair(indexParam), IndexFilePaths: indexPaths, @@ -925,9 +928,9 @@ func TestSegment_indexInfo(t *testing.T) { BuildID: buildID, } - seg.setVectorFieldInfo(fieldID, &VectorFieldInfo{indexInfo: indexInfo}) + seg.setIndexedFieldInfo(fieldID, &IndexedFieldInfo{indexInfo: indexInfo}) - fieldInfo, err := seg.getVectorFieldInfo(fieldID) + fieldInfo, err := seg.getIndexedFieldInfo(fieldID) assert.Nil(t, err) info := fieldInfo.indexInfo assert.Equal(t, indexName, info.IndexName) @@ -974,25 +977,25 @@ func TestSegment_BasicMetrics(t *testing.T) { assert.Equal(t, false, resOnService) }) - t.Run("test VectorFieldInfo", func(t *testing.T) { + t.Run("test IndexedFieldInfo", func(t *testing.T) { fieldID := rowIDFieldID - info := &VectorFieldInfo{ + info := &IndexedFieldInfo{ fieldBinlog: &datapb.FieldBinlog{ FieldID: fieldID, Binlogs: []*datapb.Binlog{}, }, } - segment.setVectorFieldInfo(fieldID, info) - resInfo, err := segment.getVectorFieldInfo(fieldID) + segment.setIndexedFieldInfo(fieldID, info) + resInfo, err := segment.getIndexedFieldInfo(fieldID) assert.NoError(t, err) assert.Equal(t, info, resInfo) - _, err = segment.getVectorFieldInfo(FieldID(1000)) + _, err = segment.getIndexedFieldInfo(FieldID(1000)) assert.Error(t, err) }) } -func TestSegment_fillVectorFieldsData(t *testing.T) { +func TestSegment_fillIndexedFieldsData(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -1010,17 +1013,17 @@ func TestSegment_fillVectorFieldsData(t *testing.T) { vecCM, err := genVectorChunkManager(ctx) assert.NoError(t, err) - t.Run("test fillVectorFieldsData float-vector invalid vectorChunkManager", func(t *testing.T) { + t.Run("test fillIndexedFieldsData float-vector invalid vectorChunkManager", func(t *testing.T) { fieldID := FieldID(100) fieldName := "float-vector-field-0" - info := &VectorFieldInfo{ + info := &IndexedFieldInfo{ fieldBinlog: &datapb.FieldBinlog{ FieldID: fieldID, Binlogs: []*datapb.Binlog{}, }, - indexInfo: &querypb.VecFieldIndexInfo{EnableIndex: true}, + indexInfo: &querypb.FieldIndexInfo{EnableIndex: true}, } - segment.setVectorFieldInfo(fieldID, info) + segment.setIndexedFieldInfo(fieldID, info) fieldData := []*schemapb.FieldData{ { Type: schemapb.DataType_FloatVector, @@ -1043,7 +1046,488 @@ func TestSegment_fillVectorFieldsData(t *testing.T) { Offset: []int64{0}, FieldsData: fieldData, } - err = segment.fillVectorFieldsData(defaultCollectionID, vecCM, result) + err = segment.fillIndexedFieldsData(defaultCollectionID, vecCM, result) assert.Error(t, err) }) } + +func Test_getFieldDataPath(t *testing.T) { + indexedFieldInfo := &IndexedFieldInfo{ + fieldBinlog: &datapb.FieldBinlog{ + FieldID: 0, + Binlogs: []*datapb.Binlog{ + { + LogPath: funcutil.GenRandomStr(), + }, + { + LogPath: funcutil.GenRandomStr(), + }, + }, + }, + } + s := &Segment{ + idBinlogRowSizes: []int64{10, 15}, + } + + path, offsetInBinlog := s.getFieldDataPath(indexedFieldInfo, 4) + assert.Equal(t, indexedFieldInfo.fieldBinlog.Binlogs[0].LogPath, path) + assert.Equal(t, int64(4), offsetInBinlog) + + path, offsetInBinlog = s.getFieldDataPath(indexedFieldInfo, 11) + assert.Equal(t, indexedFieldInfo.fieldBinlog.Binlogs[1].LogPath, path) + assert.Equal(t, int64(1), offsetInBinlog) +} + +func generateBoolArray(numRows int) []bool { + ret := make([]bool, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, rand.Int()%2 == 0) + } + return ret +} + +func generateInt8Array(numRows int) []int8 { + ret := make([]int8, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, int8(rand.Int())) + } + return ret +} + +func generateInt16Array(numRows int) []int16 { + ret := make([]int16, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, int16(rand.Int())) + } + return ret +} + +func generateInt32Array(numRows int) []int32 { + ret := make([]int32, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, int32(rand.Int())) + } + return ret +} + +func generateInt64Array(numRows int) []int64 { + ret := make([]int64, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, int64(rand.Int())) + } + return ret +} + +func generateFloat32Array(numRows int) []float32 { + ret := make([]float32, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, rand.Float32()) + } + return ret +} + +func generateStringArray(numRows int) []string { + ret := make([]string, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, funcutil.GenRandomStr()) + } + return ret +} + +func generateFloat64Array(numRows int) []float64 { + ret := make([]float64, 0, numRows) + for i := 0; i < numRows; i++ { + ret = append(ret, rand.Float64()) + } + return ret +} + +func generateFloatVectors(numRows, dim int) []float32 { + total := numRows * dim + ret := make([]float32, 0, total) + for i := 0; i < total; i++ { + ret = append(ret, rand.Float32()) + } + return ret +} + +func generateBinaryVectors(numRows, dim int) []byte { + total := (numRows * dim) / 8 + ret := make([]byte, total) + _, err := rand.Read(ret) + if err != nil { + panic(err) + } + return ret +} + +func newScalarFieldData(dType schemapb.DataType, fieldName string, numRows int) *schemapb.FieldData { + ret := &schemapb.FieldData{ + Type: dType, + FieldName: fieldName, + Field: nil, + } + + switch dType { + case schemapb.DataType_Bool: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_BoolData{ + BoolData: &schemapb.BoolArray{ + Data: generateBoolArray(numRows), + }, + }, + }, + } + case schemapb.DataType_Int8: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_IntData{ + IntData: &schemapb.IntArray{ + Data: generateInt32Array(numRows), + }, + }, + }, + } + case schemapb.DataType_Int16: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_IntData{ + IntData: &schemapb.IntArray{ + Data: generateInt32Array(numRows), + }, + }, + }, + } + case schemapb.DataType_Int32: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_IntData{ + IntData: &schemapb.IntArray{ + Data: generateInt32Array(numRows), + }, + }, + }, + } + case schemapb.DataType_Int64: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_LongData{ + LongData: &schemapb.LongArray{ + Data: generateInt64Array(numRows), + }, + }, + }, + } + case schemapb.DataType_Float: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_FloatData{ + FloatData: &schemapb.FloatArray{ + Data: generateFloat32Array(numRows), + }, + }, + }, + } + case schemapb.DataType_Double: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_DoubleData{ + DoubleData: &schemapb.DoubleArray{ + Data: generateFloat64Array(numRows), + }, + }, + }, + } + case schemapb.DataType_VarChar, schemapb.DataType_String: + ret.Field = &schemapb.FieldData_Scalars{ + Scalars: &schemapb.ScalarField{ + Data: &schemapb.ScalarField_StringData{ + StringData: &schemapb.StringArray{ + Data: generateStringArray(numRows), + }, + }, + }, + } + } + + return ret +} + +func newFloatVectorFieldData(fieldName string, numRows, dim int) *schemapb.FieldData { + return &schemapb.FieldData{ + Type: schemapb.DataType_FloatVector, + FieldName: fieldName, + Field: &schemapb.FieldData_Vectors{ + Vectors: &schemapb.VectorField{ + Dim: int64(dim), + Data: &schemapb.VectorField_FloatVector{ + FloatVector: &schemapb.FloatArray{ + Data: generateFloatVectors(numRows, dim), + }, + }, + }, + }, + } +} + +func newBinaryVectorFieldData(fieldName string, numRows, dim int) *schemapb.FieldData { + return &schemapb.FieldData{ + Type: schemapb.DataType_BinaryVector, + FieldName: fieldName, + Field: &schemapb.FieldData_Vectors{ + Vectors: &schemapb.VectorField{ + Dim: int64(dim), + Data: &schemapb.VectorField_BinaryVector{ + BinaryVector: generateBinaryVectors(numRows, dim), + }, + }, + }, + } +} + +func Test_fillBinVecFieldData(t *testing.T) { + var m storage.ChunkManager + + m = newMockChunkManager(withDefaultReadAt()) + + f := newBinaryVectorFieldData("bv", 1, 8) + + path := funcutil.GenRandomStr() + index := 0 + offset := int64(100) + endian := common.Endian + + assert.NoError(t, fillBinVecFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillBinVecFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillFloatVecFieldData(t *testing.T) { + var m storage.ChunkManager + + m = newMockChunkManager(withDefaultReadAt()) + + f := newFloatVectorFieldData("fv", 1, 8) + + path := funcutil.GenRandomStr() + index := 0 + offset := int64(100) + endian := common.Endian + + assert.NoError(t, fillFloatVecFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillFloatVecFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillFloatVecFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillBoolFieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withReadBool(offset)) + + f := newScalarFieldData(schemapb.DataType_Bool, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillBoolFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadErr()) + assert.Error(t, fillBoolFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadIllegalBool()) + assert.Error(t, fillBoolFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillStringFieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withReadString(offset)) + + f := newScalarFieldData(schemapb.DataType_VarChar, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillStringFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadErr()) + assert.Error(t, fillStringFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadIllegalString()) + assert.Error(t, fillStringFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillInt8FieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Int8, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillInt8FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillInt8FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillInt8FieldData(m, path, f, index, offset, endian)) +} + +func Test_fillInt16FieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Int16, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillInt16FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillInt16FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillInt16FieldData(m, path, f, index, offset, endian)) +} + +func Test_fillInt32FieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Int32, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillInt32FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillInt32FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillInt32FieldData(m, path, f, index, offset, endian)) +} + +func Test_fillInt64FieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Int64, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillInt64FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillInt64FieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillInt64FieldData(m, path, f, index, offset, endian)) +} + +func Test_fillFloatFieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Float, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillFloatFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillFloatFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillFloatFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillDoubleFieldData(t *testing.T) { + var m storage.ChunkManager + + offset := int64(100) + m = newMockChunkManager(withDefaultReadAt()) + + f := newScalarFieldData(schemapb.DataType_Double, "f", 1) + + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + assert.NoError(t, fillDoubleFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtErr()) + assert.Error(t, fillDoubleFieldData(m, path, f, index, offset, endian)) + + m = newMockChunkManager(withReadAtEmptyContent()) + assert.Error(t, fillDoubleFieldData(m, path, f, index, offset, endian)) +} + +func Test_fillFieldData(t *testing.T) { + var m storage.ChunkManager + + fs := []*schemapb.FieldData{ + newBinaryVectorFieldData("bv", 1, 8), + newFloatVectorFieldData("fv", 1, 8), + newScalarFieldData(schemapb.DataType_Bool, "f", 1), + newScalarFieldData(schemapb.DataType_VarChar, "f", 1), + newScalarFieldData(schemapb.DataType_Int8, "f", 1), + newScalarFieldData(schemapb.DataType_Int16, "f", 1), + newScalarFieldData(schemapb.DataType_Int32, "f", 1), + newScalarFieldData(schemapb.DataType_Int64, "f", 1), + newScalarFieldData(schemapb.DataType_Float, "f", 1), + newScalarFieldData(schemapb.DataType_Double, "f", 1), + } + + offset := int64(100) + path := funcutil.GenRandomStr() + index := 0 + endian := common.Endian + + for _, f := range fs { + if f.Type == schemapb.DataType_Bool { + m = newMockChunkManager(withReadBool(offset)) + } else if funcutil.SliceContain([]schemapb.DataType{ + schemapb.DataType_String, + schemapb.DataType_VarChar, + }, f.Type) { + m = newMockChunkManager(withReadString(offset)) + } else { + m = newMockChunkManager(withDefaultReadAt()) + } + + assert.NoError(t, fillFieldData(m, path, f, index, offset, endian)) + } + + assert.Error(t, fillFieldData(m, path, &schemapb.FieldData{Type: schemapb.DataType_None}, index, offset, endian)) +} diff --git a/internal/rootcoord/meta_table.go b/internal/rootcoord/meta_table.go index 553691c7e6..4e3575c392 100644 --- a/internal/rootcoord/meta_table.go +++ b/internal/rootcoord/meta_table.go @@ -975,6 +975,18 @@ func (mt *MetaTable) GetSegmentIndexInfoByID(segID typeutil.UniqueID, fieldID in return pb.SegmentIndexInfo{}, fmt.Errorf("can't find index name = %s on segment = %d, with filed id = %d", idxName, segID, fieldID) } +func (mt *MetaTable) GetSegmentIndexInfos(segID typeutil.UniqueID) (map[typeutil.UniqueID]pb.SegmentIndexInfo, error) { + mt.ddLock.RLock() + defer mt.ddLock.RUnlock() + + ret, ok := mt.segID2IndexMeta[segID] + if !ok { + return nil, fmt.Errorf("segment not found in meta, segment: %d", segID) + } + + return ret, nil +} + // GetFieldSchema return field schema func (mt *MetaTable) GetFieldSchema(collName string, fieldName string) (schemapb.FieldSchema, error) { mt.ddLock.RLock() diff --git a/internal/rootcoord/meta_table_test.go b/internal/rootcoord/meta_table_test.go index dcbf56fde1..78d8972c05 100644 --- a/internal/rootcoord/meta_table_test.go +++ b/internal/rootcoord/meta_table_test.go @@ -1316,3 +1316,36 @@ func TestFixIssue10540(t *testing.T) { _, err = NewMetaTable(txnKV, skv) assert.Nil(t, err) } + +func TestMetaTable_GetSegmentIndexInfos(t *testing.T) { + meta := &MetaTable{ + segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]pb.SegmentIndexInfo{}, + } + + segID := typeutil.UniqueID(100) + _, err := meta.GetSegmentIndexInfos(segID) + assert.Error(t, err) + + meta.segID2IndexMeta[segID] = map[typeutil.UniqueID]pb.SegmentIndexInfo{ + 5: { + CollectionID: 1, + PartitionID: 2, + SegmentID: segID, + FieldID: 4, + IndexID: 5, + BuildID: 6, + EnableIndex: true, + }, + } + infos, err := meta.GetSegmentIndexInfos(segID) + assert.NoError(t, err) + indexInfos, ok := infos[5] + assert.True(t, ok) + assert.Equal(t, typeutil.UniqueID(1), indexInfos.GetCollectionID()) + assert.Equal(t, typeutil.UniqueID(2), indexInfos.GetPartitionID()) + assert.Equal(t, segID, indexInfos.GetSegmentID()) + assert.Equal(t, typeutil.UniqueID(4), indexInfos.GetFieldID()) + assert.Equal(t, typeutil.UniqueID(5), indexInfos.GetIndexID()) + assert.Equal(t, typeutil.UniqueID(6), indexInfos.GetBuildID()) + assert.Equal(t, true, indexInfos.GetEnableIndex()) +} diff --git a/internal/rootcoord/root_coord.go b/internal/rootcoord/root_coord.go index 3d42402b4e..1ece7066e0 100644 --- a/internal/rootcoord/root_coord.go +++ b/internal/rootcoord/root_coord.go @@ -1837,6 +1837,64 @@ func (c *Core) DescribeSegment(ctx context.Context, in *milvuspb.DescribeSegment return t.Rsp, nil } +func (c *Core) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) { + metrics.RootCoordDescribeSegmentsCounter.WithLabelValues(metrics.TotalLabel).Inc() + + if code, ok := c.checkHealthy(); !ok { + log.Error("failed to describe segments, rootcoord not healthy", + zap.String("role", typeutil.RootCoordRole), + zap.Int64("msgID", in.GetBase().GetMsgID()), + zap.Int64("collection", in.GetCollectionID()), + zap.Int64s("segments", in.GetSegmentIDs())) + + return &rootcoordpb.DescribeSegmentsResponse{ + Status: failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]), + }, nil + } + + tr := timerecord.NewTimeRecorder("DescribeSegments") + + log.Debug("received request to describe segments", + zap.String("role", typeutil.RootCoordRole), + zap.Int64("msgID", in.GetBase().GetMsgID()), + zap.Int64("collection", in.GetCollectionID()), + zap.Int64s("segments", in.GetSegmentIDs())) + + t := &DescribeSegmentsReqTask{ + baseReqTask: baseReqTask{ + ctx: ctx, + core: c, + }, + Req: in, + Rsp: &rootcoordpb.DescribeSegmentsResponse{}, + } + + if err := executeTask(t); err != nil { + log.Error("failed to describe segments", + zap.Error(err), + zap.String("role", typeutil.RootCoordRole), + zap.Int64("msgID", in.GetBase().GetMsgID()), + zap.Int64("collection", in.GetCollectionID()), + zap.Int64s("segments", in.GetSegmentIDs())) + + return &rootcoordpb.DescribeSegmentsResponse{ + Status: failStatus(commonpb.ErrorCode_UnexpectedError, "DescribeSegments failed: "+err.Error()), + }, nil + } + + log.Debug("succeed to describe segments", + zap.String("role", typeutil.RootCoordRole), + zap.Int64("msgID", in.GetBase().GetMsgID()), + zap.Int64("collection", in.GetCollectionID()), + zap.Int64s("segments", in.GetSegmentIDs())) + + metrics.RootCoordDescribeSegmentsCounter.WithLabelValues(metrics.SuccessLabel).Inc() + metrics.RootCoordDDLReadTypeLatency.WithLabelValues("DescribeSegments").Observe(float64(tr.ElapseSpan().Milliseconds())) + + t.Rsp.Status = succStatus() + return t.Rsp, nil +} + // ShowSegments list all segments func (c *Core) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) { metrics.RootCoordShowSegmentsCounter.WithLabelValues(metrics.TotalLabel).Inc() diff --git a/internal/rootcoord/root_coord_test.go b/internal/rootcoord/root_coord_test.go index 5f4b654f88..dfc99384c1 100644 --- a/internal/rootcoord/root_coord_test.go +++ b/internal/rootcoord/root_coord_test.go @@ -2992,3 +2992,88 @@ func TestCore_GetComponentStates(t *testing.T) { assert.NoError(t, err) assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode) } + +func TestCore_DescribeSegments(t *testing.T) { + collID := typeutil.UniqueID(1) + partID := typeutil.UniqueID(2) + segID := typeutil.UniqueID(100) + fieldID := typeutil.UniqueID(3) + buildID := typeutil.UniqueID(4) + indexID := typeutil.UniqueID(1000) + indexName := "test_describe_segments_index" + + c := &Core{ + ctx: context.Background(), + } + + // not healthy. + c.stateCode.Store(internalpb.StateCode_Abnormal) + got1, err := c.DescribeSegments(context.Background(), &rootcoordpb.DescribeSegmentsRequest{}) + assert.NoError(t, err) + assert.NotEqual(t, commonpb.ErrorCode_Success, got1.GetStatus().GetErrorCode()) + + // failed to be executed. + c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) { + return []typeutil.UniqueID{segID}, nil + } + c.stateCode.Store(internalpb.StateCode_Healthy) + shortDuration := time.Nanosecond + shortCtx, cancel := context.WithTimeout(c.ctx, shortDuration) + defer cancel() + time.Sleep(shortDuration) + got2, err := c.DescribeSegments(shortCtx, &rootcoordpb.DescribeSegmentsRequest{}) + assert.NoError(t, err) + assert.NotEqual(t, commonpb.ErrorCode_Success, got2.GetStatus().GetErrorCode()) + + // success. + c.MetaTable = &MetaTable{ + segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{ + segID: { + indexID: { + CollectionID: collID, + PartitionID: partID, + SegmentID: segID, + FieldID: fieldID, + IndexID: indexID, + BuildID: buildID, + EnableIndex: true, + }, + }, + }, + indexID2Meta: map[typeutil.UniqueID]etcdpb.IndexInfo{ + indexID: { + IndexName: indexName, + IndexID: indexID, + IndexParams: nil, + }, + }, + } + infos, err := c.DescribeSegments(context.Background(), &rootcoordpb.DescribeSegmentsRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DescribeSegments, + MsgID: 0, + Timestamp: 0, + SourceID: 0, + }, + CollectionID: collID, + SegmentIDs: []typeutil.UniqueID{segID}, + }) + assert.NoError(t, err) + assert.Equal(t, commonpb.ErrorCode_Success, infos.GetStatus().GetErrorCode()) + assert.Equal(t, 1, len(infos.GetSegmentInfos())) + segmentInfo, ok := infos.GetSegmentInfos()[segID] + assert.True(t, ok) + assert.Equal(t, 1, len(segmentInfo.GetIndexInfos())) + assert.Equal(t, collID, segmentInfo.GetIndexInfos()[0].GetCollectionID()) + assert.Equal(t, partID, segmentInfo.GetIndexInfos()[0].GetPartitionID()) + assert.Equal(t, segID, segmentInfo.GetIndexInfos()[0].GetSegmentID()) + assert.Equal(t, fieldID, segmentInfo.GetIndexInfos()[0].GetFieldID()) + assert.Equal(t, indexID, segmentInfo.GetIndexInfos()[0].GetIndexID()) + assert.Equal(t, buildID, segmentInfo.GetIndexInfos()[0].GetBuildID()) + assert.Equal(t, true, segmentInfo.GetIndexInfos()[0].GetEnableIndex()) + + indexInfo, ok := segmentInfo.GetExtraIndexInfos()[indexID] + assert.True(t, ok) + assert.Equal(t, indexName, indexInfo.IndexName) + assert.Equal(t, indexID, indexInfo.IndexID) +} diff --git a/internal/rootcoord/task.go b/internal/rootcoord/task.go index 826ada02a9..6af3876adf 100644 --- a/internal/rootcoord/task.go +++ b/internal/rootcoord/task.go @@ -29,6 +29,7 @@ import ( "github.com/milvus-io/milvus/internal/proto/etcdpb" "github.com/milvus-io/milvus/internal/proto/internalpb" "github.com/milvus-io/milvus/internal/proto/milvuspb" + "github.com/milvus-io/milvus/internal/proto/rootcoordpb" "github.com/milvus-io/milvus/internal/proto/schemapb" "github.com/milvus-io/milvus/internal/util/funcutil" "github.com/milvus-io/milvus/internal/util/tsoutil" @@ -829,6 +830,88 @@ func (t *ShowSegmentReqTask) Execute(ctx context.Context) error { return nil } +type DescribeSegmentsReqTask struct { + baseReqTask + Req *rootcoordpb.DescribeSegmentsRequest + Rsp *rootcoordpb.DescribeSegmentsResponse +} + +func (t *DescribeSegmentsReqTask) Type() commonpb.MsgType { + return t.Req.GetBase().GetMsgType() +} + +func (t *DescribeSegmentsReqTask) Execute(ctx context.Context) error { + collectionID := t.Req.GetCollectionID() + segIDs, err := t.core.CallGetFlushedSegmentsService(ctx, collectionID, -1) + if err != nil { + log.Error("failed to get flushed segments", + zap.Error(err), + zap.Int64("collection", collectionID)) + return err + } + + t.Rsp.CollectionID = collectionID + t.Rsp.SegmentInfos = make(map[typeutil.UniqueID]*rootcoordpb.SegmentInfos) + + segIDsMap := make(map[typeutil.UniqueID]struct{}) + for _, segID := range segIDs { + segIDsMap[segID] = struct{}{} + } + + for _, segID := range t.Req.SegmentIDs { + if _, ok := segIDsMap[segID]; !ok { + log.Warn("requested segment not found", + zap.Int64("collection", collectionID), + zap.Int64("segment", segID)) + return fmt.Errorf("segment not found, collection: %d, segment: %d", + collectionID, segID) + } + + if _, ok := t.Rsp.SegmentInfos[segID]; !ok { + t.Rsp.SegmentInfos[segID] = &rootcoordpb.SegmentInfos{ + BaseInfo: &rootcoordpb.SegmentBaseInfo{ + CollectionID: collectionID, + PartitionID: 0, // TODO: change this after MetaTable.partID2SegID been fixed. + SegmentID: segID, + }, + IndexInfos: nil, + ExtraIndexInfos: make(map[typeutil.UniqueID]*etcdpb.IndexInfo), + } + } + + segmentInfo, err := t.core.MetaTable.GetSegmentIndexInfos(segID) + if err != nil { + continue + } + + for indexID, indexInfo := range segmentInfo { + t.Rsp.SegmentInfos[segID].IndexInfos = + append(t.Rsp.SegmentInfos[segID].IndexInfos, + &etcdpb.SegmentIndexInfo{ + CollectionID: indexInfo.CollectionID, + PartitionID: indexInfo.PartitionID, + SegmentID: indexInfo.SegmentID, + FieldID: indexInfo.FieldID, + IndexID: indexInfo.IndexID, + BuildID: indexInfo.BuildID, + EnableIndex: indexInfo.EnableIndex, + }) + extraIndexInfo, err := t.core.MetaTable.GetIndexByID(indexID) + if err != nil { + log.Error("index not found in meta table", + zap.Error(err), + zap.Int64("indexID", indexID), + zap.Int64("collection", collectionID), + zap.Int64("segment", segID)) + return err + } + t.Rsp.SegmentInfos[segID].ExtraIndexInfos[indexID] = extraIndexInfo + } + } + + return nil +} + // CreateIndexReqTask create index request task type CreateIndexReqTask struct { baseReqTask diff --git a/internal/rootcoord/task_test.go b/internal/rootcoord/task_test.go new file mode 100644 index 0000000000..a685482cd3 --- /dev/null +++ b/internal/rootcoord/task_test.go @@ -0,0 +1,115 @@ +package rootcoord + +import ( + "context" + "errors" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/milvus-io/milvus/internal/proto/etcdpb" + "github.com/milvus-io/milvus/internal/util/typeutil" + + "github.com/milvus-io/milvus/internal/proto/commonpb" + "github.com/milvus-io/milvus/internal/proto/rootcoordpb" +) + +func TestDescribeSegmentReqTask_Type(t *testing.T) { + tsk := &DescribeSegmentsReqTask{ + Req: &rootcoordpb.DescribeSegmentsRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DescribeSegments, + }, + }, + } + assert.Equal(t, commonpb.MsgType_DescribeSegments, tsk.Type()) +} + +func TestDescribeSegmentsReqTask_Execute(t *testing.T) { + collID := typeutil.UniqueID(1) + partID := typeutil.UniqueID(2) + segID := typeutil.UniqueID(100) + fieldID := typeutil.UniqueID(3) + buildID := typeutil.UniqueID(4) + indexID := typeutil.UniqueID(1000) + indexName := "test_describe_segments_index" + + c := &Core{} + + // failed to get flushed segments. + c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) { + return nil, errors.New("mock") + } + tsk := &DescribeSegmentsReqTask{ + baseReqTask: baseReqTask{ + core: c, + }, + Req: &rootcoordpb.DescribeSegmentsRequest{ + Base: &commonpb.MsgBase{ + MsgType: commonpb.MsgType_DescribeSegments, + }, + CollectionID: collID, + SegmentIDs: []typeutil.UniqueID{segID}, + }, + Rsp: &rootcoordpb.DescribeSegmentsResponse{}, + } + assert.Error(t, tsk.Execute(context.Background())) + + // requested segment not found in flushed segments. + c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) { + return []typeutil.UniqueID{}, nil + } + assert.Error(t, tsk.Execute(context.Background())) + + // segment not found in meta. + c.CallGetFlushedSegmentsService = func(ctx context.Context, collID, partID typeutil.UniqueID) ([]typeutil.UniqueID, error) { + return []typeutil.UniqueID{segID}, nil + } + c.MetaTable = &MetaTable{ + segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{}, + } + assert.NoError(t, tsk.Execute(context.Background())) + + // index not found in meta. + c.MetaTable = &MetaTable{ + segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{ + segID: { + indexID: { + CollectionID: collID, + PartitionID: partID, + SegmentID: segID, + FieldID: fieldID, + IndexID: indexID, + BuildID: buildID, + EnableIndex: true, + }, + }, + }, + } + assert.Error(t, tsk.Execute(context.Background())) + + // success. + c.MetaTable = &MetaTable{ + segID2IndexMeta: map[typeutil.UniqueID]map[typeutil.UniqueID]etcdpb.SegmentIndexInfo{ + segID: { + indexID: { + CollectionID: collID, + PartitionID: partID, + SegmentID: segID, + FieldID: fieldID, + IndexID: indexID, + BuildID: buildID, + EnableIndex: true, + }, + }, + }, + indexID2Meta: map[typeutil.UniqueID]etcdpb.IndexInfo{ + indexID: { + IndexName: indexName, + IndexID: indexID, + IndexParams: nil, + }, + }, + } + assert.NoError(t, tsk.Execute(context.Background())) +} diff --git a/internal/storage/data_codec.go b/internal/storage/data_codec.go index 83a5758945..3d1d8e87fb 100644 --- a/internal/storage/data_codec.go +++ b/internal/storage/data_codec.go @@ -1071,6 +1071,57 @@ func NewIndexFileBinlogCodec() *IndexFileBinlogCodec { return &IndexFileBinlogCodec{} } +func (codec *IndexFileBinlogCodec) serializeImpl( + indexBuildID UniqueID, + version int64, + collectionID UniqueID, + partitionID UniqueID, + segmentID UniqueID, + fieldID UniqueID, + indexName string, + indexID UniqueID, + key string, + value []byte, + ts Timestamp, +) (*Blob, error) { + writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, key) + defer writer.Close() + + eventWriter, err := writer.NextIndexFileEventWriter() + if err != nil { + return nil, err + } + defer eventWriter.Close() + + err = eventWriter.AddByteToPayload(value) + if err != nil { + return nil, err + } + + eventWriter.SetEventTimestamp(ts, ts) + + writer.SetEventTimeStamp(ts, ts) + + // https://github.com/milvus-io/milvus/issues/9620 + // len(params) is also not accurate, indexParams is a map + writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(value))) + + err = writer.Finish() + if err != nil { + return nil, err + } + buffer, err := writer.GetBuffer() + if err != nil { + return nil, err + } + + return &Blob{ + Key: key, + //Key: strconv.Itoa(len(datas)), + Value: buffer, + }, nil +} + // Serialize serilizes data as blobs. func (codec *IndexFileBinlogCodec) Serialize( indexBuildID UniqueID, @@ -1091,94 +1142,22 @@ func (codec *IndexFileBinlogCodec) Serialize( ts := Timestamp(time.Now().UnixNano()) - for pos := range datas { - writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, datas[pos].Key) - - // https://github.com/milvus-io/milvus/issues/9449 - // store index parameters to extra, in bytes format. - params, _ := json.Marshal(indexParams) - writer.descriptorEvent.AddExtra(IndexParamsKey, params) - - eventWriter, err := writer.NextIndexFileEventWriter() - if err != nil { - writer.Close() - return nil, err - } - - err = eventWriter.AddByteToPayload(datas[pos].Value) - if err != nil { - eventWriter.Close() - writer.Close() - return nil, err - } - - eventWriter.SetEventTimestamp(ts, ts) - - writer.SetEventTimeStamp(ts, ts) - - // https://github.com/milvus-io/milvus/issues/9620 - writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(datas[pos].Value))) - - err = writer.Finish() - if err != nil { - eventWriter.Close() - writer.Close() - return nil, err - } - buffer, err := writer.GetBuffer() - if err != nil { - eventWriter.Close() - writer.Close() - return nil, err - } - - blobs = append(blobs, &Blob{ - Key: datas[pos].Key, - //Key: strconv.Itoa(pos), - Value: buffer, - }) - eventWriter.Close() - writer.Close() - } - - // save index params - writer := NewIndexFileBinlogWriter(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, IndexParamsKey) - eventWriter, err := writer.NextIndexFileEventWriter() - if err != nil { - writer.Close() - return nil, err - } - defer writer.Close() - defer eventWriter.Close() - + // save index params. + // querycoord will parse index extra info from binlog, better to let this key appear first. params, _ := json.Marshal(indexParams) - err = eventWriter.AddByteToPayload(params) + indexParamBlob, err := codec.serializeImpl(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, IndexParamsKey, params, ts) if err != nil { return nil, err } + blobs = append(blobs, indexParamBlob) - eventWriter.SetEventTimestamp(ts, ts) - - writer.SetEventTimeStamp(ts, ts) - - // https://github.com/milvus-io/milvus/issues/9620 - // len(params) is also not accurate, indexParams is a map - writer.AddExtra(originalSizeKey, fmt.Sprintf("%v", len(params))) - - err = writer.Finish() - if err != nil { - return nil, err + for pos := range datas { + blob, err := codec.serializeImpl(indexBuildID, version, collectionID, partitionID, segmentID, fieldID, indexName, indexID, datas[pos].Key, datas[pos].Value, ts) + if err != nil { + return nil, err + } + blobs = append(blobs, blob) } - buffer, err := writer.GetBuffer() - if err != nil { - return nil, err - } - - blobs = append(blobs, &Blob{ - Key: IndexParamsKey, - //Key: strconv.Itoa(len(datas)), - Value: buffer, - }) return blobs, nil } diff --git a/internal/types/types.go b/internal/types/types.go index a61608626e..1c1f937a98 100644 --- a/internal/types/types.go +++ b/internal/types/types.go @@ -569,6 +569,8 @@ type RootCoord interface { // error is always nil ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) + DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error) + // ReleaseDQLMessageStream notifies RootCoord to release and close the search message stream of specific collection. // // ctx is the request to control request deadline and cancellation. diff --git a/internal/util/funcutil/func.go b/internal/util/funcutil/func.go index c4101dd10a..3be8582784 100644 --- a/internal/util/funcutil/func.go +++ b/internal/util/funcutil/func.go @@ -17,7 +17,9 @@ package funcutil import ( + "bytes" "context" + "encoding/binary" "encoding/json" "errors" "fmt" @@ -344,3 +346,9 @@ func GetNumRowOfFieldData(fieldData *schemapb.FieldData) (uint64, error) { return fieldNumRows, nil } + +// ReadBinary read byte slice as receiver. +func ReadBinary(endian binary.ByteOrder, bs []byte, receiver interface{}) error { + buf := bytes.NewReader(bs) + return binary.Read(buf, endian, receiver) +} diff --git a/internal/util/funcutil/func_test.go b/internal/util/funcutil/func_test.go index 902bdae7aa..6f6cc151b0 100644 --- a/internal/util/funcutil/func_test.go +++ b/internal/util/funcutil/func_test.go @@ -18,6 +18,7 @@ package funcutil import ( "context" + "encoding/binary" "encoding/json" "errors" "fmt" @@ -399,3 +400,66 @@ func TestGetNumRowsOfBinaryVectorField(t *testing.T) { } } } + +func Test_ReadBinary(t *testing.T) { + // TODO: test big endian. + // low byte in high address, high byte in low address. + endian := binary.LittleEndian + var bs []byte + + bs = []byte{0x1f} + var i8 int8 + var expectedI8 int8 = 0x1f + assert.NoError(t, ReadBinary(endian, bs, &i8)) + assert.Equal(t, expectedI8, i8) + + bs = []byte{0xff, 0x1f} + var i16 int16 + var expectedI16 int16 = 0x1fff + assert.NoError(t, ReadBinary(endian, bs, &i16)) + assert.Equal(t, expectedI16, i16) + + bs = []byte{0xff, 0xff, 0xff, 0x1f} + var i32 int32 + var expectedI32 int32 = 0x1fffffff + assert.NoError(t, ReadBinary(endian, bs, &i32)) + assert.Equal(t, expectedI32, i32) + + bs = []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f} + var i64 int64 + var expectedI64 int64 = 0x1fffffffffffffff + assert.NoError(t, ReadBinary(endian, bs, &i64)) + assert.Equal(t, expectedI64, i64) + + // hard to compare float-pointing value. + + bs = []byte{0, 0, 0, 0} + var f float32 + // var expectedF32 float32 = 0 + var expectedF32 float32 + assert.NoError(t, ReadBinary(endian, bs, &f)) + assert.Equal(t, expectedF32, f) + + bs = []byte{0, 0, 0, 0, 0, 0, 0, 0} + var d float64 + // var expectedF64 float64 = 0 + var expectedF64 float64 + assert.NoError(t, ReadBinary(endian, bs, &d)) + assert.Equal(t, expectedF64, d) + + bs = []byte{0} + var fb bool + assert.NoError(t, ReadBinary(endian, bs, &fb)) + assert.False(t, fb) + + bs = []byte{1} + var tb bool + assert.NoError(t, ReadBinary(endian, bs, &tb)) + assert.True(t, tb) + + // float vector + bs = []byte{0, 0, 0, 0, 0, 0, 0, 0} + var fs = make([]float32, 2) + assert.NoError(t, ReadBinary(endian, bs, &fs)) + assert.ElementsMatch(t, []float32{0, 0}, fs) +} diff --git a/internal/util/mock/rootcoord_client.go b/internal/util/mock/rootcoord_client.go index 2930c60213..11ca4ddb65 100644 --- a/internal/util/mock/rootcoord_client.go +++ b/internal/util/mock/rootcoord_client.go @@ -99,6 +99,10 @@ func (m *RootCoordClient) ShowSegments(ctx context.Context, in *milvuspb.ShowSeg return &milvuspb.ShowSegmentsResponse{}, m.Err } +func (m *RootCoordClient) DescribeSegments(ctx context.Context, in *rootcoordpb.DescribeSegmentsRequest, opts ...grpc.CallOption) (*rootcoordpb.DescribeSegmentsResponse, error) { + return &rootcoordpb.DescribeSegmentsResponse{}, m.Err +} + func (m *RootCoordClient) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) { return &commonpb.Status{}, m.Err }