From b063bfda8f8773e960b8297310c4fc76ae9a193b Mon Sep 17 00:00:00 2001 From: xige-16 Date: Thu, 30 Dec 2021 19:09:33 +0800 Subject: [PATCH] Add index info in loadSegmentRequest (#14524) Signed-off-by: xige-16 --- internal/proto/query_coord.proto | 19 +- internal/proto/querypb/query_coord.pb.go | 482 +++++++++++------- internal/querycoord/cluster.go | 38 +- internal/querycoord/cluster_test.go | 53 +- internal/querycoord/index_checker.go | 101 ++-- .../querycoord/mock_3rd_component_test.go | 5 +- internal/querycoord/query_coord.go | 3 +- internal/querycoord/task.go | 31 +- internal/querycoord/util.go | 13 + 9 files changed, 409 insertions(+), 336 deletions(-) diff --git a/internal/proto/query_coord.proto b/internal/proto/query_coord.proto index a479a46c08..9ddb9d972b 100644 --- a/internal/proto/query_coord.proto +++ b/internal/proto/query_coord.proto @@ -9,7 +9,6 @@ import "milvus.proto"; import "internal.proto"; import "schema.proto"; import "data_coord.proto"; -import "index_coord.proto"; service QueryCoord { rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {} @@ -190,8 +189,19 @@ message SegmentLoadInfo { repeated data.FieldBinlog statslogs = 8; repeated data.FieldBinlog deltalogs = 9; repeated int64 compactionFrom = 10; // segmentIDs compacted from - bool enable_index = 11; - repeated index.IndexFilePathInfo index_path_infos = 12; + repeated VecFieldIndexInfo index_infos = 11; + int64 segment_size = 12; +} + +message VecFieldIndexInfo { + int64 fieldID =1; + bool enable_index = 2; + string index_name = 3; + int64 indexID = 4; + int64 buildID = 5; + repeated common.KeyValuePair index_params = 6; + repeated string index_file_paths = 7; + int64 index_size = 8; } message LoadSegmentsRequest { @@ -285,8 +295,7 @@ message SegmentInfo { repeated int64 compactionFrom = 10; bool createdByCompaction = 11; common.SegmentState segment_state = 12; - bool enable_index = 13; - repeated index.IndexFilePathInfo index_path_infos = 14; + repeated VecFieldIndexInfo index_infos = 13; } message CollectionInfo { diff --git a/internal/proto/querypb/query_coord.pb.go b/internal/proto/querypb/query_coord.pb.go index a3c8606f8c..51530b3c84 100644 --- a/internal/proto/querypb/query_coord.pb.go +++ b/internal/proto/querypb/query_coord.pb.go @@ -9,7 +9,6 @@ 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" - indexpb "github.com/milvus-io/milvus/internal/proto/indexpb" internalpb "github.com/milvus-io/milvus/internal/proto/internalpb" milvuspb "github.com/milvus-io/milvus/internal/proto/milvuspb" schemapb "github.com/milvus-io/milvus/internal/proto/schemapb" @@ -1255,21 +1254,21 @@ func (m *WatchDeltaChannelsRequest) GetInfos() []*datapb.VchannelInfo { } type SegmentLoadInfo struct { - SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` - PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"` - CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"` - DbID int64 `protobuf:"varint,4,opt,name=dbID,proto3" json:"dbID,omitempty"` - FlushTime int64 `protobuf:"varint,5,opt,name=flush_time,json=flushTime,proto3" json:"flush_time,omitempty"` - BinlogPaths []*datapb.FieldBinlog `protobuf:"bytes,6,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"` - NumOfRows int64 `protobuf:"varint,7,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"` - 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"` - EnableIndex bool `protobuf:"varint,11,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"` - IndexPathInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,12,rep,name=index_path_infos,json=indexPathInfos,proto3" json:"index_path_infos,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` + PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + DbID int64 `protobuf:"varint,4,opt,name=dbID,proto3" json:"dbID,omitempty"` + FlushTime int64 `protobuf:"varint,5,opt,name=flush_time,json=flushTime,proto3" json:"flush_time,omitempty"` + BinlogPaths []*datapb.FieldBinlog `protobuf:"bytes,6,rep,name=binlog_paths,json=binlogPaths,proto3" json:"binlog_paths,omitempty"` + NumOfRows int64 `protobuf:"varint,7,opt,name=num_of_rows,json=numOfRows,proto3" json:"num_of_rows,omitempty"` + 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"` + SegmentSize int64 `protobuf:"varint,12,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *SegmentLoadInfo) Reset() { *m = SegmentLoadInfo{} } @@ -1367,20 +1366,115 @@ func (m *SegmentLoadInfo) GetCompactionFrom() []int64 { return nil } -func (m *SegmentLoadInfo) GetEnableIndex() bool { +func (m *SegmentLoadInfo) GetIndexInfos() []*VecFieldIndexInfo { + if m != nil { + return m.IndexInfos + } + return nil +} + +func (m *SegmentLoadInfo) GetSegmentSize() int64 { + if m != nil { + return m.SegmentSize + } + return 0 +} + +type VecFieldIndexInfo 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"` + IndexID int64 `protobuf:"varint,4,opt,name=indexID,proto3" json:"indexID,omitempty"` + BuildID int64 `protobuf:"varint,5,opt,name=buildID,proto3" json:"buildID,omitempty"` + IndexParams []*commonpb.KeyValuePair `protobuf:"bytes,6,rep,name=index_params,json=indexParams,proto3" json:"index_params,omitempty"` + IndexFilePaths []string `protobuf:"bytes,7,rep,name=index_file_paths,json=indexFilePaths,proto3" json:"index_file_paths,omitempty"` + IndexSize int64 `protobuf:"varint,8,opt,name=index_size,json=indexSize,proto3" json:"index_size,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + 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) { + return fileDescriptor_aab7cc9a69ed26e8, []int{19} +} + +func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_VecFieldIndexInfo.Unmarshal(m, b) +} +func (m *VecFieldIndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_VecFieldIndexInfo.Marshal(b, m, deterministic) +} +func (m *VecFieldIndexInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_VecFieldIndexInfo.Merge(m, src) +} +func (m *VecFieldIndexInfo) XXX_Size() int { + return xxx_messageInfo_VecFieldIndexInfo.Size(m) +} +func (m *VecFieldIndexInfo) XXX_DiscardUnknown() { + xxx_messageInfo_VecFieldIndexInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_VecFieldIndexInfo proto.InternalMessageInfo + +func (m *VecFieldIndexInfo) GetFieldID() int64 { + if m != nil { + return m.FieldID + } + return 0 +} + +func (m *VecFieldIndexInfo) GetEnableIndex() bool { if m != nil { return m.EnableIndex } return false } -func (m *SegmentLoadInfo) GetIndexPathInfos() []*indexpb.IndexFilePathInfo { +func (m *VecFieldIndexInfo) GetIndexName() string { if m != nil { - return m.IndexPathInfos + return m.IndexName + } + return "" +} + +func (m *VecFieldIndexInfo) GetIndexID() int64 { + if m != nil { + return m.IndexID + } + return 0 +} + +func (m *VecFieldIndexInfo) GetBuildID() int64 { + if m != nil { + return m.BuildID + } + return 0 +} + +func (m *VecFieldIndexInfo) GetIndexParams() []*commonpb.KeyValuePair { + if m != nil { + return m.IndexParams } return nil } +func (m *VecFieldIndexInfo) GetIndexFilePaths() []string { + if m != nil { + return m.IndexFilePaths + } + return nil +} + +func (m *VecFieldIndexInfo) GetIndexSize() int64 { + if m != nil { + return m.IndexSize + } + return 0 +} + type LoadSegmentsRequest struct { Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` DstNodeID int64 `protobuf:"varint,2,opt,name=dst_nodeID,json=dstNodeID,proto3" json:"dst_nodeID,omitempty"` @@ -1397,7 +1491,7 @@ func (m *LoadSegmentsRequest) Reset() { *m = LoadSegmentsRequest{} } func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*LoadSegmentsRequest) ProtoMessage() {} func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{19} + return fileDescriptor_aab7cc9a69ed26e8, []int{20} } func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -1477,7 +1571,7 @@ func (m *ReleaseSegmentsRequest) Reset() { *m = ReleaseSegmentsRequest{} func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*ReleaseSegmentsRequest) ProtoMessage() {} func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{20} + return fileDescriptor_aab7cc9a69ed26e8, []int{21} } func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -1553,7 +1647,7 @@ func (m *HandoffSegmentsRequest) Reset() { *m = HandoffSegmentsRequest{} func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) } func (*HandoffSegmentsRequest) ProtoMessage() {} func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{21} + return fileDescriptor_aab7cc9a69ed26e8, []int{22} } func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error { @@ -1603,7 +1697,7 @@ func (m *LoadBalanceRequest) Reset() { *m = LoadBalanceRequest{} } func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) } func (*LoadBalanceRequest) ProtoMessage() {} func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{22} + return fileDescriptor_aab7cc9a69ed26e8, []int{23} } func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error { @@ -1672,7 +1766,7 @@ func (m *DmChannelWatchInfo) Reset() { *m = DmChannelWatchInfo{} } func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) } func (*DmChannelWatchInfo) ProtoMessage() {} func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{23} + return fileDescriptor_aab7cc9a69ed26e8, []int{24} } func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error { @@ -1729,7 +1823,7 @@ func (m *QueryChannelInfo) Reset() { *m = QueryChannelInfo{} } func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) } func (*QueryChannelInfo) ProtoMessage() {} func (*QueryChannelInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{24} + return fileDescriptor_aab7cc9a69ed26e8, []int{25} } func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error { @@ -1798,7 +1892,7 @@ func (m *PartitionStates) Reset() { *m = PartitionStates{} } func (m *PartitionStates) String() string { return proto.CompactTextString(m) } func (*PartitionStates) ProtoMessage() {} func (*PartitionStates) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{25} + return fileDescriptor_aab7cc9a69ed26e8, []int{26} } func (m *PartitionStates) XXX_Unmarshal(b []byte) error { @@ -1841,30 +1935,29 @@ func (m *PartitionStates) GetInMemoryPercentage() int64 { } type SegmentInfo struct { - SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` - CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"` - PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"` - NodeID int64 `protobuf:"varint,4,opt,name=nodeID,proto3" json:"nodeID,omitempty"` - MemSize int64 `protobuf:"varint,5,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"` - NumRows int64 `protobuf:"varint,6,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"` - IndexName string `protobuf:"bytes,7,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"` - IndexID int64 `protobuf:"varint,8,opt,name=indexID,proto3" json:"indexID,omitempty"` - DmChannel string `protobuf:"bytes,9,opt,name=dmChannel,proto3" json:"dmChannel,omitempty"` - 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"` - EnableIndex bool `protobuf:"varint,13,opt,name=enable_index,json=enableIndex,proto3" json:"enable_index,omitempty"` - IndexPathInfos []*indexpb.IndexFilePathInfo `protobuf:"bytes,14,rep,name=index_path_infos,json=indexPathInfos,proto3" json:"index_path_infos,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` + CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"` + PartitionID int64 `protobuf:"varint,3,opt,name=partitionID,proto3" json:"partitionID,omitempty"` + NodeID int64 `protobuf:"varint,4,opt,name=nodeID,proto3" json:"nodeID,omitempty"` + MemSize int64 `protobuf:"varint,5,opt,name=mem_size,json=memSize,proto3" json:"mem_size,omitempty"` + NumRows int64 `protobuf:"varint,6,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"` + IndexName string `protobuf:"bytes,7,opt,name=index_name,json=indexName,proto3" json:"index_name,omitempty"` + IndexID int64 `protobuf:"varint,8,opt,name=indexID,proto3" json:"indexID,omitempty"` + DmChannel string `protobuf:"bytes,9,opt,name=dmChannel,proto3" json:"dmChannel,omitempty"` + 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"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *SegmentInfo) Reset() { *m = SegmentInfo{} } func (m *SegmentInfo) String() string { return proto.CompactTextString(m) } func (*SegmentInfo) ProtoMessage() {} func (*SegmentInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{26} + return fileDescriptor_aab7cc9a69ed26e8, []int{27} } func (m *SegmentInfo) XXX_Unmarshal(b []byte) error { @@ -1969,16 +2062,9 @@ func (m *SegmentInfo) GetSegmentState() commonpb.SegmentState { return commonpb.SegmentState_SegmentStateNone } -func (m *SegmentInfo) GetEnableIndex() bool { +func (m *SegmentInfo) GetIndexInfos() []*VecFieldIndexInfo { if m != nil { - return m.EnableIndex - } - return false -} - -func (m *SegmentInfo) GetIndexPathInfos() []*indexpb.IndexFilePathInfo { - if m != nil { - return m.IndexPathInfos + return m.IndexInfos } return nil } @@ -2000,7 +2086,7 @@ func (m *CollectionInfo) Reset() { *m = CollectionInfo{} } func (m *CollectionInfo) String() string { return proto.CompactTextString(m) } func (*CollectionInfo) ProtoMessage() {} func (*CollectionInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{27} + return fileDescriptor_aab7cc9a69ed26e8, []int{28} } func (m *CollectionInfo) XXX_Unmarshal(b []byte) error { @@ -2085,7 +2171,7 @@ func (m *SegmentChangeInfo) Reset() { *m = SegmentChangeInfo{} } func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) } func (*SegmentChangeInfo) ProtoMessage() {} func (*SegmentChangeInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{28} + return fileDescriptor_aab7cc9a69ed26e8, []int{29} } func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error { @@ -2146,7 +2232,7 @@ func (m *SealedSegmentsChangeInfo) Reset() { *m = SealedSegmentsChangeIn func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) } func (*SealedSegmentsChangeInfo) ProtoMessage() {} func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_aab7cc9a69ed26e8, []int{29} + return fileDescriptor_aab7cc9a69ed26e8, []int{30} } func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error { @@ -2204,6 +2290,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((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest") proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest") proto.RegisterType((*HandoffSegmentsRequest)(nil), "milvus.proto.query.HandoffSegmentsRequest") @@ -2220,145 +2307,150 @@ func init() { func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) } var fileDescriptor_aab7cc9a69ed26e8 = []byte{ - // 2193 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0x4d, 0x73, 0xdc, 0x48, - 0xd5, 0x9a, 0x2f, 0x7b, 0xde, 0x8c, 0x67, 0xe4, 0x4e, 0x62, 0xc6, 0x43, 0x92, 0xf5, 0x6a, 0xd7, - 0xd9, 0xe0, 0x65, 0xed, 0xe0, 0x40, 0x15, 0x5b, 0xc0, 0x21, 0xb6, 0x89, 0xd7, 0xec, 0xc6, 0x31, - 0x63, 0x67, 0x29, 0x52, 0xa9, 0x12, 0x9a, 0x51, 0x7b, 0xac, 0x8a, 0xa4, 0x9e, 0xa8, 0x35, 0x6b, - 0x3b, 0x5c, 0x39, 0x2c, 0x07, 0x8a, 0x3f, 0x40, 0x71, 0x01, 0x0a, 0x52, 0xc5, 0xfe, 0x87, 0x5c, - 0xf8, 0x1b, 0x14, 0x07, 0xf8, 0x09, 0x1c, 0xa9, 0xa2, 0xba, 0xd5, 0xd2, 0xe8, 0xa3, 0x65, 0xcb, - 0x76, 0x79, 0x93, 0xa2, 0xb8, 0x49, 0xaf, 0xdf, 0xeb, 0xf7, 0xfa, 0x7d, 0x77, 0x3f, 0x98, 0x7b, - 0x31, 0xc6, 0xde, 0x89, 0x3e, 0x20, 0xc4, 0x33, 0x57, 0x46, 0x1e, 0xf1, 0x09, 0x42, 0x8e, 0x65, - 0x7f, 0x31, 0xa6, 0xc1, 0xdf, 0x0a, 0x5f, 0xef, 0x36, 0x07, 0xc4, 0x71, 0x88, 0x1b, 0xc0, 0xba, - 0xcd, 0x38, 0x46, 0xb7, 0x65, 0xb9, 0x3e, 0xf6, 0x5c, 0xc3, 0x0e, 0x57, 0xe9, 0xe0, 0x10, 0x3b, - 0x86, 0xf8, 0x53, 0x4d, 0xc3, 0x37, 0xe2, 0xfb, 0x77, 0xe7, 0x2c, 0xd7, 0xc4, 0xc7, 0x71, 0x90, - 0xf6, 0x2b, 0x05, 0xe6, 0xf7, 0x0e, 0xc9, 0xd1, 0x06, 0xb1, 0x6d, 0x3c, 0xf0, 0x2d, 0xe2, 0xd2, - 0x1e, 0x7e, 0x31, 0xc6, 0xd4, 0x47, 0xf7, 0xa0, 0xd2, 0x37, 0x28, 0xee, 0x28, 0x8b, 0xca, 0xdd, - 0xc6, 0xda, 0xcd, 0x95, 0x84, 0x70, 0x42, 0xaa, 0x47, 0x74, 0xb8, 0x6e, 0x50, 0xdc, 0xe3, 0x98, - 0x08, 0x41, 0xc5, 0xec, 0x6f, 0x6f, 0x76, 0x4a, 0x8b, 0xca, 0xdd, 0x72, 0x8f, 0x7f, 0xa3, 0xf7, - 0x61, 0x76, 0x10, 0xed, 0xbd, 0xbd, 0x49, 0x3b, 0xe5, 0xc5, 0xf2, 0xdd, 0x72, 0x2f, 0x09, 0xd4, - 0xfe, 0xac, 0xc0, 0x37, 0x32, 0x62, 0xd0, 0x11, 0x71, 0x29, 0x46, 0xf7, 0xa1, 0x46, 0x7d, 0xc3, - 0x1f, 0x53, 0x21, 0xc9, 0x37, 0xa5, 0x92, 0xec, 0x71, 0x94, 0x9e, 0x40, 0xcd, 0xb2, 0x2d, 0x49, - 0xd8, 0xa2, 0xef, 0xc0, 0x75, 0xcb, 0x7d, 0x84, 0x1d, 0xe2, 0x9d, 0xe8, 0x23, 0xec, 0x0d, 0xb0, - 0xeb, 0x1b, 0x43, 0x1c, 0xca, 0x78, 0x2d, 0x5c, 0xdb, 0x9d, 0x2c, 0x69, 0x7f, 0x52, 0xe0, 0x06, - 0x93, 0x74, 0xd7, 0xf0, 0x7c, 0xeb, 0x0a, 0xf4, 0xa5, 0x41, 0x33, 0x2e, 0x63, 0xa7, 0xcc, 0xd7, - 0x12, 0x30, 0x86, 0x33, 0x0a, 0xd9, 0xb3, 0xb3, 0x55, 0xb8, 0xb8, 0x09, 0x98, 0xf6, 0x47, 0x61, - 0xd8, 0xb8, 0x9c, 0x97, 0x51, 0x68, 0x9a, 0x67, 0x29, 0xcb, 0xf3, 0x22, 0xea, 0x7c, 0xad, 0xc0, - 0x8d, 0xcf, 0x88, 0x61, 0x4e, 0x0c, 0xff, 0xf5, 0xab, 0xf3, 0x47, 0x50, 0x0b, 0x02, 0xa7, 0x53, - 0xe1, 0xbc, 0x96, 0x92, 0xbc, 0x44, 0x50, 0x4d, 0x24, 0xdc, 0xe3, 0x80, 0x9e, 0x20, 0xd2, 0x7e, - 0xa7, 0x40, 0xa7, 0x87, 0x6d, 0x6c, 0x50, 0xfc, 0x26, 0x4f, 0x31, 0x0f, 0x35, 0x97, 0x98, 0x78, - 0x7b, 0x93, 0x9f, 0xa2, 0xdc, 0x13, 0x7f, 0xda, 0x3f, 0x85, 0x86, 0xdf, 0x72, 0x87, 0x8d, 0x59, - 0xa1, 0x7a, 0x11, 0x2b, 0xbc, 0x9e, 0x58, 0xe1, 0x6d, 0x3f, 0xe9, 0xc4, 0x52, 0xd5, 0x84, 0xa5, - 0x7e, 0x0e, 0x0b, 0x1b, 0x1e, 0x36, 0x7c, 0xfc, 0x53, 0x96, 0xf9, 0x37, 0x0e, 0x0d, 0xd7, 0xc5, - 0x76, 0x78, 0x84, 0x34, 0x73, 0x45, 0xc2, 0xbc, 0x03, 0xd3, 0x23, 0x8f, 0x1c, 0x9f, 0x44, 0x72, - 0x87, 0xbf, 0xda, 0x5f, 0x14, 0xe8, 0xca, 0xf6, 0xbe, 0x4c, 0x46, 0x78, 0x0f, 0x66, 0x45, 0x09, - 0x0b, 0x76, 0xe3, 0x3c, 0xeb, 0xbd, 0xe6, 0x8b, 0x18, 0x07, 0x74, 0x0f, 0xae, 0x07, 0x48, 0x1e, - 0xa6, 0x63, 0xdb, 0x8f, 0x70, 0xcb, 0x1c, 0x17, 0xf1, 0xb5, 0x1e, 0x5f, 0x12, 0x14, 0xda, 0x2b, - 0x05, 0x16, 0xb6, 0xb0, 0x1f, 0x19, 0x91, 0x71, 0xc5, 0x6f, 0x69, 0x92, 0xfd, 0x4a, 0x81, 0xae, - 0x4c, 0xd6, 0xcb, 0xa8, 0xf5, 0x29, 0xcc, 0x47, 0x3c, 0x74, 0x13, 0xd3, 0x81, 0x67, 0x8d, 0xb8, - 0x33, 0xf3, 0x94, 0xdb, 0x58, 0x7b, 0x6f, 0x25, 0xdb, 0x25, 0xac, 0xa4, 0x25, 0xb8, 0x11, 0x6d, - 0xb1, 0x19, 0xdb, 0x41, 0xfb, 0x8d, 0x02, 0x37, 0xb6, 0xb0, 0xbf, 0x87, 0x87, 0x0e, 0x76, 0xfd, - 0x6d, 0xf7, 0x80, 0x5c, 0x5c, 0xaf, 0xb7, 0x01, 0xa8, 0xd8, 0x27, 0x2a, 0x07, 0x31, 0x48, 0x11, - 0x1d, 0xf3, 0xee, 0x23, 0x2d, 0xcf, 0x65, 0x74, 0xf7, 0x3d, 0xa8, 0x5a, 0xee, 0x01, 0x09, 0x55, - 0xf5, 0x8e, 0x4c, 0x55, 0x71, 0x66, 0x01, 0xb6, 0xf6, 0x9f, 0x12, 0xcc, 0x3f, 0x30, 0x4d, 0x59, - 0xd8, 0x9d, 0x5f, 0x2f, 0x93, 0xe8, 0x2e, 0xc5, 0xa3, 0xbb, 0x90, 0xcf, 0x65, 0x42, 0xaa, 0x72, - 0x8e, 0x90, 0xaa, 0xe6, 0x85, 0x14, 0xda, 0x82, 0x59, 0x8a, 0xf1, 0x73, 0x7d, 0x44, 0x28, 0xf7, - 0x89, 0x4e, 0x8d, 0x9f, 0x46, 0x4b, 0x9e, 0x26, 0x6a, 0x26, 0x1f, 0xd1, 0xe1, 0xae, 0xc0, 0xec, - 0x35, 0x19, 0x61, 0xf8, 0x87, 0x9e, 0xc0, 0xfc, 0xd0, 0x26, 0x7d, 0xc3, 0xd6, 0x29, 0x36, 0x6c, - 0x6c, 0xea, 0xc2, 0xde, 0xb4, 0x33, 0x5d, 0x4c, 0xe1, 0xd7, 0x03, 0xf2, 0x3d, 0x4e, 0x2d, 0x16, - 0xa8, 0xf6, 0x0f, 0x05, 0x16, 0x7a, 0xd8, 0x21, 0x5f, 0xe0, 0xff, 0x55, 0x13, 0x68, 0xff, 0x2a, - 0xc1, 0xfc, 0xcf, 0x0c, 0x7f, 0x70, 0xb8, 0xe9, 0x08, 0x10, 0x7d, 0x33, 0xe7, 0x2b, 0x52, 0xa0, - 0xa2, 0x30, 0xaa, 0xca, 0xac, 0xca, 0xae, 0x15, 0x2b, 0x9f, 0x8b, 0x23, 0xc7, 0xc2, 0x28, 0x56, - 0xc1, 0x6b, 0x17, 0xa8, 0xe0, 0x68, 0x03, 0x66, 0xf1, 0xf1, 0xc0, 0x1e, 0x9b, 0x58, 0x0f, 0xb8, - 0x07, 0x3e, 0x75, 0x5b, 0xc2, 0x3d, 0xee, 0x52, 0x4d, 0x41, 0xb4, 0xcd, 0x43, 0xf9, 0xb5, 0x02, - 0x0b, 0x81, 0x9e, 0xb1, 0xed, 0x1b, 0x6f, 0x56, 0xd5, 0x91, 0x1a, 0x2b, 0xe7, 0x51, 0xa3, 0xf6, - 0x87, 0x0a, 0xb4, 0xc5, 0x01, 0x59, 0xdf, 0xc6, 0x96, 0xd0, 0x4d, 0xa8, 0x47, 0xa9, 0x55, 0x94, - 0xfe, 0x09, 0x00, 0x2d, 0x42, 0x23, 0x66, 0x3f, 0x21, 0x69, 0x1c, 0x54, 0x48, 0xdc, 0xb0, 0x50, - 0x56, 0x62, 0x85, 0xf2, 0x16, 0xc0, 0x81, 0x3d, 0xa6, 0x87, 0xba, 0x6f, 0x39, 0x58, 0xb4, 0x2b, - 0x75, 0x0e, 0xd9, 0xb7, 0x1c, 0x8c, 0x1e, 0x40, 0xb3, 0x6f, 0xb9, 0x36, 0x19, 0xea, 0x23, 0xc3, - 0x3f, 0xa4, 0x9d, 0x5a, 0xae, 0xc5, 0x1e, 0x5a, 0xd8, 0x36, 0xd7, 0x39, 0x6e, 0xaf, 0x11, 0xd0, - 0xec, 0x32, 0x12, 0x74, 0x1b, 0x1a, 0xee, 0xd8, 0xd1, 0xc9, 0x81, 0xee, 0x91, 0x23, 0x66, 0x73, - 0xce, 0xc2, 0x1d, 0x3b, 0x8f, 0x0f, 0x7a, 0xe4, 0x88, 0xa2, 0x1f, 0x42, 0x9d, 0x25, 0x77, 0x6a, - 0x93, 0x21, 0xed, 0xcc, 0x14, 0xda, 0x7f, 0x42, 0xc0, 0xa8, 0x4d, 0xe6, 0x08, 0x9c, 0xba, 0x5e, - 0x8c, 0x3a, 0x22, 0x40, 0x77, 0xa0, 0x35, 0x20, 0xce, 0xc8, 0xe0, 0x1a, 0x7a, 0xe8, 0x11, 0xa7, - 0x03, 0x3c, 0x5a, 0x52, 0x50, 0xf4, 0x2e, 0x34, 0xb1, 0x6b, 0xf4, 0x6d, 0xe6, 0xb8, 0x26, 0x3e, - 0xee, 0x34, 0x16, 0x95, 0xbb, 0x33, 0xbd, 0x46, 0x00, 0xdb, 0x66, 0x20, 0xf4, 0x18, 0xd4, 0xe0, - 0xf2, 0xcd, 0x14, 0x25, 0xfc, 0xbb, 0xc9, 0xe5, 0x59, 0x4a, 0x67, 0x61, 0x13, 0x1f, 0xaf, 0x70, - 0xa2, 0x87, 0x96, 0x8d, 0x99, 0x92, 0xb8, 0x73, 0xb4, 0xf8, 0x42, 0xf8, 0x4b, 0xb5, 0x57, 0x25, - 0xb8, 0xc6, 0xdc, 0x23, 0x4c, 0xa2, 0x17, 0x77, 0xf1, 0x5b, 0x00, 0x26, 0xf5, 0xf5, 0x84, 0x9b, - 0xd7, 0x4d, 0xea, 0xef, 0x04, 0x9e, 0xfe, 0x71, 0xe8, 0xc5, 0xe5, 0xfc, 0xf6, 0x23, 0xe5, 0xae, - 0xd9, 0x84, 0x70, 0x91, 0x8b, 0x15, 0x4b, 0xc5, 0x94, 0x8c, 0xbd, 0x01, 0xd6, 0x13, 0xed, 0x72, - 0x33, 0x00, 0xee, 0xc8, 0x03, 0xb1, 0x26, 0x69, 0x33, 0xfe, 0xae, 0xc0, 0xbc, 0xb8, 0x1b, 0x5c, - 0x5e, 0x5d, 0x79, 0x19, 0x21, 0x0c, 0x9f, 0xf2, 0x29, 0x7d, 0x66, 0xa5, 0x40, 0x42, 0xae, 0x4a, - 0x12, 0x72, 0xb2, 0xd7, 0xaa, 0xa5, 0x7b, 0x2d, 0xed, 0xb7, 0x0a, 0xcc, 0x7f, 0x62, 0xb8, 0x26, - 0x39, 0x38, 0xb8, 0xfc, 0x01, 0x37, 0xa0, 0x49, 0x27, 0xf9, 0xb5, 0x70, 0x2f, 0x95, 0x20, 0xd2, - 0xbe, 0x2c, 0x01, 0x62, 0xee, 0xb0, 0x6e, 0xd8, 0x86, 0x3b, 0xc0, 0x17, 0x97, 0x66, 0x09, 0x5a, - 0x09, 0x27, 0x88, 0x5e, 0x72, 0xe2, 0x5e, 0x40, 0xd1, 0xa7, 0xd0, 0xea, 0x07, 0xac, 0x74, 0x0f, - 0x1b, 0x94, 0xb8, 0xdc, 0x0e, 0xad, 0xb5, 0xf7, 0x65, 0x62, 0xef, 0x7b, 0xd6, 0x70, 0x88, 0xbd, - 0x0d, 0xe2, 0x9a, 0x41, 0x97, 0x33, 0xdb, 0x0f, 0xc5, 0x64, 0xa4, 0xe8, 0x1d, 0x68, 0x4c, 0x22, - 0x22, 0x2c, 0x91, 0x10, 0x85, 0x04, 0x45, 0x1f, 0xc2, 0x5c, 0xb2, 0x01, 0x9a, 0x18, 0x4e, 0xa5, - 0xf1, 0xde, 0x86, 0x19, 0xe7, 0x97, 0x80, 0xa2, 0xa2, 0xcf, 0x4b, 0x13, 0xcf, 0xe8, 0x45, 0xee, - 0x73, 0x37, 0xa1, 0x6e, 0x86, 0x94, 0xe2, 0x76, 0x35, 0x01, 0xb0, 0xf0, 0x08, 0x24, 0xd4, 0x6d, - 0x62, 0x98, 0xd8, 0x0c, 0x93, 0x7a, 0x00, 0xfc, 0x8c, 0xc3, 0xb4, 0xaf, 0x4a, 0xa0, 0xc6, 0x9b, - 0xaa, 0xc2, 0xbc, 0xaf, 0xe6, 0x76, 0x77, 0x4a, 0x07, 0x59, 0xb9, 0x44, 0x07, 0x99, 0xed, 0x70, - 0xab, 0x17, 0xeb, 0x70, 0xb5, 0xdf, 0x2b, 0xd0, 0x4e, 0x5d, 0xa6, 0xd2, 0xe5, 0x55, 0xc9, 0x96, - 0xd7, 0xef, 0x43, 0x95, 0xd5, 0x1c, 0xcc, 0x95, 0xd4, 0x4a, 0xb3, 0x95, 0x5d, 0xd1, 0x7a, 0x01, - 0x01, 0x5a, 0x85, 0x6b, 0x92, 0x27, 0x33, 0x61, 0x4a, 0x94, 0x7d, 0x31, 0xd3, 0xfe, 0x5a, 0x81, - 0x46, 0x4c, 0x1f, 0x67, 0x74, 0x06, 0x69, 0x4b, 0x97, 0x24, 0x96, 0x4e, 0x1d, 0xaf, 0x9c, 0x3d, - 0x5e, 0xce, 0xd3, 0x12, 0x5a, 0x80, 0x19, 0x07, 0x3b, 0x3a, 0xb5, 0x5e, 0x86, 0xbd, 0xc1, 0xb4, - 0x83, 0x9d, 0x3d, 0xeb, 0x25, 0x66, 0x4b, 0xac, 0xac, 0xf3, 0x9a, 0x1e, 0xa4, 0xe4, 0x69, 0x77, - 0xec, 0xf0, 0x8a, 0x7e, 0x0b, 0x20, 0x28, 0x85, 0xae, 0xe1, 0x60, 0x5e, 0xf0, 0xeb, 0xbd, 0x3a, - 0x87, 0xec, 0x18, 0x0e, 0x46, 0x1d, 0x98, 0xe6, 0x3f, 0xdb, 0x9b, 0x9d, 0x99, 0x80, 0x50, 0xfc, - 0x26, 0xc3, 0xa1, 0x9e, 0x0e, 0x87, 0xa2, 0xc5, 0xfa, 0x1e, 0x5c, 0x1b, 0xf0, 0x97, 0x10, 0x73, - 0xfd, 0x64, 0x23, 0x5a, 0x12, 0x35, 0x5b, 0xb6, 0x84, 0x1e, 0x32, 0xe7, 0xe2, 0x1a, 0xd5, 0x03, - 0x2b, 0x37, 0xb9, 0x95, 0xdf, 0x95, 0xdf, 0x48, 0x03, 0xcc, 0xc0, 0xc8, 0x61, 0x4e, 0xe4, 0x7f, - 0x99, 0x36, 0x61, 0xb6, 0x58, 0x9b, 0xd0, 0xba, 0x4c, 0x9b, 0xf0, 0x65, 0x19, 0x5a, 0x93, 0x02, - 0x5b, 0x38, 0xfa, 0x8b, 0xbc, 0xf6, 0xee, 0x80, 0x3a, 0x79, 0xa8, 0xe0, 0x8a, 0x39, 0xb5, 0x47, - 0x48, 0x3f, 0x51, 0xb4, 0x47, 0xa9, 0x30, 0xfb, 0x18, 0xea, 0x2c, 0x91, 0xe9, 0xfe, 0xc9, 0x08, - 0x73, 0x47, 0x6b, 0xa5, 0x0b, 0x44, 0xb0, 0x11, 0xcb, 0x6c, 0xfb, 0x27, 0x23, 0xdc, 0x9b, 0xb1, - 0xc5, 0xd7, 0x25, 0xdf, 0x0e, 0xd1, 0x7d, 0xb8, 0xe1, 0x05, 0xed, 0x81, 0xa9, 0x27, 0x8e, 0x1d, - 0x54, 0xda, 0xeb, 0xe1, 0xe2, 0x6e, 0xfc, 0xf8, 0x39, 0x91, 0x3b, 0x9d, 0x1b, 0xb9, 0xff, 0x56, - 0x60, 0x4e, 0x78, 0x07, 0xf3, 0xd9, 0x21, 0xbf, 0xb1, 0xb0, 0x3c, 0x4b, 0x5c, 0xdb, 0x72, 0xa3, - 0x26, 0x47, 0x98, 0x23, 0x00, 0x8a, 0x26, 0xe7, 0x13, 0x68, 0x0b, 0xa4, 0x28, 0x5d, 0x16, 0xac, - 0xca, 0xad, 0x80, 0x2e, 0x4a, 0x94, 0x4b, 0xd0, 0x22, 0x07, 0x07, 0x71, 0x7e, 0x41, 0xbc, 0xcf, - 0x0a, 0xa8, 0x60, 0xf8, 0x13, 0x50, 0x43, 0xb4, 0xf3, 0x26, 0xe8, 0xb6, 0x20, 0x8c, 0x6e, 0xf7, - 0xbf, 0x56, 0xa0, 0x93, 0x4c, 0xd7, 0xb1, 0xe3, 0x9f, 0xbf, 0x21, 0xf8, 0x41, 0xf2, 0x8d, 0x67, - 0xe9, 0x14, 0x79, 0x26, 0x7c, 0x44, 0x47, 0xba, 0xfc, 0x12, 0x5a, 0x49, 0x3f, 0x44, 0x4d, 0x98, - 0xd9, 0x21, 0xfe, 0x8f, 0x8f, 0x2d, 0xea, 0xab, 0x53, 0xa8, 0x05, 0xb0, 0x43, 0xfc, 0x5d, 0x0f, - 0x53, 0xec, 0xfa, 0xaa, 0x82, 0x00, 0x6a, 0x8f, 0xdd, 0x4d, 0x8b, 0x3e, 0x57, 0x4b, 0xe8, 0x9a, - 0xa8, 0x0c, 0x86, 0xbd, 0x2d, 0x8c, 0xab, 0x96, 0x19, 0x79, 0xf4, 0x57, 0x41, 0x2a, 0x34, 0x23, - 0x94, 0xad, 0xdd, 0x27, 0x6a, 0x15, 0xd5, 0xa1, 0x1a, 0x7c, 0xd6, 0x96, 0x4d, 0x50, 0xd3, 0x8d, - 0x07, 0xdb, 0xf3, 0x89, 0xfb, 0xa9, 0x4b, 0x8e, 0x22, 0x90, 0x3a, 0x85, 0x1a, 0x30, 0x2d, 0x9a, - 0x39, 0x55, 0x41, 0x6d, 0x68, 0xc4, 0xfa, 0x28, 0xb5, 0xc4, 0x00, 0x5b, 0xde, 0x68, 0x20, 0x3a, - 0xaa, 0x40, 0x04, 0x66, 0xb5, 0x4d, 0x72, 0xe4, 0xaa, 0x95, 0xe5, 0x07, 0x30, 0x13, 0x06, 0x08, - 0x3b, 0x4d, 0xb0, 0x3b, 0xfb, 0x53, 0xa7, 0xd0, 0x1c, 0xcc, 0x26, 0x26, 0x01, 0xaa, 0x82, 0x10, - 0xb4, 0xec, 0xc4, 0xf8, 0x45, 0x2d, 0xad, 0xfd, 0xad, 0x01, 0x10, 0xf4, 0x0c, 0x84, 0x78, 0x26, - 0x1a, 0x01, 0xda, 0xc2, 0x3e, 0xcb, 0x87, 0xc4, 0x0d, 0x73, 0x19, 0x45, 0xf7, 0x72, 0x4a, 0x6b, - 0x16, 0x55, 0x48, 0xda, 0xbd, 0x93, 0x43, 0x91, 0x42, 0xd7, 0xa6, 0x90, 0xc3, 0x39, 0xb2, 0x1b, - 0xe6, 0xbe, 0x35, 0x78, 0x1e, 0x35, 0x1b, 0xf9, 0x1c, 0x53, 0xa8, 0x21, 0xc7, 0x54, 0x1e, 0x12, - 0x3f, 0x7b, 0xbe, 0x67, 0xb9, 0xc3, 0xf0, 0xa1, 0x51, 0x9b, 0x42, 0x2f, 0xe0, 0xfa, 0x16, 0xe6, - 0xdc, 0x2d, 0xea, 0x5b, 0x03, 0x1a, 0x32, 0x5c, 0xcb, 0x67, 0x98, 0x41, 0x3e, 0x27, 0x4b, 0x1b, - 0xda, 0xa9, 0x71, 0x27, 0x5a, 0x96, 0x3a, 0xb2, 0x74, 0x34, 0xdb, 0xfd, 0xb0, 0x10, 0x6e, 0xc4, - 0xcd, 0x82, 0x56, 0x72, 0x14, 0x88, 0xbe, 0x95, 0xb7, 0x41, 0x66, 0x76, 0xd2, 0x5d, 0x2e, 0x82, - 0x1a, 0xb1, 0x7a, 0x0a, 0xad, 0xe4, 0xb0, 0x49, 0xce, 0x4a, 0x3a, 0x90, 0xea, 0x9e, 0xf6, 0xc6, - 0xab, 0x4d, 0xa1, 0x5f, 0xc0, 0x5c, 0x66, 0xc2, 0x83, 0xbe, 0x2d, 0xdb, 0x3e, 0x6f, 0x10, 0x74, - 0x16, 0x07, 0x21, 0xfd, 0x44, 0x8b, 0xf9, 0xd2, 0x67, 0x46, 0x7d, 0xc5, 0xa5, 0x8f, 0x6d, 0x7f, - 0x9a, 0xf4, 0xe7, 0xe6, 0x30, 0x06, 0x94, 0x9d, 0xf1, 0xa0, 0x8f, 0x64, 0x2c, 0x72, 0xe7, 0x4c, - 0xdd, 0x95, 0xa2, 0xe8, 0x91, 0xc9, 0xc7, 0x3c, 0x5a, 0xd3, 0x4d, 0xb3, 0x94, 0x6d, 0xee, 0x5c, - 0x47, 0xce, 0x36, 0x7f, 0xb4, 0x12, 0x38, 0x75, 0x72, 0x74, 0x20, 0xb7, 0x95, 0x74, 0xdc, 0x21, - 0x77, 0x6a, 0xf9, 0x24, 0x42, 0x9b, 0x42, 0xfb, 0x89, 0x1c, 0x8c, 0xee, 0xe4, 0xf9, 0x44, 0xf2, - 0xb2, 0x7b, 0x96, 0xb9, 0x74, 0x80, 0x2d, 0xec, 0x3f, 0xc2, 0xbe, 0x67, 0x0d, 0x68, 0x7a, 0x53, - 0xf1, 0x33, 0x41, 0x08, 0x37, 0xfd, 0xe0, 0x4c, 0xbc, 0x50, 0xec, 0xb5, 0x57, 0x00, 0x75, 0x6e, - 0x33, 0x56, 0x1e, 0xfe, 0x9f, 0xc6, 0xaf, 0x20, 0x8d, 0x3f, 0x83, 0x76, 0x6a, 0x6e, 0x24, 0x4f, - 0xe3, 0xf2, 0xe1, 0xd2, 0x59, 0x0e, 0xd2, 0x07, 0x94, 0x9d, 0x8a, 0xc8, 0x03, 0x2b, 0x77, 0x7a, - 0x72, 0x16, 0x8f, 0x67, 0xd0, 0x4e, 0x8d, 0x25, 0xe4, 0x27, 0x90, 0xcf, 0x2e, 0x0a, 0x9c, 0x20, - 0xfb, 0x18, 0x2f, 0x3f, 0x41, 0xee, 0xa3, 0xfd, 0x59, 0x3c, 0x3e, 0x87, 0x66, 0xfc, 0x1d, 0x14, - 0x7d, 0x90, 0x17, 0x9d, 0xa9, 0x97, 0xb1, 0x37, 0x9f, 0xaf, 0xaf, 0xbe, 0x9e, 0x3d, 0x83, 0x76, - 0xea, 0xdd, 0x53, 0x6e, 0x5d, 0xf9, 0xe3, 0xe8, 0x59, 0xbb, 0x7f, 0x8d, 0x19, 0xf8, 0xaa, 0x73, - 0xe5, 0xfa, 0x77, 0x9f, 0xae, 0x0d, 0x2d, 0xff, 0x70, 0xdc, 0x67, 0xa7, 0x5c, 0x0d, 0x30, 0x3f, - 0xb2, 0x88, 0xf8, 0x5a, 0x0d, 0x93, 0xc6, 0x2a, 0xdf, 0x69, 0x95, 0x4b, 0x3b, 0xea, 0xf7, 0x6b, - 0xfc, 0xf7, 0xfe, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x7f, 0xb6, 0xed, 0xcc, 0x27, 0x00, - 0x00, + // 2282 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x39, 0x4f, 0x73, 0x1b, 0x49, + 0xf5, 0x1e, 0xfd, 0xb3, 0xf5, 0x24, 0x4b, 0xe3, 0x8e, 0xed, 0x9f, 0xac, 0x5f, 0x36, 0x9b, 0x9d, + 0x5d, 0x67, 0x83, 0x97, 0xb5, 0x83, 0x03, 0x55, 0x6c, 0x01, 0x87, 0xd8, 0xc6, 0x5e, 0x93, 0x8d, + 0xd7, 0xc8, 0x4e, 0x28, 0x52, 0xa9, 0x12, 0x23, 0x4d, 0x4b, 0x9e, 0xca, 0xcc, 0xb4, 0x32, 0x3d, + 0x5a, 0xdb, 0xe1, 0xc2, 0x81, 0xc3, 0x72, 0xa0, 0xb8, 0x53, 0x14, 0x27, 0x28, 0xc8, 0x61, 0x2f, + 0x7c, 0x82, 0x5c, 0xf8, 0x1a, 0x14, 0x07, 0xf8, 0x08, 0x1c, 0xa9, 0xa2, 0xfa, 0xcf, 0x8c, 0x66, + 0x46, 0x3d, 0xb6, 0x6c, 0x97, 0x37, 0x29, 0x8a, 0xdb, 0xcc, 0xeb, 0xd7, 0xef, 0xbd, 0x7e, 0xff, + 0xbb, 0x1f, 0xcc, 0xbd, 0x18, 0x62, 0xff, 0xb4, 0xdd, 0x25, 0xc4, 0xb7, 0x56, 0x07, 0x3e, 0x09, + 0x08, 0x42, 0xae, 0xed, 0x7c, 0x31, 0xa4, 0xe2, 0x6f, 0x95, 0xaf, 0x37, 0xab, 0x5d, 0xe2, 0xba, + 0xc4, 0x13, 0xb0, 0x66, 0x35, 0x8e, 0xd1, 0xac, 0xd9, 0x5e, 0x80, 0x7d, 0xcf, 0x74, 0xc2, 0x55, + 0xda, 0x3d, 0xc2, 0xae, 0x29, 0xff, 0x74, 0xcb, 0x0c, 0xcc, 0x38, 0x7d, 0xe3, 0x97, 0x1a, 0x2c, + 0x1e, 0x1c, 0x91, 0xe3, 0x4d, 0xe2, 0x38, 0xb8, 0x1b, 0xd8, 0xc4, 0xa3, 0x2d, 0xfc, 0x62, 0x88, + 0x69, 0x80, 0xee, 0x41, 0xa1, 0x63, 0x52, 0xdc, 0xd0, 0x6e, 0x6b, 0x77, 0x2b, 0xeb, 0x37, 0x57, + 0x13, 0x92, 0x48, 0x11, 0x1e, 0xd1, 0xfe, 0x86, 0x49, 0x71, 0x8b, 0x63, 0x22, 0x04, 0x05, 0xab, + 0xb3, 0xbb, 0xd5, 0xc8, 0xdd, 0xd6, 0xee, 0xe6, 0x5b, 0xfc, 0x1b, 0x7d, 0x00, 0xb3, 0xdd, 0x88, + 0xf6, 0xee, 0x16, 0x6d, 0xe4, 0x6f, 0xe7, 0xef, 0xe6, 0x5b, 0x49, 0xa0, 0xf1, 0x27, 0x0d, 0xfe, + 0x6f, 0x4c, 0x0c, 0x3a, 0x20, 0x1e, 0xc5, 0xe8, 0x3e, 0x94, 0x68, 0x60, 0x06, 0x43, 0x2a, 0x25, + 0xf9, 0x7f, 0xa5, 0x24, 0x07, 0x1c, 0xa5, 0x25, 0x51, 0xc7, 0xd9, 0xe6, 0x14, 0x6c, 0xd1, 0xb7, + 0x60, 0xde, 0xf6, 0x1e, 0x61, 0x97, 0xf8, 0xa7, 0xed, 0x01, 0xf6, 0xbb, 0xd8, 0x0b, 0xcc, 0x3e, + 0x0e, 0x65, 0xbc, 0x11, 0xae, 0xed, 0x8f, 0x96, 0x8c, 0x3f, 0x6a, 0xb0, 0xc0, 0x24, 0xdd, 0x37, + 0xfd, 0xc0, 0xbe, 0x06, 0x7d, 0x19, 0x50, 0x8d, 0xcb, 0xd8, 0xc8, 0xf3, 0xb5, 0x04, 0x8c, 0xe1, + 0x0c, 0x42, 0xf6, 0xec, 0x6c, 0x05, 0x2e, 0x6e, 0x02, 0x66, 0xfc, 0x41, 0x1a, 0x36, 0x2e, 0xe7, + 0x55, 0x14, 0x9a, 0xe6, 0x99, 0x1b, 0xe7, 0x79, 0x19, 0x75, 0xbe, 0xd6, 0x60, 0xe1, 0x33, 0x62, + 0x5a, 0x23, 0xc3, 0x7f, 0xfd, 0xea, 0xfc, 0x01, 0x94, 0x44, 0x94, 0x34, 0x0a, 0x9c, 0xd7, 0x72, + 0x92, 0x97, 0x8c, 0xa0, 0x91, 0x84, 0x07, 0x1c, 0xd0, 0x92, 0x9b, 0x8c, 0xdf, 0x69, 0xd0, 0x68, + 0x61, 0x07, 0x9b, 0x14, 0xbf, 0xc9, 0x53, 0x2c, 0x42, 0xc9, 0x23, 0x16, 0xde, 0xdd, 0xe2, 0xa7, + 0xc8, 0xb7, 0xe4, 0x9f, 0xf1, 0x0f, 0xa9, 0xe1, 0xb7, 0xdc, 0x61, 0x63, 0x56, 0x28, 0x5e, 0xc6, + 0x0a, 0xaf, 0x47, 0x56, 0x78, 0xdb, 0x4f, 0x3a, 0xb2, 0x54, 0x31, 0x61, 0xa9, 0x9f, 0xc2, 0xd2, + 0xa6, 0x8f, 0xcd, 0x00, 0xff, 0x98, 0xa5, 0xf9, 0xcd, 0x23, 0xd3, 0xf3, 0xb0, 0x13, 0x1e, 0x21, + 0xcd, 0x5c, 0x53, 0x30, 0x6f, 0xc0, 0xf4, 0xc0, 0x27, 0x27, 0xa7, 0x91, 0xdc, 0xe1, 0xaf, 0xf1, + 0x67, 0x0d, 0x9a, 0x2a, 0xda, 0x57, 0xc9, 0x08, 0xef, 0xc3, 0xac, 0xac, 0x57, 0x82, 0x1a, 0xe7, + 0x59, 0x6e, 0x55, 0x5f, 0xc4, 0x38, 0xa0, 0x7b, 0x30, 0x2f, 0x90, 0x7c, 0x4c, 0x87, 0x4e, 0x10, + 0xe1, 0xe6, 0x39, 0x2e, 0xe2, 0x6b, 0x2d, 0xbe, 0x24, 0x77, 0x18, 0xaf, 0x34, 0x58, 0xda, 0xc1, + 0x41, 0x64, 0x44, 0xc6, 0x15, 0xbf, 0xa5, 0x49, 0xf6, 0x2b, 0x0d, 0x9a, 0x2a, 0x59, 0xaf, 0xa2, + 0xd6, 0xa7, 0xb0, 0x18, 0xf1, 0x68, 0x5b, 0x98, 0x76, 0x7d, 0x7b, 0xc0, 0x9d, 0x99, 0xa7, 0xdc, + 0xca, 0xfa, 0xfb, 0xab, 0xe3, 0x2d, 0xc1, 0x6a, 0x5a, 0x82, 0x85, 0x88, 0xc4, 0x56, 0x8c, 0x82, + 0xf1, 0x6b, 0x0d, 0x16, 0x76, 0x70, 0x70, 0x80, 0xfb, 0x2e, 0xf6, 0x82, 0x5d, 0xaf, 0x47, 0x2e, + 0xaf, 0xd7, 0x5b, 0x00, 0x54, 0xd2, 0x89, 0xca, 0x41, 0x0c, 0x32, 0x89, 0x8e, 0x79, 0xf7, 0x91, + 0x96, 0xe7, 0x2a, 0xba, 0xfb, 0x0e, 0x14, 0x6d, 0xaf, 0x47, 0x42, 0x55, 0xbd, 0xab, 0x52, 0x55, + 0x9c, 0x99, 0xc0, 0x36, 0xfe, 0x9d, 0x83, 0xc5, 0x07, 0x96, 0xa5, 0x0a, 0xbb, 0x8b, 0xeb, 0x65, + 0x14, 0xdd, 0xb9, 0x78, 0x74, 0x4f, 0xe4, 0x73, 0x63, 0x21, 0x55, 0xb8, 0x40, 0x48, 0x15, 0xb3, + 0x42, 0x0a, 0xed, 0xc0, 0x2c, 0xc5, 0xf8, 0x79, 0x7b, 0x40, 0x28, 0xf7, 0x89, 0x46, 0x89, 0x9f, + 0xc6, 0x48, 0x9e, 0x26, 0xea, 0x1c, 0x1f, 0xd1, 0xfe, 0xbe, 0xc4, 0x6c, 0x55, 0xd9, 0xc6, 0xf0, + 0x0f, 0x3d, 0x86, 0xc5, 0xbe, 0x43, 0x3a, 0xa6, 0xd3, 0xa6, 0xd8, 0x74, 0xb0, 0xd5, 0x96, 0xf6, + 0xa6, 0x8d, 0xe9, 0xc9, 0x14, 0x3e, 0x2f, 0xb6, 0x1f, 0xf0, 0xdd, 0x72, 0x81, 0x1a, 0x7f, 0xd7, + 0x60, 0xa9, 0x85, 0x5d, 0xf2, 0x05, 0xfe, 0x6f, 0x35, 0x81, 0xf1, 0xcf, 0x1c, 0x2c, 0xfe, 0xc4, + 0x0c, 0xba, 0x47, 0x5b, 0xae, 0x04, 0xd1, 0x37, 0x73, 0xbe, 0x49, 0x0a, 0x54, 0x14, 0x46, 0x45, + 0x95, 0x55, 0xd9, 0x1d, 0x62, 0xf5, 0x89, 0x3c, 0x72, 0x2c, 0x8c, 0x62, 0x15, 0xbc, 0x74, 0x89, + 0x0a, 0x8e, 0x36, 0x61, 0x16, 0x9f, 0x74, 0x9d, 0xa1, 0x85, 0xdb, 0x82, 0xbb, 0xf0, 0xa9, 0x5b, + 0x0a, 0xee, 0x71, 0x97, 0xaa, 0xca, 0x4d, 0xbb, 0x3c, 0x94, 0x5f, 0x6b, 0xb0, 0x24, 0xf4, 0x8c, + 0x9d, 0xc0, 0x7c, 0xb3, 0xaa, 0x8e, 0xd4, 0x58, 0xb8, 0x88, 0x1a, 0x8d, 0xdf, 0x16, 0xa0, 0x2e, + 0x0f, 0xc8, 0xfa, 0x36, 0xb6, 0x84, 0x6e, 0x42, 0x39, 0x4a, 0xad, 0xb2, 0xf4, 0x8f, 0x00, 0xe8, + 0x36, 0x54, 0x62, 0xf6, 0x93, 0x92, 0xc6, 0x41, 0x13, 0x89, 0x1b, 0x16, 0xca, 0x42, 0xac, 0x50, + 0xbe, 0x03, 0xd0, 0x73, 0x86, 0xf4, 0xa8, 0x1d, 0xd8, 0x2e, 0x96, 0xed, 0x4a, 0x99, 0x43, 0x0e, + 0x6d, 0x17, 0xa3, 0x07, 0x50, 0xed, 0xd8, 0x9e, 0x43, 0xfa, 0xed, 0x81, 0x19, 0x1c, 0xd1, 0x46, + 0x29, 0xd3, 0x62, 0xdb, 0x36, 0x76, 0xac, 0x0d, 0x8e, 0xdb, 0xaa, 0x88, 0x3d, 0xfb, 0x6c, 0x0b, + 0xba, 0x05, 0x15, 0x6f, 0xe8, 0xb6, 0x49, 0xaf, 0xed, 0x93, 0x63, 0x66, 0x73, 0xce, 0xc2, 0x1b, + 0xba, 0x9f, 0xf7, 0x5a, 0xe4, 0x98, 0xa2, 0xef, 0x43, 0x99, 0x25, 0x77, 0xea, 0x90, 0x3e, 0x6d, + 0xcc, 0x4c, 0x44, 0x7f, 0xb4, 0x81, 0xed, 0xb6, 0x98, 0x23, 0xf0, 0xdd, 0xe5, 0xc9, 0x76, 0x47, + 0x1b, 0xd0, 0x1d, 0xa8, 0x75, 0x89, 0x3b, 0x30, 0xb9, 0x86, 0xb6, 0x7d, 0xe2, 0x36, 0x80, 0x47, + 0x4b, 0x0a, 0x8a, 0xb6, 0xa1, 0x62, 0x7b, 0x16, 0x3e, 0x91, 0x7e, 0x5b, 0xe1, 0x7c, 0x96, 0x55, + 0xb9, 0xf0, 0x09, 0xee, 0x72, 0x5e, 0xbb, 0x0c, 0x9d, 0x1b, 0x1d, 0xec, 0xf0, 0x93, 0xa2, 0xf7, + 0xa0, 0x2a, 0x8d, 0xda, 0xa6, 0xf6, 0x4b, 0xdc, 0xa8, 0x0a, 0x43, 0x4a, 0xd8, 0x81, 0xfd, 0x12, + 0x1b, 0x7f, 0xc9, 0xc1, 0xdc, 0x18, 0x11, 0xd6, 0xf8, 0xf5, 0x38, 0x24, 0x74, 0x8e, 0xf0, 0x97, + 0x91, 0xc4, 0x9e, 0xd9, 0x71, 0x58, 0x4c, 0x59, 0xf8, 0x84, 0xfb, 0xc6, 0x4c, 0xab, 0x22, 0x60, + 0x9c, 0x00, 0xb3, 0xb1, 0x90, 0xde, 0x33, 0x5d, 0x2c, 0x1b, 0xb3, 0x32, 0x87, 0xec, 0x99, 0x2e, + 0x66, 0xb4, 0x85, 0x88, 0xa1, 0x67, 0x84, 0xbf, 0x6c, 0xa5, 0x33, 0xb4, 0x39, 0x57, 0xe1, 0x19, + 0xe1, 0x2f, 0xda, 0x82, 0xaa, 0x20, 0x39, 0x30, 0x7d, 0xd3, 0x0d, 0xfd, 0xe2, 0x3d, 0x65, 0xbc, + 0x3d, 0xc4, 0xa7, 0x4f, 0x4c, 0x67, 0x88, 0xf7, 0x4d, 0xdb, 0x6f, 0x09, 0x3d, 0xee, 0xf3, 0x5d, + 0xe8, 0x2e, 0xe8, 0x82, 0x4a, 0xcf, 0x76, 0xb0, 0xf4, 0x30, 0x96, 0x13, 0xca, 0xad, 0x1a, 0x87, + 0x6f, 0xdb, 0x0e, 0x16, 0x4e, 0x14, 0x1d, 0x81, 0xab, 0x6d, 0x46, 0xf8, 0x10, 0x87, 0x70, 0xa5, + 0xbd, 0xca, 0xc1, 0x0d, 0x16, 0x4a, 0x61, 0xc1, 0xb9, 0x7c, 0x3a, 0x78, 0x07, 0xc0, 0xa2, 0x41, + 0x3b, 0x91, 0x12, 0xca, 0x16, 0x0d, 0xf6, 0x44, 0x56, 0xf8, 0x24, 0x8c, 0xf8, 0x7c, 0x76, 0xab, + 0x96, 0x0a, 0xed, 0xf1, 0xe4, 0x79, 0x99, 0x4b, 0x28, 0x2b, 0x5b, 0x94, 0x0c, 0xfd, 0x2e, 0x6e, + 0x27, 0xae, 0x16, 0x55, 0x01, 0xdc, 0x53, 0x27, 0xad, 0x92, 0xa2, 0x25, 0xfb, 0x9b, 0x06, 0x8b, + 0xf2, 0x1e, 0x75, 0x75, 0x75, 0x65, 0x65, 0xcf, 0x30, 0xd5, 0xe4, 0xcf, 0xe8, 0xc9, 0x0b, 0x13, + 0x14, 0xaf, 0xa2, 0xa2, 0x78, 0x25, 0xfb, 0xd2, 0x52, 0xba, 0x2f, 0x35, 0x7e, 0xa3, 0xc1, 0xe2, + 0xa7, 0xa6, 0x67, 0x91, 0x5e, 0xef, 0xea, 0x07, 0xdc, 0x8c, 0x22, 0x76, 0xf7, 0x22, 0x7d, 0x67, + 0x62, 0x93, 0xf1, 0x65, 0x0e, 0x10, 0x73, 0x87, 0x0d, 0xd3, 0x31, 0xbd, 0x2e, 0xbe, 0xbc, 0x34, + 0xcb, 0x50, 0x4b, 0x38, 0x41, 0xf4, 0xea, 0x15, 0xf7, 0x02, 0x8a, 0x1e, 0x42, 0xad, 0x23, 0x58, + 0xb5, 0x7d, 0x6c, 0x52, 0xe2, 0x71, 0x3b, 0xd4, 0xd6, 0x3f, 0x50, 0x89, 0x7d, 0xe8, 0xdb, 0xfd, + 0x3e, 0xf6, 0x37, 0x89, 0x67, 0x89, 0x8e, 0x70, 0xb6, 0x13, 0x8a, 0xc9, 0xb6, 0xa2, 0x77, 0xa1, + 0x32, 0x8a, 0x88, 0xb0, 0x9d, 0x80, 0x28, 0x24, 0x28, 0xfa, 0x08, 0xe6, 0x92, 0xcd, 0xe2, 0xc8, + 0x70, 0x3a, 0x8d, 0xf7, 0x81, 0xcc, 0x38, 0x3f, 0x07, 0x14, 0x35, 0x48, 0xbc, 0x8c, 0xf3, 0xf4, + 0x36, 0xc9, 0xdd, 0xf7, 0x26, 0x94, 0xad, 0x70, 0xa7, 0xbc, 0x89, 0x8e, 0x00, 0x2c, 0x3c, 0x84, + 0x84, 0x6d, 0x87, 0x98, 0x16, 0xb6, 0xc2, 0x02, 0x28, 0x80, 0x9f, 0x71, 0x98, 0xf1, 0x55, 0x0e, + 0xf4, 0x78, 0x03, 0x3a, 0x31, 0xef, 0xeb, 0xb9, 0x09, 0x9f, 0xd1, 0x6d, 0x17, 0xae, 0xd0, 0x6d, + 0x8f, 0xdf, 0x06, 0x8a, 0x97, 0xbb, 0x0d, 0x18, 0xbf, 0xd7, 0xa0, 0x9e, 0xba, 0x78, 0xa6, 0x5b, + 0x11, 0x6d, 0xbc, 0x15, 0xf9, 0x2e, 0x14, 0x59, 0x7d, 0xc6, 0x5c, 0x49, 0xb5, 0x34, 0x5b, 0xd5, + 0x75, 0xb6, 0x25, 0x36, 0xa0, 0x35, 0xb8, 0xa1, 0x78, 0x5e, 0x94, 0xa6, 0x44, 0xe3, 0xaf, 0x8b, + 0xc6, 0x2f, 0x0a, 0x50, 0x89, 0xe9, 0xe3, 0x9c, 0x2e, 0x2a, 0x6d, 0xe9, 0x9c, 0xc2, 0xd2, 0xa9, + 0xe3, 0xe5, 0xc7, 0x8f, 0x97, 0xf1, 0x0c, 0x87, 0x96, 0x60, 0xc6, 0xc5, 0xae, 0x28, 0x50, 0xb2, + 0x5a, 0xba, 0xd8, 0x65, 0xe5, 0x89, 0x2d, 0xb1, 0x16, 0x88, 0xf7, 0x3f, 0x22, 0x25, 0x4f, 0x7b, + 0x43, 0x97, 0x77, 0x3f, 0xc9, 0xda, 0x3c, 0x7d, 0x46, 0x6d, 0x9e, 0x49, 0xd6, 0xe6, 0x44, 0x38, + 0x94, 0xd3, 0xe1, 0x30, 0x69, 0x63, 0x73, 0x0f, 0x6e, 0x74, 0xf9, 0xab, 0x91, 0xb5, 0x71, 0xba, + 0x19, 0x2d, 0x35, 0x2a, 0xbc, 0x89, 0x50, 0x2d, 0xa1, 0x6d, 0xe6, 0x5c, 0xb2, 0x85, 0xe1, 0x56, + 0xae, 0x72, 0x2b, 0xab, 0x4b, 0xbf, 0xb4, 0x8d, 0x30, 0x72, 0x98, 0x13, 0xf9, 0x5f, 0xba, 0xa5, + 0x9a, 0xbd, 0x64, 0x4b, 0x65, 0x7c, 0x99, 0x87, 0xda, 0xa8, 0x68, 0x4e, 0x1c, 0xd1, 0x93, 0xbc, + 0x76, 0xef, 0x81, 0x3e, 0x7a, 0xa8, 0xe1, 0x87, 0x3d, 0xb3, 0xee, 0xa7, 0x9f, 0x68, 0xea, 0x83, + 0x54, 0xe8, 0x7c, 0x02, 0x65, 0x96, 0x9c, 0xda, 0xc1, 0xe9, 0x00, 0x73, 0xe7, 0xa9, 0xa5, 0x93, + 0xbe, 0x20, 0xc4, 0xb2, 0xd5, 0xe1, 0xe9, 0x00, 0xb7, 0x66, 0x1c, 0xf9, 0x75, 0xc5, 0xb7, 0x53, + 0x74, 0x1f, 0x16, 0x7c, 0x51, 0xf2, 0xad, 0x76, 0xe2, 0xd8, 0xa2, 0x7a, 0xce, 0x87, 0x8b, 0xfb, + 0xf1, 0xe3, 0x67, 0x44, 0xe3, 0x74, 0x66, 0x34, 0xfe, 0x4b, 0x83, 0x39, 0x69, 0x71, 0xe6, 0x87, + 0x7d, 0x7e, 0x63, 0x63, 0xb9, 0x93, 0x78, 0x8e, 0xed, 0x45, 0x8d, 0x8b, 0x34, 0x87, 0x00, 0xca, + 0xc6, 0xe5, 0x53, 0xa8, 0x4b, 0xa4, 0x28, 0x05, 0x4e, 0x58, 0x69, 0x6b, 0x62, 0x5f, 0x94, 0xfc, + 0x96, 0xa1, 0x46, 0x7a, 0xbd, 0x38, 0x3f, 0x11, 0xc3, 0xb3, 0x12, 0x2a, 0x19, 0xfe, 0x08, 0xf4, + 0x10, 0xed, 0xa2, 0x49, 0xb7, 0x2e, 0x37, 0x46, 0xaf, 0x1b, 0xbf, 0xd2, 0xa0, 0x91, 0x4c, 0xc1, + 0xb1, 0xe3, 0x5f, 0xbc, 0xc8, 0x7f, 0x2f, 0xf9, 0xc6, 0xb5, 0x7c, 0x86, 0x3c, 0x23, 0x3e, 0xb2, + 0xcb, 0x5c, 0x79, 0x09, 0xb5, 0xa4, 0x1f, 0xa2, 0x2a, 0xcc, 0xec, 0x91, 0xe0, 0x87, 0x27, 0x36, + 0x0d, 0xf4, 0x29, 0x54, 0x03, 0xd8, 0x23, 0xc1, 0xbe, 0x8f, 0x29, 0xf6, 0x02, 0x5d, 0x43, 0x00, + 0xa5, 0xcf, 0xbd, 0x2d, 0x9b, 0x3e, 0xd7, 0x73, 0xe8, 0x86, 0xcc, 0xf6, 0xa6, 0xb3, 0x2b, 0x8d, + 0xab, 0xe7, 0xd9, 0xf6, 0xe8, 0xaf, 0x80, 0x74, 0xa8, 0x46, 0x28, 0x3b, 0xfb, 0x8f, 0xf5, 0x22, + 0x2a, 0x43, 0x51, 0x7c, 0x96, 0x56, 0x2c, 0xd0, 0xd3, 0xcd, 0x04, 0xa3, 0xf9, 0xd8, 0x7b, 0xe8, + 0x91, 0xe3, 0x08, 0xa4, 0x4f, 0xa1, 0x0a, 0x4c, 0xcb, 0x06, 0x4d, 0xd7, 0x50, 0x1d, 0x2a, 0xb1, + 0xde, 0x48, 0xcf, 0x31, 0xc0, 0x8e, 0x3f, 0xe8, 0xca, 0x2e, 0x49, 0x88, 0xc0, 0xac, 0xb6, 0x45, + 0x8e, 0x3d, 0xbd, 0xb0, 0xf2, 0x00, 0x66, 0xc2, 0x00, 0x61, 0xa7, 0x11, 0xd4, 0xd9, 0x9f, 0x3e, + 0x85, 0xe6, 0x60, 0x36, 0x31, 0x09, 0xd1, 0x35, 0x84, 0xa0, 0xe6, 0x24, 0xc6, 0x4f, 0x7a, 0x6e, + 0xfd, 0xaf, 0x15, 0x00, 0xd1, 0x07, 0x10, 0xe2, 0x5b, 0x68, 0x00, 0x68, 0x07, 0x07, 0x2c, 0xc7, + 0x11, 0x2f, 0xcc, 0x4f, 0x14, 0xdd, 0xcb, 0x28, 0x97, 0xe3, 0xa8, 0x52, 0xd2, 0xe6, 0x9d, 0x8c, + 0x1d, 0x29, 0x74, 0x63, 0x0a, 0xb9, 0x9c, 0x23, 0xbb, 0x61, 0x1f, 0xda, 0xdd, 0xe7, 0x51, 0x03, + 0x91, 0xcd, 0x31, 0x85, 0x1a, 0x72, 0x4c, 0xe5, 0x21, 0xf9, 0x73, 0x10, 0xf8, 0xb6, 0xd7, 0x0f, + 0x1f, 0x5a, 0x8d, 0x29, 0xf4, 0x02, 0xe6, 0x77, 0x30, 0xe7, 0x6e, 0xd3, 0xc0, 0xee, 0xd2, 0x90, + 0xe1, 0x7a, 0x36, 0xc3, 0x31, 0xe4, 0x0b, 0xb2, 0x74, 0xa0, 0x9e, 0x1a, 0xf7, 0xa2, 0x15, 0xa5, + 0x23, 0x2b, 0x47, 0xd3, 0xcd, 0x8f, 0x26, 0xc2, 0x8d, 0xb8, 0xd9, 0x50, 0x4b, 0x8e, 0x42, 0xd1, + 0x37, 0xb2, 0x08, 0x8c, 0xcd, 0x8e, 0x9a, 0x2b, 0x93, 0xa0, 0x46, 0xac, 0x9e, 0x42, 0x2d, 0x39, + 0x6c, 0x53, 0xb3, 0x52, 0x0e, 0xe4, 0x9a, 0x67, 0xbd, 0x71, 0x1b, 0x53, 0xe8, 0x67, 0x30, 0x37, + 0x36, 0xe1, 0x42, 0xdf, 0x54, 0x91, 0xcf, 0x1a, 0x84, 0x9d, 0xc7, 0x41, 0x4a, 0x3f, 0xd2, 0x62, + 0xb6, 0xf4, 0x63, 0xa3, 0xce, 0xc9, 0xa5, 0x8f, 0x91, 0x3f, 0x4b, 0xfa, 0x0b, 0x73, 0x18, 0x02, + 0x1a, 0x9f, 0x71, 0xa1, 0x8f, 0x55, 0x2c, 0x32, 0xe7, 0x6c, 0xcd, 0xd5, 0x49, 0xd1, 0x23, 0x93, + 0x0f, 0x79, 0xb4, 0xa6, 0x1b, 0x61, 0x25, 0xdb, 0xcc, 0xb9, 0x96, 0x9a, 0x6d, 0xf6, 0x68, 0x49, + 0x38, 0x75, 0x72, 0x74, 0xa2, 0xb6, 0x95, 0x72, 0xdc, 0xa3, 0x76, 0x6a, 0xf5, 0x24, 0xc6, 0x98, + 0x42, 0x87, 0x89, 0x1c, 0x8c, 0xee, 0x64, 0xf9, 0x44, 0xf2, 0x02, 0x7b, 0x9e, 0xb9, 0xda, 0x00, + 0x3b, 0x38, 0x78, 0x84, 0x03, 0xdf, 0xee, 0xd2, 0x34, 0x51, 0xf9, 0x33, 0x42, 0x08, 0x89, 0x7e, + 0x78, 0x2e, 0x5e, 0x28, 0xf6, 0xfa, 0x2b, 0x80, 0x32, 0xb7, 0x19, 0x2b, 0x0f, 0xff, 0x4b, 0xe3, + 0xd7, 0x90, 0xc6, 0x9f, 0x41, 0x3d, 0x35, 0x37, 0x53, 0xa7, 0x71, 0xf5, 0x70, 0xed, 0x3c, 0x07, + 0xe9, 0x00, 0x1a, 0x9f, 0x0a, 0xa9, 0x03, 0x2b, 0x73, 0x7a, 0x74, 0x1e, 0x8f, 0x67, 0x50, 0x4f, + 0x8d, 0x65, 0xd4, 0x27, 0x50, 0xcf, 0x6e, 0x26, 0x38, 0xc1, 0xf8, 0x30, 0x42, 0x7d, 0x82, 0xcc, + 0xa1, 0xc5, 0x79, 0x3c, 0x9e, 0x40, 0x35, 0xfe, 0xb6, 0x89, 0x3e, 0xcc, 0x8a, 0xce, 0xd4, 0x6b, + 0xd7, 0x9b, 0xcf, 0xd7, 0xd7, 0x5f, 0xcf, 0x9e, 0x41, 0x3d, 0xf5, 0x96, 0xa9, 0xb6, 0xae, 0xfa, + 0xc1, 0xf3, 0x3c, 0xea, 0x5f, 0x63, 0x06, 0xbe, 0xee, 0x5c, 0xb9, 0xf1, 0xed, 0xa7, 0xeb, 0x7d, + 0x3b, 0x38, 0x1a, 0x76, 0xd8, 0x29, 0xd7, 0x04, 0xe6, 0xc7, 0x36, 0x91, 0x5f, 0x6b, 0x61, 0xd2, + 0x58, 0xe3, 0x94, 0xd6, 0xb8, 0xb4, 0x83, 0x4e, 0xa7, 0xc4, 0x7f, 0xef, 0xff, 0x27, 0x00, 0x00, + 0xff, 0xff, 0x7b, 0x37, 0x4e, 0x07, 0xb9, 0x28, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/internal/querycoord/cluster.go b/internal/querycoord/cluster.go index 4dd8704964..ecaaeda8d3 100644 --- a/internal/querycoord/cluster.go +++ b/internal/querycoord/cluster.go @@ -706,32 +706,32 @@ func defaultSegEstimatePolicy() segEstimatePolicy { type segEstimatePolicy func(request *querypb.LoadSegmentsRequest, dataKv kv.DataKV) (int64, error) func estimateSegmentsSize(segments *querypb.LoadSegmentsRequest, kvClient kv.DataKV) (int64, error) { - segmentSize := int64(0) - - //TODO:: collection has multi vector field - //vecFields := make([]int64, 0) - //for _, field := range segments.Schema.Fields { - // if field.DataType == schemapb.DataType_BinaryVector || field.DataType == schemapb.DataType_FloatVector { - // vecFields = append(vecFields, field.FieldID) - // } - //} - // get fields data size, if len(indexFieldIDs) == 0, vector field would be involved in fieldBinLogs + requestSize := int64(0) for _, loadInfo := range segments.Infos { - // get index size - if loadInfo.EnableIndex { - for _, pathInfo := range loadInfo.IndexPathInfos { - segmentSize += int64(pathInfo.GetSerializedSize()) + segmentSize := int64(0) + // get which field has index file + vecFieldIndexInfo := make(map[int64]*querypb.VecFieldIndexInfo) + for _, indexInfo := range loadInfo.IndexInfos { + if indexInfo.EnableIndex { + fieldID := indexInfo.FieldID + vecFieldIndexInfo[fieldID] = indexInfo } - continue } - // get binlog size for _, binlogPath := range loadInfo.BinlogPaths { - for _, binlog := range binlogPath.Binlogs { - segmentSize += binlog.GetLogSize() + fieldID := binlogPath.FieldID + // if index node has built index, cal segment size by index file size, or use raw data's binlog size + if indexInfo, ok := vecFieldIndexInfo[fieldID]; ok { + segmentSize += indexInfo.IndexSize + } else { + for _, binlog := range binlogPath.Binlogs { + segmentSize += binlog.GetLogSize() + } } } + loadInfo.SegmentSize = segmentSize + requestSize += segmentSize } - return segmentSize, nil + return requestSize, nil } diff --git a/internal/querycoord/cluster_test.go b/internal/querycoord/cluster_test.go index d4eabfaa44..f957e2c103 100644 --- a/internal/querycoord/cluster_test.go +++ b/internal/querycoord/cluster_test.go @@ -37,7 +37,6 @@ import ( "github.com/milvus-io/milvus/internal/proto/commonpb" "github.com/milvus-io/milvus/internal/proto/datapb" "github.com/milvus-io/milvus/internal/proto/etcdpb" - "github.com/milvus-io/milvus/internal/proto/indexpb" "github.com/milvus-io/milvus/internal/proto/querypb" "github.com/milvus-io/milvus/internal/proto/schemapb" "github.com/milvus-io/milvus/internal/storage" @@ -652,22 +651,9 @@ func TestGrpcRequest(t *testing.T) { func TestEstimateSegmentSize(t *testing.T) { refreshParams() - baseCtx, cancel := context.WithCancel(context.Background()) - option := &minioKV.Option{ - Address: Params.QueryCoordCfg.MinioEndPoint, - AccessKeyID: Params.QueryCoordCfg.MinioAccessKeyID, - SecretAccessKeyID: Params.QueryCoordCfg.MinioSecretAccessKey, - UseSSL: Params.QueryCoordCfg.MinioUseSSLStr, - CreateBucket: true, - BucketName: Params.QueryCoordCfg.MinioBucketName, - } - - dataKV, err := minioKV.NewMinIOKV(baseCtx, option) - assert.Nil(t, err) - schema := genCollectionSchema(defaultCollectionID, false) binlog := []*datapb.FieldBinlog{ { - FieldID: simpleConstField.id, + FieldID: defaultVecFieldID, Binlogs: []*datapb.Binlog{{LogPath: "by-dev/rand/path", LogSize: 1024}}, }, } @@ -681,43 +667,22 @@ func TestEstimateSegmentSize(t *testing.T) { } loadReq := &querypb.LoadSegmentsRequest{ - Schema: schema, Infos: []*querypb.SegmentLoadInfo{loadInfo}, CollectionID: defaultCollectionID, } - size, err := estimateSegmentsSize(loadReq, dataKV) + size, err := estimateSegmentsSize(loadReq, nil) assert.NoError(t, err) assert.Equal(t, int64(1024), size) - binlog, err = saveSimpleBinLog(baseCtx, schema, dataKV) - assert.NoError(t, err) - - loadInfo.BinlogPaths = binlog - - size, err = estimateSegmentsSize(loadReq, dataKV) - assert.NoError(t, err) - assert.NotEqual(t, int64(1024), size) - - indexPath, err := generateIndex(defaultSegmentID) - assert.NoError(t, err) - - indexInfo := &indexpb.IndexFilePathInfo{ - IndexFilePaths: indexPath, - SerializedSize: 1024, + indexInfo := &querypb.VecFieldIndexInfo{ + FieldID: defaultVecFieldID, + EnableIndex: true, + IndexSize: 2048, } - loadInfo.IndexPathInfos = []*indexpb.IndexFilePathInfo{indexInfo} - loadInfo.EnableIndex = true - size, err = estimateSegmentsSize(loadReq, dataKV) + loadInfo.IndexInfos = []*querypb.VecFieldIndexInfo{indexInfo} + size, err = estimateSegmentsSize(loadReq, nil) assert.NoError(t, err) - assert.Equal(t, int64(1024), size) - - indexInfo.IndexFilePaths = []string{"&*^*(^*(&*%^&*^(&"} - indexInfo.SerializedSize = 0 - size, err = estimateSegmentsSize(loadReq, dataKV) - assert.NoError(t, err) - assert.Equal(t, int64(0), size) - - cancel() + assert.Equal(t, int64(2048), size) } diff --git a/internal/querycoord/index_checker.go b/internal/querycoord/index_checker.go index c33ada21b9..e667d01b42 100644 --- a/internal/querycoord/index_checker.go +++ b/internal/querycoord/index_checker.go @@ -31,18 +31,10 @@ import ( "github.com/milvus-io/milvus/internal/proto/indexpb" "github.com/milvus-io/milvus/internal/proto/milvuspb" "github.com/milvus-io/milvus/internal/proto/querypb" + "github.com/milvus-io/milvus/internal/proto/schemapb" "github.com/milvus-io/milvus/internal/types" ) -type indexInfo struct { - segmentID UniqueID - collectionID UniqueID - partitionID UniqueID - - infos []*indexpb.IndexFilePathInfo - enableIndex bool -} - // IndexChecker checks index type IndexChecker struct { ctx context.Context @@ -127,7 +119,8 @@ func (ic *IndexChecker) reloadFromKV() error { log.Error("reloadFromKV: unmarshal failed", zap.Any("error", err.Error())) return err } - if ic.verifyHandoffReqValid(segmentInfo) && Params.QueryCoordCfg.AutoHandoff { + validHandoffReq, _ := ic.verifyHandoffReqValid(segmentInfo) + if validHandoffReq && Params.QueryCoordCfg.AutoHandoff { // push the req to handoffReqChan and then wait to load after index created // in case handoffReqChan is full, and block start process go ic.enqueueHandoffReq(segmentInfo) @@ -146,7 +139,7 @@ func (ic *IndexChecker) reloadFromKV() error { return nil } -func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool { +func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) (bool, *querypb.CollectionInfo) { // if collection has not been loaded, then skip the segment collectionInfo, err := ic.meta.getCollectionInfoByID(req.CollectionID) if err == nil { @@ -154,7 +147,7 @@ func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool { if collectionInfo.LoadType == querypb.LoadType_LoadPartition { for _, id := range collectionInfo.PartitionIDs { if id == req.PartitionID { - return true + return true, collectionInfo } } } else { @@ -165,12 +158,12 @@ func (ic *IndexChecker) verifyHandoffReqValid(req *querypb.SegmentInfo) bool { } } if !partitionReleased { - return true + return true, collectionInfo } } } - return false + return false, nil } func (ic *IndexChecker) enqueueHandoffReq(req *querypb.SegmentInfo) { @@ -196,15 +189,14 @@ func (ic *IndexChecker) checkIndexLoop() { // TODO:: check whether the index exists in parallel, in case indexCoord cannot create the index normally, and then block the loop log.Debug("checkIndexLoop: start check index for handoff segment", zap.Int64("segmentID", segmentInfo.SegmentID)) for { - if ic.verifyHandoffReqValid(segmentInfo) && Params.QueryCoordCfg.AutoHandoff { - indexInfo, err := getIndexInfo(ic.ctx, segmentInfo, ic.rootCoord, ic.indexCoord) + validHandoffReq, collectionInfo := ic.verifyHandoffReqValid(segmentInfo) + if validHandoffReq && Params.QueryCoordCfg.AutoHandoff { + indexInfo, err := getIndexInfo(ic.ctx, segmentInfo, collectionInfo.Schema, ic.rootCoord, ic.indexCoord) if err != nil { continue } - if indexInfo.enableIndex { - segmentInfo.EnableIndex = true - } - segmentInfo.IndexPathInfos = indexInfo.infos + + segmentInfo.IndexInfos = indexInfo ic.enqueueIndexedSegment(segmentInfo) break } @@ -278,13 +270,18 @@ func (ic *IndexChecker) processHandoffAfterIndexDone() { } } -func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, root types.RootCoord, index types.IndexCoord) (*indexInfo, error) { - indexInfo := &indexInfo{ - segmentID: info.SegmentID, - partitionID: info.PartitionID, - collectionID: info.CollectionID, +func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, schema *schemapb.CollectionSchema, root types.RootCoord, index types.IndexCoord) ([]*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 := getVecFieldIDs(schema) + if len(vecFieldIDs) != 1 { + err := fmt.Errorf("collection %d has multi vec field, num of vec fields = %d", info.CollectionID, len(vecFieldIDs)) + log.Error("get index info failed", zap.Int64("collectionID", info.CollectionID), zap.Int64("segmentID", info.SegmentID), zap.Error(err)) + return nil, err + } + indexInfo := &querypb.VecFieldIndexInfo{ + FieldID: vecFieldIDs[0], } - // check the buildID of the segment's index whether exist on rootCoord req := &milvuspb.DescribeSegmentRequest{ Base: &commonpb.MsgBase{ @@ -305,36 +302,36 @@ func getIndexInfo(ctx context.Context, info *querypb.SegmentInfo, root types.Roo // if the segment.EnableIndex == false, then load the segment immediately if !response.EnableIndex { - indexInfo.enableIndex = false - return indexInfo, nil - } + indexInfo.EnableIndex = false + } else { + indexInfo.BuildID = response.BuildID + indexInfo.EnableIndex = true + // if index created done on indexNode, then handoff start + indexFilePathRequest := &indexpb.GetIndexFilePathsRequest{ + IndexBuildIDs: []UniqueID{response.BuildID}, + } + ctx3, cancel3 := context.WithTimeout(ctx, timeoutForRPC) + defer cancel3() + pathResponse, err2 := index.GetIndexFilePaths(ctx3, indexFilePathRequest) + if err2 != nil { + return nil, err2 + } - // if index created done on indexNode, then handoff start - indexFilePathRequest := &indexpb.GetIndexFilePathsRequest{ - IndexBuildIDs: []UniqueID{response.BuildID}, - } - ctx3, cancel3 := context.WithTimeout(ctx, timeoutForRPC) - defer cancel3() - pathResponse, err2 := index.GetIndexFilePaths(ctx3, indexFilePathRequest) - if err2 != nil { - return nil, err2 - } + if pathResponse.Status.ErrorCode != commonpb.ErrorCode_Success { + return nil, errors.New(pathResponse.Status.Reason) + } - if pathResponse.Status.ErrorCode != commonpb.ErrorCode_Success { - return nil, errors.New(pathResponse.Status.Reason) - } + if len(pathResponse.FilePaths) != 1 { + return nil, errors.New("illegal index file paths, there should be only one vector column") + } - if len(pathResponse.FilePaths) <= 0 { - return nil, errors.New("illegal index file paths") - } - for _, fieldPath := range pathResponse.FilePaths { - if len(fieldPath.IndexFilePaths) == 0 { + fieldPathInfo := pathResponse.FilePaths[0] + if len(fieldPathInfo.IndexFilePaths) == 0 { return nil, errors.New("empty index paths") } + + indexInfo.IndexFilePaths = fieldPathInfo.IndexFilePaths + indexInfo.IndexSize = int64(fieldPathInfo.SerializedSize) } - - indexInfo.enableIndex = true - indexInfo.infos = pathResponse.FilePaths - - return indexInfo, nil + return []*querypb.VecFieldIndexInfo{indexInfo}, nil } diff --git a/internal/querycoord/mock_3rd_component_test.go b/internal/querycoord/mock_3rd_component_test.go index ac2705f6cd..1d26644028 100644 --- a/internal/querycoord/mock_3rd_component_test.go +++ b/internal/querycoord/mock_3rd_component_test.go @@ -49,13 +49,14 @@ const ( defaultQueryNodeID = int64(100) defaultChannelNum = 2 defaultNumRowPerSegment = 1000 + defaultVecFieldID = 101 ) func genCollectionSchema(collectionID UniqueID, isBinary bool) *schemapb.CollectionSchema { var fieldVec schemapb.FieldSchema if isBinary { fieldVec = schemapb.FieldSchema{ - FieldID: UniqueID(101), + FieldID: UniqueID(defaultVecFieldID), Name: "vec", IsPrimaryKey: false, DataType: schemapb.DataType_BinaryVector, @@ -74,7 +75,7 @@ func genCollectionSchema(collectionID UniqueID, isBinary bool) *schemapb.Collect } } else { fieldVec = schemapb.FieldSchema{ - FieldID: UniqueID(101), + FieldID: UniqueID(defaultVecFieldID), Name: "vec", IsPrimaryKey: false, DataType: schemapb.DataType_FloatVector, diff --git a/internal/querycoord/query_coord.go b/internal/querycoord/query_coord.go index 3f147727fb..6011060574 100644 --- a/internal/querycoord/query_coord.go +++ b/internal/querycoord/query_coord.go @@ -423,7 +423,8 @@ func (qc *QueryCoord) watchHandoffSegmentLoop() { } switch event.Type { case mvccpb.PUT: - if Params.QueryCoordCfg.AutoHandoff && qc.indexChecker.verifyHandoffReqValid(segmentInfo) { + validHandoffReq, _ := qc.indexChecker.verifyHandoffReqValid(segmentInfo) + if Params.QueryCoordCfg.AutoHandoff && validHandoffReq { qc.indexChecker.enqueueHandoffReq(segmentInfo) log.Debug("watchHandoffSegmentLoop: enqueue a handoff request to index checker", zap.Any("segment info", segmentInfo)) } else { diff --git a/internal/querycoord/task.go b/internal/querycoord/task.go index c0c5053673..62de1afefb 100644 --- a/internal/querycoord/task.go +++ b/internal/querycoord/task.go @@ -374,11 +374,10 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error { indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ CollectionID: collectionID, SegmentID: segmentID, - }, lct.rootCoord, lct.indexCoord) + }, lct.Schema, lct.rootCoord, lct.indexCoord) - if err == nil && indexInfo.enableIndex { - segmentLoadInfo.EnableIndex = true - segmentLoadInfo.IndexPathInfos = indexInfo.infos + if err == nil { + segmentLoadInfo.IndexInfos = indexInfo } msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase) @@ -726,11 +725,10 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error { indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ CollectionID: collectionID, SegmentID: segmentID, - }, lpt.rootCoord, lpt.indexCoord) + }, lpt.Schema, lpt.rootCoord, lpt.indexCoord) - if err == nil && indexInfo.enableIndex { - segmentLoadInfo.EnableIndex = true - segmentLoadInfo.IndexPathInfos = indexInfo.infos + if err == nil { + segmentLoadInfo.IndexInfos = indexInfo } msgBase := proto.Clone(lpt.Base).(*commonpb.MsgBase) @@ -1501,8 +1499,7 @@ func (ht *handoffTask) execute(ctx context.Context) error { BinlogPaths: segmentBinlogs.FieldBinlogs, NumOfRows: segmentBinlogs.NumOfRows, CompactionFrom: segmentInfo.CompactionFrom, - EnableIndex: segmentInfo.EnableIndex, - IndexPathInfos: segmentInfo.IndexPathInfos, + IndexInfos: segmentInfo.IndexInfos, } msgBase := proto.Clone(ht.Base).(*commonpb.MsgBase) @@ -1697,11 +1694,10 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error { indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ CollectionID: collectionID, SegmentID: segmentID, - }, lbt.rootCoord, lbt.indexCoord) + }, collectionInfo.Schema, lbt.rootCoord, lbt.indexCoord) - if err == nil && indexInfo.enableIndex { - segmentLoadInfo.EnableIndex = true - segmentLoadInfo.IndexPathInfos = indexInfo.infos + if err == nil { + segmentLoadInfo.IndexInfos = indexInfo } msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase) @@ -1869,11 +1865,10 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error { indexInfo, err := getIndexInfo(ctx, &querypb.SegmentInfo{ CollectionID: collectionID, SegmentID: segmentID, - }, lbt.rootCoord, lbt.indexCoord) + }, collectionInfo.Schema, lbt.rootCoord, lbt.indexCoord) - if err == nil && indexInfo.enableIndex { - segmentLoadInfo.EnableIndex = true - segmentLoadInfo.IndexPathInfos = indexInfo.infos + if err == nil { + segmentLoadInfo.IndexInfos = indexInfo } msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase) diff --git a/internal/querycoord/util.go b/internal/querycoord/util.go index 0738501c47..a8d7a234d9 100644 --- a/internal/querycoord/util.go +++ b/internal/querycoord/util.go @@ -16,6 +16,8 @@ package querycoord +import "github.com/milvus-io/milvus/internal/proto/schemapb" + func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} { compareMap := make(map[int64]struct{}) for _, data := range sliceData { @@ -24,3 +26,14 @@ func getCompareMapFromSlice(sliceData []int64) map[int64]struct{} { return compareMap } + +func getVecFieldIDs(schema *schemapb.CollectionSchema) []int64 { + var vecFieldIDs []int64 + for _, field := range schema.Fields { + if field.DataType == schemapb.DataType_BinaryVector || field.DataType == schemapb.DataType_FloatVector { + vecFieldIDs = append(vecFieldIDs, field.FieldID) + } + } + + return vecFieldIDs +}