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

Add support for loading multiple indexes (#16138) 

Signed-off-by: dragondriver <jiquan.long@zilliz.com>
pull/16235/head^2
Jiquan Long 2022-03-30 21:11:28 +08:00 committed by GitHub
parent 0f53989f17
commit ba37531456
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
40 changed files with 2365 additions and 637 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
internal/core/src/pb/common.pb.cc
View File

@ -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:

1
internal/core/src/pb/common.pb.h
View File

@ -233,6 +233,7 @@ enum MsgType : int {
ReleaseSegments = 253,
HandoffSegments = 254,
LoadBalanceSegments = 255,
DescribeSegments = 256,
CreateIndex = 300,
DescribeIndex = 301,
DropIndex = 302,

4
internal/datacoord/mock_test.go
View File

@ -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{

4
internal/distributed/proxy/service_test.go
View File

@ -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
}

13
internal/distributed/rootcoord/client/client.go
View File

@ -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) {

4
internal/distributed/rootcoord/service.go
View File

@ -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)

10
internal/metrics/rootcoord_metrics.go
View File

@ -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)

1
internal/proto/common.proto
View File

@ -114,6 +114,7 @@ enum MsgType {
ReleaseSegments = 253;
HandoffSegments = 254;
LoadBalanceSegments = 255;
DescribeSegments = 256;
/* DEFINITION REQUESTS: INDEX */
CreateIndex = 300;

200
internal/proto/commonpb/common.pb.go
View File

@ -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,
}

6
internal/proto/query_coord.proto
View File

@ -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;
}

392
internal/proto/querypb/query_coord.pb.go
View File

@ -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.

30
internal/proto/root_coord.proto
View File

@ -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.
}
}
// 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<int64, etcd.IndexInfo> extra_index_infos = 3; // index_id -> IndexInfo{index_name, index_id, index_params}
}
message DescribeSegmentsResponse {
common.Status status = 1;
int64 collectionID = 2;
map<int64, SegmentInfos> segment_infos = 3; // segment_id -> segment infos
}

411
internal/proto/rootcoordpb/root_coord.pb.go
View File

@ -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,

4
internal/proxy/rootcoord_mock_test.go
View File

@ -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 {

161
internal/querycoord/global_meta_broker.go
View File

@ -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,

8
internal/querycoord/index_checker.go
View File

@ -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

41
internal/querycoord/mock_3rd_component_test.go
View File

@ -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

2
internal/querycoord/util.go
View File

@ -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

33
internal/querynode/collection_replica.go
View File

@ -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
}

6
internal/querynode/collection_replica_test.go
View File

@ -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)

2
internal/querynode/historical.go
View File

@ -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)

4
internal/querynode/impl_test.go
View File

@ -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),

2
internal/querynode/load_index_info.go
View File

@ -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

2
internal/querynode/load_index_info_test.go
View File

@ -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,

144
internal/querynode/mock_test.go
View File

@ -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)
}

289
internal/querynode/segment.go
View File

@ -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 {

40
internal/querynode/segment_loader.go
View File

@ -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
}

6
internal/querynode/segment_loader_test.go
View File

@ -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)

512
internal/querynode/segment_test.go
View File

@ -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))
}

12
internal/rootcoord/meta_table.go
View File

@ -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()

33
internal/rootcoord/meta_table_test.go
View File

@ -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())
}

58
internal/rootcoord/root_coord.go
View File

@ -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()

85
internal/rootcoord/root_coord_test.go
View File

@ -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)
}

83
internal/rootcoord/task.go
View File

@ -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

115
internal/rootcoord/task_test.go Normal file
View File

@ -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()))
}

143
internal/storage/data_codec.go
View File

@ -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
}

2
internal/types/types.go
View File

@ -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.

8
internal/util/funcutil/func.go
View File

@ -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)
}

64
internal/util/funcutil/func_test.go
View File

@ -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)
}

4
internal/util/mock/rootcoord_client.go
View File

@ -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
}