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

Add index info in loadSegmentRequest (#14524) 

Signed-off-by: xige-16 <xi.ge@zilliz.com>
pull/14633/head
xige-16 2021-12-30 19:09:33 +08:00 committed by GitHub
parent f96cd84efb
commit b063bfda8f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 409 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
internal/proto/query_coord.proto
View File

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

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

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

38
internal/querycoord/cluster.go
View File

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

53
internal/querycoord/cluster_test.go
View File

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

101
internal/querycoord/index_checker.go
View File

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

5
internal/querycoord/mock_3rd_component_test.go
View File

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

3
internal/querycoord/query_coord.go
View File

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

31
internal/querycoord/task.go
View File

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

13
internal/querycoord/util.go
View File

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