admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-08 01:58:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

Explictly specify Load operation meta (#16027)

Browse Source 
Fix #15996

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
This commit is contained in:
congqixia 2022-03-14 09:50:01 +08:00 committed by GitHub
parent b38591e527
commit 6a66faa2fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 350 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
internal/proto/query_coord.proto
View File

@ -161,6 +161,12 @@ message RemoveQueryChannelRequest {
string query_result_channel = 5; string query_result_channel = 5;
} }
message LoadMetaInfo {
LoadType load_type = 1;
int64 collectionID = 2;
repeated int64 partitionIDs = 3;
}
message WatchDmChannelsRequest { message WatchDmChannelsRequest {
common.MsgBase base = 1; common.MsgBase base = 1;
int64 nodeID = 2; int64 nodeID = 2;
@ -169,6 +175,7 @@ message WatchDmChannelsRequest {
repeated data.VchannelInfo infos = 5; repeated data.VchannelInfo infos = 5;
schema.CollectionSchema schema = 6; schema.CollectionSchema schema = 6;
repeated data.SegmentInfo exclude_infos = 7; repeated data.SegmentInfo exclude_infos = 7;
LoadMetaInfo load_meta = 8;
} }
message WatchDeltaChannelsRequest { message WatchDeltaChannelsRequest {
@ -176,6 +183,7 @@ message WatchDeltaChannelsRequest {
int64 nodeID = 2; int64 nodeID = 2;
int64 collectionID = 3; int64 collectionID = 3;
repeated data.VchannelInfo infos = 4; repeated data.VchannelInfo infos = 4;
LoadMetaInfo load_meta = 9;
} }
message SegmentLoadInfo { message SegmentLoadInfo {
@ -211,6 +219,7 @@ message LoadSegmentsRequest {
schema.CollectionSchema schema = 4; schema.CollectionSchema schema = 4;
int64 source_nodeID = 5; int64 source_nodeID = 5;
int64 collectionID = 6; int64 collectionID = 6;
LoadMetaInfo load_meta = 7;
} }
message ReleaseSegmentsRequest { message ReleaseSegmentsRequest {
@ -257,9 +266,9 @@ enum TriggerCondition {
} }
enum LoadType { enum LoadType {
UnKnowType = 0; UnKnownType = 0;
LoadPartition = 1; LoadPartition = 1;
loadCollection = 2; LoadCollection = 2;
} }
message DmChannelWatchInfo { message DmChannelWatchInfo {

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

@ -107,21 +107,21 @@ func (TriggerCondition) EnumDescriptor() ([]byte, []int) {
type LoadType int32 type LoadType int32
const ( const (
LoadType_UnKnowType LoadType = 0 LoadType_UnKnownType LoadType = 0
LoadType_LoadPartition LoadType = 1 LoadType_LoadPartition LoadType = 1
LoadType_loadCollection LoadType = 2 LoadType_LoadCollection LoadType = 2
) )
var LoadType_name = map[int32]string{ var LoadType_name = map[int32]string{
0: "UnKnowType", 0: "UnKnownType",
1: "LoadPartition", 1: "LoadPartition",
2: "loadCollection", 2: "LoadCollection",
} }
var LoadType_value = map[string]int32{ var LoadType_value = map[string]int32{
"UnKnowType": 0, "UnKnownType": 0,
"LoadPartition": 1, "LoadPartition": 1,
"loadCollection": 2, "LoadCollection": 2,
} }
func (x LoadType) String() string { func (x LoadType) String() string {
@ -1103,6 +1103,61 @@ func (m *RemoveQueryChannelRequest) GetQueryResultChannel() string {
return "" return ""
} }
type LoadMetaInfo struct {
LoadType LoadType `protobuf:"varint,1,opt,name=load_type,json=loadType,proto3,enum=milvus.proto.query.LoadType" json:"load_type,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,3,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoadMetaInfo) Reset() { *m = LoadMetaInfo{} }
func (m *LoadMetaInfo) String() string { return proto.CompactTextString(m) }
func (*LoadMetaInfo) ProtoMessage() {}
func (*LoadMetaInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{16}
}
func (m *LoadMetaInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LoadMetaInfo.Unmarshal(m, b)
}
func (m *LoadMetaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LoadMetaInfo.Marshal(b, m, deterministic)
}
func (m *LoadMetaInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_LoadMetaInfo.Merge(m, src)
}
func (m *LoadMetaInfo) XXX_Size() int {
return xxx_messageInfo_LoadMetaInfo.Size(m)
}
func (m *LoadMetaInfo) XXX_DiscardUnknown() {
xxx_messageInfo_LoadMetaInfo.DiscardUnknown(m)
}
var xxx_messageInfo_LoadMetaInfo proto.InternalMessageInfo
func (m *LoadMetaInfo) GetLoadType() LoadType {
if m != nil {
return m.LoadType
}
return LoadType_UnKnownType
}
func (m *LoadMetaInfo) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *LoadMetaInfo) GetPartitionIDs() []int64 {
if m != nil {
return m.PartitionIDs
}
return nil
}
type WatchDmChannelsRequest struct { type WatchDmChannelsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"` NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
@ -1111,6 +1166,7 @@ type WatchDmChannelsRequest struct {
Infos []*datapb.VchannelInfo `protobuf:"bytes,5,rep,name=infos,proto3" json:"infos,omitempty"` Infos []*datapb.VchannelInfo `protobuf:"bytes,5,rep,name=infos,proto3" json:"infos,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"` Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"`
ExcludeInfos []*datapb.SegmentInfo `protobuf:"bytes,7,rep,name=exclude_infos,json=excludeInfos,proto3" json:"exclude_infos,omitempty"` ExcludeInfos []*datapb.SegmentInfo `protobuf:"bytes,7,rep,name=exclude_infos,json=excludeInfos,proto3" json:"exclude_infos,omitempty"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,8,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -1120,7 +1176,7 @@ func (m *WatchDmChannelsRequest) Reset() { *m = WatchDmChannelsRequest{}
func (m *WatchDmChannelsRequest) String() string { return proto.CompactTextString(m) } func (m *WatchDmChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDmChannelsRequest) ProtoMessage() {} func (*WatchDmChannelsRequest) ProtoMessage() {}
func (*WatchDmChannelsRequest) Descriptor() ([]byte, []int) { func (*WatchDmChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{16} return fileDescriptor_aab7cc9a69ed26e8, []int{17}
} }
func (m *WatchDmChannelsRequest) XXX_Unmarshal(b []byte) error { func (m *WatchDmChannelsRequest) XXX_Unmarshal(b []byte) error {
@ -1190,11 +1246,19 @@ func (m *WatchDmChannelsRequest) GetExcludeInfos() []*datapb.SegmentInfo {
return nil return nil
} }
func (m *WatchDmChannelsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
return nil
}
type WatchDeltaChannelsRequest struct { type WatchDeltaChannelsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"` NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"` CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
Infos []*datapb.VchannelInfo `protobuf:"bytes,4,rep,name=infos,proto3" json:"infos,omitempty"` Infos []*datapb.VchannelInfo `protobuf:"bytes,4,rep,name=infos,proto3" json:"infos,omitempty"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,9,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -1204,7 +1268,7 @@ func (m *WatchDeltaChannelsRequest) Reset() { *m = WatchDeltaChannelsReq
func (m *WatchDeltaChannelsRequest) String() string { return proto.CompactTextString(m) } func (m *WatchDeltaChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDeltaChannelsRequest) ProtoMessage() {} func (*WatchDeltaChannelsRequest) ProtoMessage() {}
func (*WatchDeltaChannelsRequest) Descriptor() ([]byte, []int) { func (*WatchDeltaChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{17} return fileDescriptor_aab7cc9a69ed26e8, []int{18}
} }
func (m *WatchDeltaChannelsRequest) XXX_Unmarshal(b []byte) error { func (m *WatchDeltaChannelsRequest) XXX_Unmarshal(b []byte) error {
@ -1253,6 +1317,13 @@ func (m *WatchDeltaChannelsRequest) GetInfos() []*datapb.VchannelInfo {
return nil return nil
} }
func (m *WatchDeltaChannelsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
return nil
}
type SegmentLoadInfo struct { type SegmentLoadInfo struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"` SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"` PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
@ -1275,7 +1346,7 @@ func (m *SegmentLoadInfo) Reset() { *m = SegmentLoadInfo{} }
func (m *SegmentLoadInfo) String() string { return proto.CompactTextString(m) } func (m *SegmentLoadInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentLoadInfo) ProtoMessage() {} func (*SegmentLoadInfo) ProtoMessage() {}
func (*SegmentLoadInfo) Descriptor() ([]byte, []int) { func (*SegmentLoadInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{18} return fileDescriptor_aab7cc9a69ed26e8, []int{19}
} }
func (m *SegmentLoadInfo) XXX_Unmarshal(b []byte) error { func (m *SegmentLoadInfo) XXX_Unmarshal(b []byte) error {
@ -1398,7 +1469,7 @@ func (m *VecFieldIndexInfo) Reset() { *m = VecFieldIndexInfo{} }
func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) } func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) }
func (*VecFieldIndexInfo) ProtoMessage() {} func (*VecFieldIndexInfo) ProtoMessage() {}
func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) { func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19} return fileDescriptor_aab7cc9a69ed26e8, []int{20}
} }
func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error { func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error {
@ -1482,6 +1553,7 @@ type LoadSegmentsRequest struct {
Schema *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"` Schema *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"`
SourceNodeID int64 `protobuf:"varint,5,opt,name=source_nodeID,json=sourceNodeID,proto3" json:"source_nodeID,omitempty"` SourceNodeID int64 `protobuf:"varint,5,opt,name=source_nodeID,json=sourceNodeID,proto3" json:"source_nodeID,omitempty"`
CollectionID int64 `protobuf:"varint,6,opt,name=collectionID,proto3" json:"collectionID,omitempty"` CollectionID int64 `protobuf:"varint,6,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,7,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -1491,7 +1563,7 @@ func (m *LoadSegmentsRequest) Reset() { *m = LoadSegmentsRequest{} }
func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*LoadSegmentsRequest) ProtoMessage() {} func (*LoadSegmentsRequest) ProtoMessage() {}
func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) { func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{20} return fileDescriptor_aab7cc9a69ed26e8, []int{21}
} }
func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1554,6 +1626,13 @@ func (m *LoadSegmentsRequest) GetCollectionID() int64 {
return 0 return 0
} }
func (m *LoadSegmentsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
return nil
}
type ReleaseSegmentsRequest struct { type ReleaseSegmentsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"` Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"` NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
@ -1571,7 +1650,7 @@ func (m *ReleaseSegmentsRequest) Reset() { *m = ReleaseSegmentsRequest{}
func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*ReleaseSegmentsRequest) ProtoMessage() {} func (*ReleaseSegmentsRequest) ProtoMessage() {}
func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) { func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{21} return fileDescriptor_aab7cc9a69ed26e8, []int{22}
} }
func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1647,7 +1726,7 @@ func (m *HandoffSegmentsRequest) Reset() { *m = HandoffSegmentsRequest{}
func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) } func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*HandoffSegmentsRequest) ProtoMessage() {} func (*HandoffSegmentsRequest) ProtoMessage() {}
func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) { func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{22} return fileDescriptor_aab7cc9a69ed26e8, []int{23}
} }
func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error { func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1697,7 +1776,7 @@ func (m *LoadBalanceRequest) Reset() { *m = LoadBalanceRequest{} }
func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) } func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) }
func (*LoadBalanceRequest) ProtoMessage() {} func (*LoadBalanceRequest) ProtoMessage() {}
func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { func (*LoadBalanceRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{23} return fileDescriptor_aab7cc9a69ed26e8, []int{24}
} }
func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error { func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error {
@ -1766,7 +1845,7 @@ func (m *DmChannelWatchInfo) Reset() { *m = DmChannelWatchInfo{} }
func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) } func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) }
func (*DmChannelWatchInfo) ProtoMessage() {} func (*DmChannelWatchInfo) ProtoMessage() {}
func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) { func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{24} return fileDescriptor_aab7cc9a69ed26e8, []int{25}
} }
func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error { func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error {
@ -1823,7 +1902,7 @@ func (m *QueryChannelInfo) Reset() { *m = QueryChannelInfo{} }
func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) } func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) }
func (*QueryChannelInfo) ProtoMessage() {} func (*QueryChannelInfo) ProtoMessage() {}
func (*QueryChannelInfo) Descriptor() ([]byte, []int) { func (*QueryChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{25} return fileDescriptor_aab7cc9a69ed26e8, []int{26}
} }
func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error { func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error {
@ -1892,7 +1971,7 @@ func (m *PartitionStates) Reset() { *m = PartitionStates{} }
func (m *PartitionStates) String() string { return proto.CompactTextString(m) } func (m *PartitionStates) String() string { return proto.CompactTextString(m) }
func (*PartitionStates) ProtoMessage() {} func (*PartitionStates) ProtoMessage() {}
func (*PartitionStates) Descriptor() ([]byte, []int) { func (*PartitionStates) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{26} return fileDescriptor_aab7cc9a69ed26e8, []int{27}
} }
func (m *PartitionStates) XXX_Unmarshal(b []byte) error { func (m *PartitionStates) XXX_Unmarshal(b []byte) error {
@ -1957,7 +2036,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} }
func (m *SegmentInfo) String() string { return proto.CompactTextString(m) } func (m *SegmentInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentInfo) ProtoMessage() {} func (*SegmentInfo) ProtoMessage() {}
func (*SegmentInfo) Descriptor() ([]byte, []int) { func (*SegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{27} return fileDescriptor_aab7cc9a69ed26e8, []int{28}
} }
func (m *SegmentInfo) XXX_Unmarshal(b []byte) error { func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
@ -2086,7 +2165,7 @@ func (m *CollectionInfo) Reset() { *m = CollectionInfo{} }
func (m *CollectionInfo) String() string { return proto.CompactTextString(m) } func (m *CollectionInfo) String() string { return proto.CompactTextString(m) }
func (*CollectionInfo) ProtoMessage() {} func (*CollectionInfo) ProtoMessage() {}
func (*CollectionInfo) Descriptor() ([]byte, []int) { func (*CollectionInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{28} return fileDescriptor_aab7cc9a69ed26e8, []int{29}
} }
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error { func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
@ -2132,7 +2211,7 @@ func (m *CollectionInfo) GetLoadType() LoadType {
if m != nil { if m != nil {
return m.LoadType return m.LoadType
} }
return LoadType_UnKnowType return LoadType_UnKnownType
} }
func (m *CollectionInfo) GetSchema() *schemapb.CollectionSchema { func (m *CollectionInfo) GetSchema() *schemapb.CollectionSchema {
@ -2168,7 +2247,7 @@ func (m *UnsubscribeChannels) Reset() { *m = UnsubscribeChannels{} }
func (m *UnsubscribeChannels) String() string { return proto.CompactTextString(m) } func (m *UnsubscribeChannels) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeChannels) ProtoMessage() {} func (*UnsubscribeChannels) ProtoMessage() {}
func (*UnsubscribeChannels) Descriptor() ([]byte, []int) { func (*UnsubscribeChannels) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{29} return fileDescriptor_aab7cc9a69ed26e8, []int{30}
} }
func (m *UnsubscribeChannels) XXX_Unmarshal(b []byte) error { func (m *UnsubscribeChannels) XXX_Unmarshal(b []byte) error {
@ -2215,7 +2294,7 @@ func (m *UnsubscribeChannelInfo) Reset() { *m = UnsubscribeChannelInfo{}
func (m *UnsubscribeChannelInfo) String() string { return proto.CompactTextString(m) } func (m *UnsubscribeChannelInfo) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeChannelInfo) ProtoMessage() {} func (*UnsubscribeChannelInfo) ProtoMessage() {}
func (*UnsubscribeChannelInfo) Descriptor() ([]byte, []int) { func (*UnsubscribeChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{30} return fileDescriptor_aab7cc9a69ed26e8, []int{31}
} }
func (m *UnsubscribeChannelInfo) XXX_Unmarshal(b []byte) error { func (m *UnsubscribeChannelInfo) XXX_Unmarshal(b []byte) error {
@ -2265,7 +2344,7 @@ func (m *SegmentChangeInfo) Reset() { *m = SegmentChangeInfo{} }
func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) } func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentChangeInfo) ProtoMessage() {} func (*SegmentChangeInfo) ProtoMessage() {}
func (*SegmentChangeInfo) Descriptor() ([]byte, []int) { func (*SegmentChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{31} return fileDescriptor_aab7cc9a69ed26e8, []int{32}
} }
func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error { func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2326,7 +2405,7 @@ func (m *SealedSegmentsChangeInfo) Reset() { *m = SealedSegmentsChangeIn
func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) } func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SealedSegmentsChangeInfo) ProtoMessage() {} func (*SealedSegmentsChangeInfo) ProtoMessage() {}
func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) { func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{32} return fileDescriptor_aab7cc9a69ed26e8, []int{33}
} }
func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error { func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2381,6 +2460,7 @@ func init() {
proto.RegisterType((*GetSegmentInfoResponse)(nil), "milvus.proto.query.GetSegmentInfoResponse") proto.RegisterType((*GetSegmentInfoResponse)(nil), "milvus.proto.query.GetSegmentInfoResponse")
proto.RegisterType((*AddQueryChannelRequest)(nil), "milvus.proto.query.AddQueryChannelRequest") proto.RegisterType((*AddQueryChannelRequest)(nil), "milvus.proto.query.AddQueryChannelRequest")
proto.RegisterType((*RemoveQueryChannelRequest)(nil), "milvus.proto.query.RemoveQueryChannelRequest") proto.RegisterType((*RemoveQueryChannelRequest)(nil), "milvus.proto.query.RemoveQueryChannelRequest")
proto.RegisterType((*LoadMetaInfo)(nil), "milvus.proto.query.LoadMetaInfo")
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest") proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest") proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest")
proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo") proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo")
@ -2403,154 +2483,158 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) } func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{ var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2345 bytes of a gzipped FileDescriptorProto // 2401 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x39, 0xcd, 0x6f, 0x1c, 0x49, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3a, 0xcd, 0x73, 0x1b, 0x49,
0xf5, 0xee, 0x99, 0xf1, 0xd8, 0xf3, 0x66, 0x3c, 0x1e, 0x97, 0x13, 0xff, 0x26, 0xf3, 0xcb, 0x66, 0xf5, 0x1e, 0x49, 0x96, 0xad, 0x27, 0x59, 0x92, 0xdb, 0x89, 0x7f, 0x8a, 0x7e, 0xd9, 0x6c, 0x76,
0xb3, 0xbd, 0x9b, 0x0f, 0xb2, 0xac, 0x13, 0x1c, 0x90, 0x58, 0x01, 0x87, 0xc4, 0x26, 0x5e, 0x93, 0x76, 0xf3, 0x41, 0x96, 0x75, 0x82, 0x03, 0x55, 0x6c, 0x01, 0x87, 0xb5, 0x4d, 0xbc, 0x26, 0x1b,
0x8d, 0xd7, 0xb4, 0x9d, 0x00, 0x51, 0xa4, 0xa6, 0x67, 0xba, 0x66, 0xdc, 0x4a, 0x77, 0xd7, 0xa4, 0xaf, 0x19, 0x3b, 0x01, 0x52, 0xa9, 0x12, 0x23, 0x4d, 0x4b, 0x9e, 0xca, 0xcc, 0xb4, 0x32, 0x3d,
0xab, 0x67, 0x13, 0x87, 0x0b, 0x07, 0x0e, 0x0b, 0x12, 0xe2, 0x8e, 0x10, 0x27, 0x10, 0xe4, 0xb0, 0xda, 0xc4, 0xe1, 0xc2, 0x81, 0xc3, 0x42, 0x15, 0x45, 0x71, 0xa5, 0x28, 0x4e, 0x50, 0xb0, 0x87,
0x17, 0xfe, 0x82, 0x5c, 0xf8, 0x37, 0x10, 0x07, 0xf8, 0x13, 0x38, 0x22, 0xa1, 0xfa, 0xe8, 0x9e, 0xbd, 0xf0, 0x17, 0xec, 0x85, 0x7f, 0x83, 0xe2, 0xc0, 0x81, 0x7f, 0x80, 0x23, 0x05, 0xd5, 0x1f,
0xfe, 0xa8, 0xb6, 0xdb, 0xb6, 0xbc, 0x89, 0x10, 0xb7, 0xae, 0xd7, 0xaf, 0xde, 0x7b, 0xf5, 0xbe, 0x33, 0x9a, 0x8f, 0x1e, 0x7b, 0x64, 0x97, 0x37, 0x29, 0x8a, 0x9b, 0xfa, 0xcd, 0xeb, 0xf7, 0x5e,
0xab, 0x1e, 0x2c, 0x3d, 0x9b, 0xe0, 0xe0, 0xc0, 0x1c, 0x10, 0x12, 0xd8, 0xab, 0xe3, 0x80, 0x84, 0xbf, 0xef, 0xee, 0x27, 0x58, 0x7e, 0x36, 0xc1, 0xfe, 0x51, 0x6f, 0x40, 0x88, 0x6f, 0xad, 0x8d,
0x04, 0x21, 0xcf, 0x71, 0x3f, 0x9f, 0x50, 0xb1, 0x5a, 0xe5, 0xff, 0x7b, 0xad, 0x01, 0xf1, 0x3c, 0x7d, 0x12, 0x10, 0x84, 0x5c, 0xdb, 0xf9, 0x64, 0x42, 0xc5, 0x6a, 0x8d, 0x7f, 0xef, 0x36, 0x06,
0xe2, 0x0b, 0x58, 0xaf, 0x95, 0xc4, 0xe8, 0xb5, 0x1d, 0x3f, 0xc4, 0x81, 0x6f, 0xb9, 0xd1, 0x5f, 0xc4, 0x75, 0x89, 0x27, 0x60, 0xdd, 0x46, 0x1c, 0xa3, 0xdb, 0xb4, 0xbd, 0x00, 0xfb, 0x9e, 0xe9,
0x3a, 0xd8, 0xc7, 0x9e, 0x25, 0x57, 0x1d, 0xdb, 0x0a, 0xad, 0x24, 0x7d, 0xfd, 0x17, 0x1a, 0xac, 0x84, 0x5f, 0xe9, 0xe0, 0x10, 0xbb, 0xa6, 0x5c, 0xb5, 0x2d, 0x33, 0x30, 0xe3, 0xf4, 0xf5, 0x9f,
0xec, 0xee, 0x93, 0xe7, 0xeb, 0xc4, 0x75, 0xf1, 0x20, 0x74, 0x88, 0x4f, 0x0d, 0xfc, 0x6c, 0x82, 0x69, 0xb0, 0xba, 0x7f, 0x48, 0x9e, 0x6f, 0x12, 0xc7, 0xc1, 0x83, 0xc0, 0x26, 0x1e, 0x35, 0xf0,
0x69, 0x88, 0x6e, 0x41, 0xad, 0x6f, 0x51, 0xdc, 0xd5, 0x2e, 0x6b, 0xd7, 0x9b, 0x6b, 0x17, 0x57, 0xb3, 0x09, 0xa6, 0x01, 0xba, 0x03, 0x95, 0xbe, 0x49, 0x71, 0x47, 0xbb, 0xaa, 0xdd, 0xac, 0xaf,
0x53, 0x92, 0x48, 0x11, 0x1e, 0xd0, 0xd1, 0x5d, 0x8b, 0x62, 0x83, 0x63, 0x22, 0x04, 0x35, 0xbb, 0x5f, 0x5e, 0x4b, 0x48, 0x22, 0x45, 0x78, 0x40, 0x47, 0x1b, 0x26, 0xc5, 0x06, 0xc7, 0x44, 0x08,
0xbf, 0xb5, 0xd1, 0xad, 0x5c, 0xd6, 0xae, 0x57, 0x0d, 0xfe, 0x8d, 0x3e, 0x80, 0x85, 0x41, 0x4c, 0x2a, 0x56, 0x7f, 0x67, 0xab, 0x53, 0xba, 0xaa, 0xdd, 0x2c, 0x1b, 0xfc, 0x37, 0x7a, 0x07, 0x96,
0x7b, 0x6b, 0x83, 0x76, 0xab, 0x97, 0xab, 0xd7, 0xab, 0x46, 0x1a, 0xa8, 0xff, 0x49, 0x83, 0xff, 0x06, 0x11, 0xed, 0x9d, 0x2d, 0xda, 0x29, 0x5f, 0x2d, 0xdf, 0x2c, 0x1b, 0x49, 0xa0, 0xfe, 0x47,
0xcb, 0x89, 0x41, 0xc7, 0xc4, 0xa7, 0x18, 0xdd, 0x86, 0x3a, 0x0d, 0xad, 0x70, 0x42, 0xa5, 0x24, 0x0d, 0xfe, 0x2f, 0x23, 0x06, 0x1d, 0x13, 0x8f, 0x62, 0x74, 0x17, 0xaa, 0x34, 0x30, 0x83, 0x09,
0xff, 0xaf, 0x94, 0x64, 0x97, 0xa3, 0x18, 0x12, 0x35, 0xcf, 0xb6, 0xa2, 0x60, 0x8b, 0xbe, 0x01, 0x95, 0x92, 0xfc, 0xbf, 0x52, 0x92, 0x7d, 0x8e, 0x62, 0x48, 0xd4, 0x2c, 0xdb, 0x92, 0x82, 0x2d,
0xe7, 0x1c, 0xff, 0x01, 0xf6, 0x48, 0x70, 0x60, 0x8e, 0x71, 0x30, 0xc0, 0x7e, 0x68, 0x8d, 0x70, 0xfa, 0x1a, 0x5c, 0xb0, 0xbd, 0x07, 0xd8, 0x25, 0xfe, 0x51, 0x6f, 0x8c, 0xfd, 0x01, 0xf6, 0x02,
0x24, 0xe3, 0x72, 0xf4, 0x6f, 0x67, 0xfa, 0x4b, 0xff, 0xa3, 0x06, 0xe7, 0x99, 0xa4, 0x3b, 0x56, 0x73, 0x84, 0x43, 0x19, 0x57, 0xc2, 0x6f, 0x7b, 0xd3, 0x4f, 0xfa, 0x1f, 0x34, 0xb8, 0xc8, 0x24,
0x10, 0x3a, 0x67, 0xa0, 0x2f, 0x1d, 0x5a, 0x49, 0x19, 0xbb, 0x55, 0xfe, 0x2f, 0x05, 0x63, 0x38, 0xdd, 0x33, 0xfd, 0xc0, 0x3e, 0x07, 0x7d, 0xe9, 0xd0, 0x88, 0xcb, 0xd8, 0x29, 0xf3, 0x6f, 0x09,
0xe3, 0x88, 0x3d, 0x3b, 0x5b, 0x8d, 0x8b, 0x9b, 0x82, 0xe9, 0x7f, 0x90, 0x86, 0x4d, 0xca, 0x79, 0x18, 0xc3, 0x19, 0x87, 0xec, 0xd9, 0xd9, 0x2a, 0x5c, 0xdc, 0x04, 0x4c, 0xff, 0xbd, 0x34, 0x6c,
0x1a, 0x85, 0x66, 0x79, 0x56, 0xf2, 0x3c, 0x4f, 0xa2, 0xce, 0xd7, 0x1a, 0x9c, 0xff, 0x94, 0x58, 0x5c, 0xce, 0xb3, 0x28, 0x34, 0xcd, 0xb3, 0x94, 0xe5, 0x79, 0x1a, 0x75, 0x7e, 0xa1, 0xc1, 0xc5,
0xf6, 0xd4, 0xf0, 0x5f, 0xbd, 0x3a, 0xbf, 0x07, 0x75, 0x11, 0x25, 0xdd, 0x1a, 0xe7, 0x75, 0x25, 0x8f, 0x88, 0x69, 0x4d, 0x0d, 0xff, 0xe5, 0xab, 0xf3, 0x3b, 0x50, 0x15, 0x51, 0xd2, 0xa9, 0x70,
0xcd, 0x4b, 0x46, 0xd0, 0x54, 0xc2, 0x5d, 0x0e, 0x30, 0xe4, 0x26, 0xfd, 0x77, 0x1a, 0x74, 0x0d, 0x5e, 0xd7, 0x92, 0xbc, 0x64, 0x04, 0x4d, 0x25, 0xdc, 0xe7, 0x00, 0x43, 0x6e, 0xd2, 0x7f, 0xab,
0xec, 0x62, 0x8b, 0xe2, 0x37, 0x79, 0x8a, 0x15, 0xa8, 0xfb, 0xc4, 0xc6, 0x5b, 0x1b, 0xfc, 0x14, 0x41, 0xc7, 0xc0, 0x0e, 0x36, 0x29, 0x7e, 0x95, 0xa7, 0x58, 0x85, 0xaa, 0x47, 0x2c, 0xbc, 0xb3,
0x55, 0x43, 0xae, 0xf4, 0x7f, 0x48, 0x0d, 0xbf, 0xe5, 0x0e, 0x9b, 0xb0, 0xc2, 0xec, 0x49, 0xac, 0xc5, 0x4f, 0x51, 0x36, 0xe4, 0x4a, 0xff, 0xbb, 0xd4, 0xf0, 0x6b, 0xee, 0xb0, 0x31, 0x2b, 0xcc,
0xf0, 0x7a, 0x6a, 0x85, 0xb7, 0xfd, 0xa4, 0x53, 0x4b, 0xcd, 0xa6, 0x2c, 0xf5, 0x13, 0xb8, 0xb0, 0x9f, 0xc6, 0x0a, 0x5f, 0x4c, 0xad, 0xf0, 0xba, 0x9f, 0x74, 0x6a, 0xa9, 0xf9, 0x84, 0xa5, 0x7e,
0x1e, 0x60, 0x2b, 0xc4, 0x3f, 0x64, 0x69, 0x7e, 0x7d, 0xdf, 0xf2, 0x7d, 0xec, 0x46, 0x47, 0xc8, 0x04, 0x97, 0x36, 0x7d, 0x6c, 0x06, 0xf8, 0xfb, 0x2c, 0xcd, 0x6f, 0x1e, 0x9a, 0x9e, 0x87, 0x9d,
0x32, 0xd7, 0x14, 0xcc, 0xbb, 0x30, 0x37, 0x0e, 0xc8, 0x8b, 0x83, 0x58, 0xee, 0x68, 0xa9, 0xff, 0xf0, 0x08, 0x69, 0xe6, 0x9a, 0x82, 0x79, 0x07, 0x16, 0xc6, 0x3e, 0x79, 0x71, 0x14, 0xc9, 0x1d,
0x59, 0x83, 0x9e, 0x8a, 0xf6, 0x69, 0x32, 0xc2, 0xfb, 0xb0, 0x20, 0xeb, 0x95, 0xa0, 0xc6, 0x79, 0x2e, 0xf5, 0x3f, 0x69, 0xd0, 0x55, 0xd1, 0x3e, 0x4b, 0x46, 0x78, 0x1b, 0x96, 0x64, 0xbd, 0x12,
0x36, 0x8c, 0xd6, 0xb3, 0x04, 0x07, 0x74, 0x0b, 0xce, 0x09, 0xa4, 0x00, 0xd3, 0x89, 0x1b, 0xc6, 0xd4, 0x38, 0xcf, 0x9a, 0xd1, 0x78, 0x16, 0xe3, 0x80, 0xee, 0xc0, 0x05, 0x81, 0xe4, 0x63, 0x3a,
0xb8, 0x55, 0x8e, 0x8b, 0xf8, 0x3f, 0x83, 0xff, 0x92, 0x3b, 0xf4, 0x57, 0x1a, 0x5c, 0xd8, 0xc4, 0x71, 0x82, 0x08, 0xb7, 0xcc, 0x71, 0x11, 0xff, 0x66, 0xf0, 0x4f, 0x72, 0x87, 0xfe, 0x99, 0x06,
0x61, 0x6c, 0x44, 0xc6, 0x15, 0xbf, 0xa5, 0x49, 0xf6, 0x4b, 0x0d, 0x7a, 0x2a, 0x59, 0x4f, 0xa3, 0x97, 0xb6, 0x71, 0x10, 0x19, 0x91, 0x71, 0xc5, 0xaf, 0x69, 0x92, 0xfd, 0x5c, 0x83, 0xae, 0x4a,
0xd6, 0xc7, 0xb0, 0x12, 0xf3, 0x30, 0x6d, 0x4c, 0x07, 0x81, 0x33, 0xe6, 0xce, 0xcc, 0x53, 0x6e, 0xd6, 0xb3, 0xa8, 0xf5, 0x31, 0xac, 0x46, 0x3c, 0x7a, 0x16, 0xa6, 0x03, 0xdf, 0x1e, 0x73, 0x67,
0x73, 0xed, 0xfd, 0xd5, 0x7c, 0x4b, 0xb0, 0x9a, 0x95, 0xe0, 0x7c, 0x4c, 0x62, 0x23, 0x41, 0x41, 0xe6, 0x29, 0xb7, 0xbe, 0xfe, 0xf6, 0x5a, 0xb6, 0x25, 0x58, 0x4b, 0x4b, 0x70, 0x31, 0x22, 0xb1,
0xff, 0xb5, 0x06, 0xe7, 0x37, 0x71, 0xb8, 0x8b, 0x47, 0x1e, 0xf6, 0xc3, 0x2d, 0x7f, 0x48, 0x4e, 0x15, 0xa3, 0xa0, 0xff, 0x52, 0x83, 0x8b, 0xdb, 0x38, 0xd8, 0xc7, 0x23, 0x17, 0x7b, 0xc1, 0x8e,
0xae, 0xd7, 0x4b, 0x00, 0x54, 0xd2, 0x89, 0xcb, 0x41, 0x02, 0x52, 0x46, 0xc7, 0xbc, 0xfb, 0xc8, 0x37, 0x24, 0xa7, 0xd7, 0xeb, 0x15, 0x00, 0x2a, 0xe9, 0x44, 0xe5, 0x20, 0x06, 0x29, 0xa2, 0x63,
0xca, 0x73, 0x1a, 0xdd, 0x7d, 0x0b, 0x66, 0x1d, 0x7f, 0x48, 0x22, 0x55, 0xbd, 0xab, 0x52, 0x55, 0xde, 0x7d, 0xa4, 0xe5, 0x39, 0x8b, 0xee, 0xbe, 0x01, 0xf3, 0xb6, 0x37, 0x24, 0xa1, 0xaa, 0xde,
0x92, 0x99, 0xc0, 0xd6, 0xff, 0x5d, 0x81, 0x95, 0x3b, 0xb6, 0xad, 0x0a, 0xbb, 0xe3, 0xeb, 0x65, 0x54, 0xa9, 0x2a, 0xce, 0x4c, 0x60, 0xeb, 0xff, 0x2a, 0xc1, 0xea, 0x07, 0x96, 0xa5, 0x0a, 0xbb,
0x1a, 0xdd, 0x95, 0x64, 0x74, 0x97, 0xf2, 0xb9, 0x5c, 0x48, 0xd5, 0x8e, 0x11, 0x52, 0xb3, 0x45, 0xd9, 0xf5, 0x32, 0x8d, 0xee, 0x52, 0x3c, 0xba, 0x0b, 0xf9, 0x5c, 0x26, 0xa4, 0x2a, 0x33, 0x84,
0x21, 0x85, 0x36, 0x61, 0x81, 0x62, 0xfc, 0xd4, 0x1c, 0x13, 0xca, 0x7d, 0xa2, 0x5b, 0xe7, 0xa7, 0xd4, 0x7c, 0x5e, 0x48, 0xa1, 0x6d, 0x58, 0xa2, 0x18, 0x3f, 0xed, 0x8d, 0x09, 0xe5, 0x3e, 0xd1,
0xd1, 0xd3, 0xa7, 0x89, 0x3b, 0xc7, 0x07, 0x74, 0xb4, 0x23, 0x31, 0x8d, 0x16, 0xdb, 0x18, 0xad, 0xa9, 0xf2, 0xd3, 0xe8, 0xc9, 0xd3, 0x44, 0x9d, 0xe3, 0x03, 0x3a, 0xda, 0x93, 0x98, 0x46, 0x83,
0xd0, 0x43, 0x58, 0x19, 0xb9, 0xa4, 0x6f, 0xb9, 0x26, 0xc5, 0x96, 0x8b, 0x6d, 0x53, 0xda, 0x9b, 0x6d, 0x0c, 0x57, 0xe8, 0x21, 0xac, 0x8e, 0x1c, 0xd2, 0x37, 0x9d, 0x1e, 0xc5, 0xa6, 0x83, 0xad,
0x76, 0xe7, 0xca, 0x29, 0xfc, 0x9c, 0xd8, 0xbe, 0xcb, 0x77, 0xcb, 0x1f, 0x54, 0xff, 0xbb, 0x06, 0x9e, 0xb4, 0x37, 0xed, 0x2c, 0x14, 0x53, 0xf8, 0x05, 0xb1, 0x7d, 0x9f, 0xef, 0x96, 0x1f, 0xa8,
0x17, 0x0c, 0xec, 0x91, 0xcf, 0xf1, 0x7f, 0xab, 0x09, 0xf4, 0x7f, 0x56, 0x60, 0xe5, 0x47, 0x56, 0xfe, 0x37, 0x0d, 0x2e, 0x19, 0xd8, 0x25, 0x9f, 0xe0, 0xff, 0x56, 0x13, 0xe8, 0xbf, 0xd6, 0xa0,
0x38, 0xd8, 0xdf, 0xf0, 0x24, 0x88, 0xbe, 0x99, 0xf3, 0x95, 0x29, 0x50, 0x71, 0x18, 0xcd, 0xaa, 0xc1, 0xaa, 0xf0, 0x03, 0x1c, 0x98, 0x4c, 0x13, 0xe8, 0x7d, 0xa8, 0x39, 0xc4, 0xb4, 0x7a, 0xc1,
0xac, 0xca, 0xee, 0x10, 0xab, 0x8f, 0xe4, 0x91, 0x13, 0x61, 0x94, 0xa8, 0xe0, 0xf5, 0x13, 0x54, 0xd1, 0x58, 0x1c, 0xad, 0x99, 0x3e, 0x9a, 0xd0, 0x1e, 0xdb, 0x74, 0x70, 0x34, 0xc6, 0xc6, 0xa2,
0x70, 0xb4, 0x0e, 0x0b, 0xf8, 0xc5, 0xc0, 0x9d, 0xd8, 0xd8, 0x14, 0xdc, 0x85, 0x4f, 0x5d, 0x52, 0x23, 0x7f, 0x65, 0x8e, 0x51, 0x2a, 0x90, 0xbd, 0xca, 0xaa, 0x16, 0xb1, 0x0c, 0xab, 0x3f, 0x30,
0x70, 0x4f, 0xba, 0x54, 0x4b, 0x6e, 0xda, 0xe2, 0xa1, 0xfc, 0x5a, 0x83, 0x0b, 0x42, 0xcf, 0xd8, 0x83, 0xc1, 0xe1, 0x96, 0x2b, 0xc5, 0xa4, 0xaf, 0x46, 0xe7, 0x45, 0x8a, 0x66, 0x14, 0xda, 0xf3,
0x0d, 0xad, 0x37, 0xab, 0xea, 0x58, 0x8d, 0xb5, 0xe3, 0xa8, 0x51, 0xff, 0x6d, 0x0d, 0x16, 0xe5, 0x2a, 0x4f, 0x63, 0xf7, 0x9a, 0xb5, 0x47, 0xd2, 0x0c, 0xb1, 0xd0, 0x8e, 0x75, 0x15, 0xd5, 0x53,
0x01, 0x59, 0xdf, 0xc6, 0x7e, 0xa1, 0x8b, 0xd0, 0x88, 0x53, 0xab, 0x2c, 0xfd, 0x53, 0x00, 0xba, 0x74, 0x15, 0x68, 0x13, 0x96, 0xf0, 0x8b, 0x81, 0x33, 0xb1, 0x70, 0x4f, 0x70, 0x17, 0x7e, 0x7e,
0x0c, 0xcd, 0x84, 0xfd, 0xa4, 0xa4, 0x49, 0x50, 0x29, 0x71, 0xa3, 0x42, 0x59, 0x4b, 0x14, 0xca, 0x45, 0xc1, 0x3d, 0xee, 0xe6, 0x0d, 0xb9, 0x69, 0x47, 0xca, 0x20, 0x4c, 0xed, 0xe2, 0xc0, 0xec,
0x77, 0x00, 0x86, 0xee, 0x84, 0xee, 0x9b, 0xa1, 0xe3, 0x61, 0xd9, 0xae, 0x34, 0x38, 0x64, 0xcf, 0x2c, 0x72, 0x31, 0xae, 0xe6, 0x99, 0x3a, 0xf4, 0x0f, 0x61, 0x6e, 0xb6, 0xd2, 0xff, 0xad, 0xc1,
0xf1, 0x30, 0xba, 0x03, 0xad, 0xbe, 0xe3, 0xbb, 0x64, 0x64, 0x8e, 0xad, 0x70, 0x9f, 0x76, 0xeb, 0x25, 0x61, 0x26, 0xec, 0x04, 0xe6, 0xab, 0xb5, 0x54, 0x64, 0x85, 0xca, 0x8c, 0x56, 0x88, 0x69,
0x85, 0x16, 0xbb, 0xe7, 0x60, 0xd7, 0xbe, 0xcb, 0x71, 0x8d, 0xa6, 0xd8, 0xb3, 0xc3, 0xb6, 0xa0, 0xa0, 0x36, 0xb3, 0x06, 0x7e, 0x53, 0x81, 0x96, 0x54, 0x2f, 0xc3, 0xe0, 0xf1, 0x73, 0x19, 0x6a,
0x4b, 0xd0, 0xf4, 0x27, 0x9e, 0x49, 0x86, 0x66, 0x40, 0x9e, 0x33, 0x9b, 0x73, 0x16, 0xfe, 0xc4, 0x51, 0xb1, 0x91, 0xcd, 0xd0, 0x14, 0x80, 0xae, 0x42, 0x3d, 0xe6, 0x3d, 0xf2, 0xa0, 0x71, 0x50,
0xfb, 0x6c, 0x68, 0x90, 0xe7, 0x14, 0x7d, 0x17, 0x1a, 0x2c, 0xb9, 0x53, 0x97, 0x8c, 0x68, 0x77, 0xa1, 0xd3, 0x86, 0xad, 0x43, 0x25, 0xd6, 0x3a, 0xbc, 0x01, 0x30, 0x74, 0x26, 0xf4, 0xb0, 0x17,
0xbe, 0x14, 0xfd, 0xe9, 0x06, 0xb6, 0xdb, 0x66, 0x8e, 0xc0, 0x77, 0x37, 0xca, 0xed, 0x8e, 0x37, 0xd8, 0x2e, 0x96, 0x0d, 0x5c, 0x8d, 0x43, 0x0e, 0x6c, 0x17, 0xa3, 0x0f, 0xa0, 0xd1, 0xb7, 0x3d,
0xa0, 0xab, 0xd0, 0x1e, 0x10, 0x6f, 0x6c, 0x71, 0x0d, 0xdd, 0x0b, 0x88, 0xd7, 0x05, 0x1e, 0x2d, 0x87, 0x8c, 0x7a, 0x63, 0x33, 0x38, 0xa4, 0x9d, 0x6a, 0xae, 0xbf, 0xdc, 0xb3, 0xb1, 0x63, 0x6d,
0x19, 0x28, 0xba, 0x07, 0x4d, 0xc7, 0xb7, 0xf1, 0x0b, 0xe9, 0xb7, 0x4d, 0xce, 0xe7, 0x8a, 0x2a, 0x70, 0x5c, 0xa3, 0x2e, 0xf6, 0xec, 0xb1, 0x2d, 0xe8, 0x0a, 0xd4, 0xbd, 0x89, 0xdb, 0x23, 0xc3,
0x17, 0x3e, 0xc2, 0x03, 0xce, 0x6b, 0x8b, 0xa1, 0x73, 0xa3, 0x83, 0x13, 0x7d, 0x52, 0xf4, 0x1e, 0x9e, 0x4f, 0x9e, 0x33, 0x8f, 0xe3, 0x2c, 0xbc, 0x89, 0xfb, 0xf1, 0xd0, 0x20, 0xcf, 0x29, 0xfa,
0xb4, 0xa4, 0x51, 0x4d, 0xea, 0xbc, 0xc4, 0xdd, 0x96, 0x30, 0xa4, 0x84, 0xed, 0x3a, 0x2f, 0xb1, 0x36, 0xd4, 0x58, 0xb9, 0xa3, 0x0e, 0x19, 0xd1, 0xce, 0x62, 0x21, 0xfa, 0xd3, 0x0d, 0x6c, 0xb7,
0xfe, 0x97, 0x0a, 0x2c, 0xe5, 0x88, 0xb0, 0xc6, 0x6f, 0xc8, 0x21, 0x91, 0x73, 0x44, 0x4b, 0x46, 0xc5, 0xfc, 0x88, 0xef, 0xae, 0x15, 0xdb, 0x1d, 0x6d, 0x40, 0xd7, 0xa1, 0x39, 0x20, 0xee, 0xd8,
0x12, 0xfb, 0x56, 0xdf, 0x65, 0x31, 0x65, 0xe3, 0x17, 0xdc, 0x37, 0xe6, 0x8d, 0xa6, 0x80, 0x71, 0xe4, 0x1a, 0xba, 0xe7, 0x13, 0xb7, 0x03, 0x3c, 0x56, 0x53, 0x50, 0x74, 0x0f, 0xea, 0xb6, 0x67,
0x02, 0xcc, 0xc6, 0x42, 0x7a, 0xdf, 0xf2, 0xb0, 0x6c, 0xcc, 0x1a, 0x1c, 0xb2, 0x6d, 0x79, 0x98, 0xe1, 0x17, 0x32, 0x6a, 0xea, 0x9c, 0xcf, 0x35, 0x95, 0xc9, 0x1f, 0xe1, 0x01, 0xe7, 0xb5, 0xc3,
0xd1, 0x16, 0x22, 0x46, 0x9e, 0x11, 0x2d, 0xd9, 0x9f, 0xfe, 0xc4, 0xe1, 0x5c, 0x85, 0x67, 0x44, 0xd0, 0xb9, 0xdd, 0xc1, 0x0e, 0x7f, 0x52, 0xf4, 0x16, 0x34, 0xa4, 0x51, 0x7b, 0xd4, 0x7e, 0x89,
0x4b, 0xb4, 0x01, 0x2d, 0x41, 0x72, 0x6c, 0x05, 0x96, 0x17, 0xf9, 0xc5, 0x7b, 0xca, 0x78, 0xbb, 0x3b, 0x0d, 0x61, 0x48, 0x09, 0xdb, 0xb7, 0x5f, 0x62, 0xfd, 0xcf, 0x25, 0x58, 0xce, 0x10, 0x61,
0x8f, 0x0f, 0x1e, 0x59, 0xee, 0x04, 0xef, 0x58, 0x4e, 0x60, 0x08, 0x3d, 0xee, 0xf0, 0x5d, 0xe8, 0xad, 0xf0, 0x90, 0x43, 0x42, 0xe7, 0x08, 0x97, 0x8c, 0x24, 0xf6, 0xcc, 0xbe, 0xc3, 0x22, 0xda,
0x3a, 0x74, 0x04, 0x95, 0xa1, 0xe3, 0x62, 0xe9, 0x61, 0x2c, 0x27, 0x34, 0x8c, 0x36, 0x87, 0xdf, 0xc2, 0x2f, 0xb8, 0x6f, 0x2c, 0x1a, 0x75, 0x01, 0xe3, 0x04, 0x98, 0x8d, 0x85, 0xf4, 0x9e, 0xe9,
0x73, 0x5c, 0x2c, 0x9c, 0x28, 0x3e, 0x02, 0x57, 0xdb, 0xbc, 0xf0, 0x21, 0x0e, 0xe1, 0x4a, 0x7b, 0x62, 0xd9, 0xaa, 0xd6, 0x38, 0x64, 0xd7, 0x74, 0x31, 0xa3, 0x2d, 0x44, 0x0c, 0x3d, 0x23, 0x5c,
0x55, 0x81, 0x65, 0x16, 0x4a, 0x51, 0xc1, 0x39, 0x79, 0x3a, 0x78, 0x07, 0xc0, 0xa6, 0xa1, 0x99, 0xb2, 0x2f, 0xfd, 0x89, 0xcd, 0xb9, 0x0a, 0xcf, 0x08, 0x97, 0x68, 0x0b, 0x1a, 0x82, 0xe4, 0xd8,
0x4a, 0x09, 0x0d, 0x9b, 0x86, 0xdb, 0x22, 0x2b, 0x7c, 0x1c, 0x45, 0x7c, 0xb5, 0xb8, 0x55, 0xcb, 0xf4, 0x4d, 0x37, 0xf4, 0x8b, 0xb7, 0x94, 0xe1, 0x7a, 0x1f, 0x1f, 0x3d, 0x32, 0x9d, 0x09, 0xde,
0x84, 0x76, 0x3e, 0x79, 0x9e, 0xe4, 0x12, 0xca, 0xca, 0x16, 0x25, 0x93, 0x60, 0x80, 0xcd, 0xd4, 0x33, 0x6d, 0xdf, 0x10, 0x7a, 0xdc, 0xe3, 0xbb, 0xd0, 0x4d, 0x68, 0x0b, 0x2a, 0x43, 0xdb, 0xc1,
0xd5, 0xa2, 0x25, 0x80, 0xdb, 0xea, 0xa4, 0x55, 0x57, 0xb4, 0x64, 0x7f, 0xd3, 0x60, 0x45, 0xde, 0xd2, 0xc3, 0x58, 0x46, 0xaa, 0x19, 0x4d, 0x0e, 0xbf, 0x67, 0x3b, 0x58, 0x38, 0x51, 0x74, 0x04,
0xa3, 0x4e, 0xaf, 0xae, 0xa2, 0xec, 0x19, 0xa5, 0x9a, 0xea, 0x21, 0x3d, 0x79, 0xad, 0x44, 0xf1, 0xae, 0xb6, 0x45, 0xe1, 0x43, 0x1c, 0xc2, 0x95, 0xf6, 0x8f, 0x12, 0xac, 0xb0, 0x50, 0x0a, 0x4b,
0x9a, 0x55, 0x14, 0xaf, 0x74, 0x5f, 0x5a, 0xcf, 0xf6, 0xa5, 0xfa, 0x6f, 0x34, 0x58, 0xf9, 0xc4, 0xf0, 0xe9, 0xb3, 0xc9, 0x1b, 0x00, 0x16, 0x0d, 0x7a, 0x89, 0x8c, 0x52, 0xb3, 0x68, 0xb0, 0x2b,
0xf2, 0x6d, 0x32, 0x1c, 0x9e, 0xfe, 0x80, 0xeb, 0x71, 0xc4, 0x6e, 0x1d, 0xa7, 0xef, 0x4c, 0x6d, 0x92, 0xca, 0xfb, 0x61, 0xc2, 0x28, 0xe7, 0x37, 0xaf, 0xa9, 0xd0, 0xce, 0xa6, 0xee, 0xd3, 0x5c,
0xd2, 0xbf, 0xa8, 0x00, 0x62, 0xee, 0x70, 0xd7, 0x72, 0x2d, 0x7f, 0x80, 0x4f, 0x2e, 0xcd, 0x15, 0xcb, 0x59, 0x21, 0xa7, 0x64, 0xe2, 0x0f, 0x70, 0x2f, 0x71, 0xd9, 0x6a, 0x08, 0xe0, 0xae, 0x3a,
0x68, 0xa7, 0x9c, 0x20, 0x7e, 0xf5, 0x4a, 0x7a, 0x01, 0x45, 0xf7, 0xa1, 0xdd, 0x17, 0xac, 0xcc, 0xe7, 0x55, 0x95, 0xcf, 0x03, 0xb1, 0xe4, 0xb5, 0x30, 0x73, 0xf2, 0xfa, 0xab, 0x06, 0xab, 0xf2,
0x00, 0x5b, 0x94, 0xf8, 0xdc, 0x0e, 0xed, 0xb5, 0x0f, 0x54, 0x62, 0xef, 0x05, 0xce, 0x68, 0x84, 0x62, 0x7a, 0x76, 0x6d, 0xe7, 0xe5, 0xee, 0x30, 0x53, 0x95, 0x8f, 0xb9, 0xe4, 0x54, 0x0a, 0x54,
0x83, 0x75, 0xe2, 0xdb, 0xa2, 0x23, 0x5c, 0xe8, 0x47, 0x62, 0xb2, 0xad, 0xe8, 0x5d, 0x68, 0x4e, 0xde, 0x79, 0x45, 0xe5, 0x4d, 0x36, 0xfa, 0xd5, 0x74, 0xa3, 0xaf, 0xff, 0x4a, 0x83, 0xd5, 0x0f,
0x23, 0x22, 0x6a, 0x27, 0x20, 0x0e, 0x09, 0x8a, 0x3e, 0x84, 0xa5, 0x74, 0xb3, 0x38, 0x35, 0x5c, 0x4d, 0xcf, 0x22, 0xc3, 0xe1, 0xd9, 0x0f, 0xb8, 0x19, 0x05, 0xfc, 0xce, 0x2c, 0x8d, 0x7c, 0x62,
0x87, 0x26, 0xfb, 0x40, 0x66, 0x9c, 0x9f, 0x01, 0x8a, 0x1b, 0x24, 0x5e, 0xc6, 0x79, 0x7a, 0x2b, 0x93, 0xfe, 0x69, 0x09, 0x10, 0xb3, 0xc6, 0x86, 0xe9, 0x98, 0xde, 0x00, 0x9f, 0x5e, 0x9a, 0x6b,
0x73, 0xf7, 0xbd, 0x08, 0x0d, 0x3b, 0xda, 0x29, 0x6f, 0xa2, 0x53, 0x00, 0x0b, 0x0f, 0x21, 0xa1, 0xd0, 0x4c, 0xf8, 0x50, 0xf4, 0x8c, 0x18, 0x77, 0x22, 0x8a, 0xee, 0x43, 0xb3, 0x2f, 0x58, 0xf5,
0xe9, 0x12, 0xcb, 0xc6, 0x76, 0x54, 0x00, 0x05, 0xf0, 0x53, 0x0e, 0xd3, 0xbf, 0xac, 0x40, 0x27, 0x7c, 0x6c, 0x52, 0xe2, 0x71, 0x3b, 0x34, 0xd7, 0xdf, 0x51, 0x89, 0x7d, 0xe0, 0xdb, 0xa3, 0x11,
0xd9, 0x80, 0x96, 0xe6, 0x7d, 0x36, 0x37, 0xe1, 0x43, 0xba, 0xed, 0xda, 0x29, 0xba, 0xed, 0xfc, 0xf6, 0x37, 0x89, 0x67, 0x89, 0x16, 0x7b, 0xa9, 0x1f, 0x8a, 0xc9, 0xb6, 0xa2, 0x37, 0xa1, 0x3e,
0x6d, 0x60, 0xf6, 0x64, 0xb7, 0x01, 0xfd, 0xf7, 0x1a, 0x2c, 0x66, 0x2e, 0x9e, 0xd9, 0x56, 0x44, 0x0d, 0xa8, 0xb0, 0x17, 0x82, 0x28, 0xa2, 0x28, 0x7a, 0x17, 0x96, 0x93, 0xdd, 0xf7, 0xd4, 0x70,
0xcb, 0xb7, 0x22, 0xdf, 0x86, 0x59, 0x56, 0x9f, 0x31, 0x57, 0x52, 0x3b, 0xcb, 0x56, 0x75, 0x9d, 0x6d, 0x1a, 0x6f, 0xac, 0x99, 0x71, 0x7e, 0x02, 0x28, 0xea, 0xee, 0x78, 0x13, 0xc1, 0xb3, 0x63,
0x35, 0xc4, 0x06, 0x74, 0x13, 0x96, 0x15, 0xcf, 0x8b, 0xd2, 0x94, 0x28, 0xff, 0xba, 0xa8, 0xff, 0x91, 0xc7, 0x84, 0xcb, 0x50, 0xb3, 0xc2, 0x9d, 0xf2, 0x6a, 0x3f, 0x05, 0xb0, 0xe8, 0x12, 0x12,
0xbc, 0x06, 0xcd, 0x84, 0x3e, 0x8e, 0xe8, 0xa2, 0xb2, 0x96, 0xae, 0x28, 0x2c, 0x9d, 0x39, 0x5e, 0xf6, 0x98, 0xa3, 0x63, 0x2b, 0xac, 0x9f, 0x02, 0xf8, 0x11, 0x87, 0xe9, 0x9f, 0x97, 0xa0, 0x1d,
0x35, 0x7f, 0xbc, 0x82, 0x67, 0x38, 0x74, 0x01, 0xe6, 0x3d, 0xec, 0x89, 0x02, 0x25, 0xab, 0xa5, 0xef, 0xe8, 0x0b, 0xf3, 0x3e, 0x9f, 0xa7, 0x85, 0x63, 0xae, 0x2f, 0x95, 0x33, 0x5c, 0x5f, 0xb2,
0x87, 0x3d, 0x56, 0x9e, 0xd8, 0x2f, 0xd6, 0x02, 0xf1, 0xfe, 0x47, 0xa4, 0xe4, 0x39, 0x7f, 0xe2, 0xd7, 0xab, 0xf9, 0xd3, 0x5d, 0xaf, 0xf4, 0xdf, 0x69, 0xd0, 0x4a, 0xdd, 0xe4, 0xd3, 0x9d, 0x8c,
0xf1, 0xee, 0x27, 0x5d, 0x9b, 0xe7, 0x0e, 0xa9, 0xcd, 0xf3, 0xe9, 0xda, 0x9c, 0x0a, 0x87, 0x46, 0x96, 0xed, 0x64, 0xbe, 0x09, 0xf3, 0xac, 0xbc, 0x63, 0xae, 0xa4, 0x66, 0x9a, 0xad, 0xea, 0x7d,
0x36, 0x1c, 0xca, 0x36, 0x36, 0xb7, 0x60, 0x79, 0xc0, 0x5f, 0x8d, 0xec, 0xbb, 0x07, 0xeb, 0xf1, 0xc0, 0x10, 0x1b, 0xd0, 0x6d, 0x58, 0x51, 0xbc, 0xd7, 0x4a, 0x53, 0xa2, 0xec, 0x73, 0xad, 0xfe,
0xaf, 0x6e, 0x93, 0x37, 0x11, 0xaa, 0x5f, 0xe8, 0x1e, 0x73, 0x2e, 0xd9, 0xc2, 0x70, 0x2b, 0xb7, 0xd3, 0x0a, 0xd4, 0x63, 0xfa, 0x38, 0xa1, 0x09, 0x2b, 0x72, 0x4f, 0x49, 0x1d, 0xaf, 0x9c, 0x3d,
0xb8, 0x95, 0xd5, 0xa5, 0x5f, 0xda, 0x46, 0x18, 0x39, 0xca, 0x89, 0x7c, 0x95, 0x6d, 0xa9, 0x16, 0x5e, 0xce, 0xbb, 0x26, 0xba, 0x04, 0x8b, 0x2e, 0x76, 0x45, 0x7d, 0x93, 0xc5, 0xd6, 0xc5, 0x2e,
0x4e, 0xd8, 0x52, 0xe9, 0x5f, 0x54, 0xa1, 0x3d, 0x2d, 0x9a, 0xa5, 0x23, 0xba, 0xcc, 0x6b, 0xf7, 0xab, 0x6e, 0xec, 0x13, 0xeb, 0xa0, 0x78, 0xfb, 0x24, 0x32, 0xfa, 0x82, 0x37, 0x71, 0x79, 0xf3,
0x36, 0x74, 0xa6, 0x0f, 0x35, 0xfc, 0xb0, 0x87, 0xd6, 0xfd, 0xec, 0x13, 0xcd, 0xe2, 0x38, 0x13, 0x94, 0x2c, 0xed, 0x0b, 0xc7, 0x94, 0xf6, 0xc5, 0x64, 0x69, 0x4f, 0x84, 0x43, 0x2d, 0x1d, 0x0e,
0x3a, 0x1f, 0x43, 0x83, 0x25, 0x27, 0x33, 0x3c, 0x18, 0x63, 0xee, 0x3c, 0xed, 0x6c, 0xd2, 0x17, 0x45, 0xfb, 0xa2, 0x3b, 0xb0, 0x32, 0xe0, 0xcf, 0x70, 0xd6, 0xc6, 0xd1, 0x66, 0xf4, 0xa9, 0x53,
0x84, 0x58, 0xb6, 0xda, 0x3b, 0x18, 0x63, 0x63, 0xde, 0x95, 0x5f, 0xa7, 0x7c, 0x3b, 0x45, 0xb7, 0xe7, 0x3d, 0x88, 0xea, 0x13, 0xba, 0xc7, 0x9c, 0x4b, 0x76, 0x40, 0xdc, 0xca, 0x0d, 0x6e, 0x65,
0xe1, 0x7c, 0x20, 0x4a, 0xbe, 0x6d, 0xa6, 0x8e, 0x2d, 0xaa, 0xe7, 0xb9, 0xe8, 0xe7, 0x4e, 0xf2, 0x75, 0xe7, 0x20, 0x6d, 0x23, 0x8c, 0x1c, 0xe6, 0x44, 0xbe, 0x4a, 0x77, 0x64, 0x4b, 0xa7, 0xec,
0xf8, 0x05, 0xd1, 0x38, 0x57, 0x18, 0x8d, 0x0f, 0x61, 0xf9, 0xa1, 0x4f, 0x27, 0x7d, 0x3a, 0x08, 0xc8, 0xf4, 0x4f, 0xcb, 0xd0, 0x9c, 0xd6, 0xdc, 0xc2, 0x11, 0x5d, 0x64, 0x7c, 0xb0, 0x0b, 0xed,
0x9c, 0x3e, 0x8e, 0xae, 0x66, 0xa5, 0xcc, 0xd1, 0x83, 0x79, 0x99, 0x2e, 0x85, 0x29, 0x1a, 0x46, 0xe9, 0xcb, 0x17, 0x3f, 0xec, 0xb1, 0x6d, 0x43, 0xfa, 0xcd, 0xab, 0x35, 0x4e, 0x85, 0x4e, 0xe2,
0xbc, 0xd6, 0x7f, 0xa5, 0xc1, 0x4a, 0x9e, 0x2e, 0xb7, 0xf4, 0x34, 0x16, 0xb5, 0x54, 0x2c, 0xfe, 0x8a, 0x5d, 0x99, 0xe9, 0x8a, 0x7d, 0xb6, 0xc7, 0x68, 0x74, 0x17, 0x2e, 0xfa, 0xa2, 0xe4, 0x5b,
0x18, 0x96, 0xa7, 0xe4, 0xcd, 0x14, 0xe5, 0xe6, 0xda, 0x35, 0x95, 0xce, 0x15, 0x82, 0x1b, 0x68, 0xbd, 0xc4, 0xb1, 0x45, 0xf5, 0xbc, 0x10, 0x7e, 0xdc, 0x8b, 0x1f, 0x3f, 0x27, 0x1a, 0x17, 0x72,
0x4a, 0x23, 0x82, 0xe9, 0xff, 0xd2, 0x60, 0x49, 0x7a, 0x35, 0x83, 0x8d, 0xf8, 0xad, 0x94, 0xd5, 0xa3, 0xf1, 0x21, 0xac, 0x3c, 0xf4, 0xe8, 0xa4, 0x4f, 0x07, 0xbe, 0xdd, 0xc7, 0xe1, 0xc5, 0xb0,
0x07, 0xe2, 0xbb, 0x8e, 0x1f, 0x37, 0x67, 0xf2, 0x8c, 0x02, 0x28, 0x9b, 0xb3, 0x4f, 0x60, 0x51, 0x90, 0x39, 0xba, 0xb0, 0x28, 0xd3, 0xa5, 0x30, 0x45, 0xcd, 0x88, 0xd6, 0xfa, 0x2f, 0x34, 0x58,
0x22, 0xc5, 0x69, 0xbe, 0x64, 0x37, 0xd1, 0x16, 0xfb, 0xe2, 0x04, 0x7f, 0x05, 0xda, 0x64, 0x38, 0xcd, 0xd2, 0xe5, 0x96, 0x9e, 0xc6, 0xa2, 0x96, 0x88, 0xc5, 0x1f, 0xc2, 0xca, 0x94, 0x7c, 0x2f,
0x4c, 0xf2, 0x13, 0x79, 0x6a, 0x41, 0x42, 0x25, 0xc3, 0x1f, 0x40, 0x27, 0x42, 0x3b, 0x6e, 0x61, 0x41, 0xb9, 0xbe, 0x7e, 0x43, 0xa5, 0x73, 0x85, 0xe0, 0x06, 0x9a, 0xd2, 0x08, 0x61, 0xfa, 0x3f,
0x59, 0x94, 0x1b, 0xe3, 0x17, 0x9c, 0x5f, 0x6a, 0xd0, 0x4d, 0x97, 0x99, 0xc4, 0xf1, 0x8f, 0xdf, 0x35, 0x58, 0x96, 0x5e, 0xcd, 0x60, 0x23, 0x7e, 0xa5, 0x66, 0xf5, 0x81, 0x78, 0x8e, 0xed, 0x45,
0xc8, 0x7c, 0x27, 0xfd, 0x8e, 0x77, 0xe5, 0x10, 0x79, 0xa6, 0x7c, 0x64, 0x27, 0x7d, 0xe3, 0x25, 0xbd, 0x9d, 0x3c, 0xa3, 0x00, 0xca, 0xde, 0xee, 0x43, 0x68, 0x49, 0xa4, 0x28, 0xcd, 0x17, 0xec,
0xb4, 0xd3, 0xb1, 0x86, 0x5a, 0x30, 0xbf, 0x4d, 0xc2, 0xef, 0xbf, 0x70, 0x68, 0xd8, 0x99, 0x41, 0x26, 0x9a, 0x62, 0x5f, 0x94, 0xe0, 0xaf, 0x41, 0x93, 0x0c, 0x87, 0x71, 0x7e, 0x22, 0x4f, 0x2d,
0x6d, 0x80, 0x6d, 0x12, 0xee, 0x04, 0x98, 0x62, 0x3f, 0xec, 0x68, 0x08, 0xa0, 0xfe, 0x99, 0xbf, 0x49, 0xa8, 0x64, 0xf8, 0x3d, 0x68, 0x87, 0x68, 0xb3, 0x16, 0x96, 0x96, 0xdc, 0x18, 0x3d, 0x89,
0xe1, 0xd0, 0xa7, 0x9d, 0x0a, 0x5a, 0x96, 0x15, 0xcd, 0x72, 0xb7, 0xa4, 0x03, 0x77, 0xaa, 0x6c, 0xfd, 0x5c, 0x83, 0x4e, 0xb2, 0xcc, 0xc4, 0x8e, 0x3f, 0x7b, 0x23, 0xf3, 0xad, 0xe4, 0xc3, 0xe8,
0x7b, 0xbc, 0xaa, 0xa1, 0x0e, 0xb4, 0x62, 0x94, 0xcd, 0x9d, 0x87, 0x9d, 0x59, 0xd4, 0x80, 0x59, 0xb5, 0x63, 0xe4, 0x99, 0xf2, 0x91, 0x8d, 0xf8, 0xad, 0x97, 0xd0, 0x4c, 0xc6, 0x1a, 0x6a, 0xc0,
0xf1, 0x59, 0xbf, 0x61, 0x43, 0x27, 0xdb, 0x30, 0x31, 0x9a, 0x0f, 0xfd, 0xfb, 0x3e, 0x79, 0x1e, 0xe2, 0x2e, 0x09, 0xbe, 0xfb, 0xc2, 0xa6, 0x41, 0x7b, 0x0e, 0x35, 0x01, 0x76, 0x49, 0xb0, 0xe7,
0x83, 0x3a, 0x33, 0xa8, 0x09, 0x73, 0xb2, 0x09, 0xed, 0x68, 0x68, 0x11, 0x9a, 0x89, 0xfe, 0xaf, 0x63, 0x8a, 0xbd, 0xa0, 0xad, 0x21, 0x80, 0xea, 0xc7, 0xde, 0x96, 0x4d, 0x9f, 0xb6, 0x4b, 0x68,
0x53, 0x61, 0x80, 0xcd, 0x60, 0x3c, 0x90, 0x9d, 0xa0, 0x10, 0x81, 0x59, 0x6d, 0x83, 0x3c, 0xf7, 0x45, 0x56, 0x34, 0xd3, 0xd9, 0x91, 0x0e, 0xdc, 0x2e, 0xb3, 0xed, 0xd1, 0xaa, 0x82, 0xda, 0xd0,
0x3b, 0xb5, 0x1b, 0x77, 0x60, 0x3e, 0x4a, 0x02, 0xec, 0x34, 0x82, 0x3a, 0x5b, 0x75, 0x66, 0xd0, 0x88, 0x50, 0xb6, 0xf7, 0x1e, 0xb6, 0xe7, 0x51, 0x0d, 0xe6, 0xc5, 0xcf, 0xea, 0x2d, 0x0b, 0xda,
0x12, 0x2c, 0xa4, 0xa6, 0x3d, 0x1d, 0x0d, 0x21, 0x68, 0xbb, 0xa9, 0x11, 0x5b, 0xa7, 0xb2, 0xf6, 0xe9, 0x86, 0x89, 0xd1, 0x7c, 0xe8, 0xdd, 0xf7, 0xc8, 0xf3, 0x08, 0xd4, 0x9e, 0x43, 0x75, 0x58,
0xd7, 0x26, 0x80, 0xe8, 0x75, 0x08, 0x09, 0x6c, 0x34, 0x06, 0xb4, 0x89, 0x43, 0x96, 0xc7, 0x89, 0x90, 0x4d, 0x68, 0x5b, 0x43, 0x2d, 0xa8, 0xc7, 0xfa, 0xbf, 0x76, 0x89, 0x01, 0xb6, 0xfd, 0xf1,
0x1f, 0xe5, 0x60, 0x8a, 0x6e, 0x15, 0xb4, 0x04, 0x79, 0x54, 0x29, 0x69, 0xef, 0x6a, 0xc1, 0x8e, 0x40, 0x76, 0x82, 0x42, 0x04, 0x66, 0xb5, 0x2d, 0xf2, 0xdc, 0x6b, 0x57, 0x6e, 0x6d, 0xc0, 0x62,
0x0c, 0xba, 0x3e, 0x83, 0x3c, 0xce, 0x71, 0xcf, 0xf1, 0xf0, 0x9e, 0x33, 0x78, 0x1a, 0x37, 0x49, 0x98, 0x04, 0x18, 0xaa, 0xa0, 0xee, 0xb1, 0x65, 0x7b, 0x0e, 0x2d, 0xc3, 0x52, 0x62, 0x7e, 0xd6,
0xc5, 0x1c, 0x33, 0xa8, 0x11, 0xc7, 0x4c, 0xae, 0x95, 0x8b, 0xdd, 0x30, 0x70, 0xfc, 0x51, 0xf4, 0xd6, 0x10, 0x82, 0x66, 0x72, 0x68, 0xd9, 0x2e, 0xad, 0xff, 0xa5, 0x0e, 0x20, 0x9a, 0x1d, 0x42,
0x98, 0xac, 0xcf, 0xa0, 0x67, 0x70, 0x6e, 0x13, 0x73, 0xee, 0x0e, 0x0d, 0x9d, 0x01, 0x8d, 0x18, 0x7c, 0x0b, 0x8d, 0x01, 0x6d, 0xe3, 0x80, 0x25, 0x72, 0xe2, 0x85, 0x49, 0x98, 0xa2, 0x3b, 0x39,
0xae, 0x15, 0x33, 0xcc, 0x21, 0x1f, 0x93, 0xa5, 0x0b, 0x8b, 0x99, 0x91, 0x36, 0xba, 0xa1, 0x74, 0x3d, 0x41, 0x16, 0x55, 0x8a, 0xda, 0xbd, 0x9e, 0xb3, 0x23, 0x85, 0xae, 0xcf, 0x21, 0x97, 0x73,
0x64, 0xe5, 0xf8, 0xbd, 0xf7, 0x61, 0x29, 0xdc, 0x98, 0x9b, 0x03, 0xed, 0xf4, 0xb8, 0x17, 0x7d, 0x3c, 0xb0, 0x5d, 0x7c, 0x60, 0x0f, 0x9e, 0x46, 0x5d, 0x52, 0x3e, 0xc7, 0x14, 0x6a, 0xc8, 0x31,
0xad, 0x88, 0x40, 0x6e, 0x3e, 0xd6, 0xbb, 0x51, 0x06, 0x35, 0x66, 0xf5, 0x18, 0xda, 0xe9, 0x81, 0x95, 0x6c, 0xe5, 0x62, 0x3f, 0xf0, 0x6d, 0x6f, 0x14, 0x3e, 0xcf, 0xeb, 0x73, 0xe8, 0x19, 0x5c,
0xa2, 0x9a, 0x95, 0x72, 0xe8, 0xd8, 0x3b, 0xec, 0x1d, 0x5f, 0x9f, 0x41, 0x3f, 0x85, 0xa5, 0xdc, 0xd8, 0xc6, 0x9c, 0xbb, 0x4d, 0x03, 0x7b, 0x40, 0x43, 0x86, 0xeb, 0xf9, 0x0c, 0x33, 0xc8, 0x33,
0x14, 0x0f, 0x7d, 0x5d, 0x45, 0xbe, 0x68, 0xd8, 0x77, 0x14, 0x07, 0x29, 0xfd, 0x54, 0x8b, 0xc5, 0xb2, 0x74, 0xa0, 0x95, 0xfa, 0x93, 0x00, 0xba, 0xa5, 0xf4, 0x64, 0xe5, 0x1f, 0x1a, 0xba, 0xef,
0xd2, 0xe7, 0xc6, 0xb9, 0xe5, 0xa5, 0x4f, 0x90, 0x3f, 0x4c, 0xfa, 0x63, 0x73, 0x98, 0x00, 0xca, 0x16, 0xc2, 0x8d, 0xb8, 0xd9, 0xd0, 0x4c, 0x0e, 0xd0, 0xd1, 0x57, 0xf2, 0x08, 0x64, 0x26, 0x8e,
0xcf, 0xf1, 0xd0, 0x47, 0x2a, 0x16, 0x85, 0xb3, 0xc4, 0xde, 0x6a, 0x59, 0xf4, 0xd8, 0xe4, 0x13, 0xdd, 0x5b, 0x45, 0x50, 0x23, 0x56, 0x8f, 0x85, 0x3f, 0x9d, 0xc4, 0x4a, 0x39, 0xc6, 0xed, 0x1e,
0x1e, 0xad, 0xd9, 0x66, 0x5f, 0xc9, 0xb6, 0x70, 0x76, 0xa7, 0x66, 0x5b, 0x3c, 0x3e, 0x13, 0x4e, 0x37, 0x19, 0xd1, 0xe7, 0xd0, 0x8f, 0x61, 0x39, 0x33, 0x17, 0x45, 0x5f, 0x55, 0x91, 0xcf, 0x1b,
0x9d, 0x1e, 0x0f, 0xa9, 0x6d, 0xa5, 0x1c, 0x69, 0xa9, 0x9d, 0x5a, 0x3d, 0x6d, 0xd2, 0x67, 0xd0, 0x9f, 0x9e, 0xc4, 0xe1, 0x71, 0x3a, 0x1a, 0xf2, 0xa5, 0xcf, 0x0c, 0xc8, 0x8b, 0x4b, 0x1f, 0x23,
0x5e, 0x2a, 0x07, 0xa3, 0xab, 0x45, 0x3e, 0x91, 0xbe, 0xa4, 0x1f, 0x65, 0x2e, 0x13, 0x60, 0x13, 0x7f, 0x9c, 0xf4, 0x33, 0x73, 0x98, 0x00, 0xca, 0x4e, 0x46, 0xd1, 0x7b, 0x2a, 0x16, 0xb9, 0xd3,
0x87, 0x0f, 0x70, 0x18, 0x38, 0x03, 0x9a, 0x25, 0x2a, 0x17, 0x53, 0x84, 0x88, 0xe8, 0xb5, 0x23, 0xd9, 0xee, 0x5a, 0x51, 0xf4, 0xc8, 0xe4, 0x13, 0x1e, 0xad, 0xe9, 0x6e, 0x5f, 0xc9, 0x36, 0x77,
0xf1, 0x22, 0xb1, 0xd7, 0x5e, 0x01, 0x34, 0xb8, 0xcd, 0x58, 0x79, 0xf8, 0x5f, 0x1a, 0x3f, 0x83, 0x1a, 0xaa, 0x66, 0x9b, 0x3f, 0x90, 0x14, 0x4e, 0x9d, 0x1c, 0xb8, 0xa9, 0x6d, 0xa5, 0x1c, 0x12,
0x34, 0xfe, 0x04, 0x16, 0x33, 0xb3, 0x41, 0x75, 0x1a, 0x57, 0x0f, 0x10, 0x8f, 0x72, 0x90, 0x3e, 0xaa, 0x9d, 0x5a, 0x3d, 0xbf, 0xd3, 0xe7, 0xd0, 0x41, 0x22, 0x09, 0xa3, 0xeb, 0x79, 0x3e, 0x91,
0xa0, 0xfc, 0xe4, 0x4b, 0x1d, 0x58, 0x85, 0x13, 0xb2, 0xa3, 0x78, 0x3c, 0x81, 0xc5, 0xcc, 0xe8, 0xbc, 0xa5, 0x9f, 0x64, 0xae, 0x1e, 0xc0, 0x36, 0x0e, 0x1e, 0xe0, 0xc0, 0xb7, 0x07, 0x34, 0x4d,
0x49, 0x7d, 0x02, 0xf5, 0x7c, 0xaa, 0xc4, 0x09, 0xf2, 0x03, 0x17, 0xf5, 0x09, 0x0a, 0x07, 0x33, 0x54, 0x2e, 0xa6, 0x08, 0x21, 0xd1, 0x1b, 0x27, 0xe2, 0x85, 0x62, 0xaf, 0x7f, 0x06, 0x50, 0xe3,
0x47, 0xf1, 0x78, 0x04, 0xad, 0xe4, 0xfb, 0x2d, 0xba, 0x56, 0x14, 0x9d, 0x99, 0x17, 0xbd, 0x37, 0x36, 0x63, 0xf5, 0xe1, 0x7f, 0x69, 0xfc, 0x1c, 0xd2, 0xf8, 0x13, 0x68, 0xa5, 0xa6, 0xad, 0xea,
0x9f, 0xaf, 0xcf, 0xbe, 0x9e, 0x3d, 0x81, 0xc5, 0xcc, 0x7b, 0xad, 0xda, 0xba, 0xea, 0x47, 0xdd, 0x34, 0xae, 0x1e, 0xc9, 0x9e, 0xe4, 0x20, 0x7d, 0x40, 0xd9, 0x59, 0xa2, 0x3a, 0xb0, 0x72, 0x67,
0xa3, 0xa8, 0x7f, 0x85, 0x19, 0xf8, 0xac, 0x73, 0xe5, 0xdd, 0x6f, 0x3e, 0x5e, 0x1b, 0x39, 0xe1, 0x8e, 0x27, 0xf1, 0x78, 0x02, 0xad, 0xd4, 0xe0, 0x4c, 0x7d, 0x02, 0xf5, 0x74, 0xad, 0xc0, 0x09,
0xfe, 0xa4, 0xcf, 0x4e, 0x79, 0x53, 0x60, 0x7e, 0xe4, 0x10, 0xf9, 0x75, 0x33, 0x4a, 0x1a, 0x37, 0xb2, 0xf3, 0x1e, 0xf5, 0x09, 0x72, 0xe7, 0x42, 0x27, 0xf1, 0x78, 0x24, 0xc6, 0x91, 0x51, 0x8b,
0x39, 0xa5, 0x9b, 0x5c, 0xda, 0x71, 0xbf, 0x5f, 0xe7, 0xcb, 0xdb, 0xff, 0x09, 0x00, 0x00, 0xff, 0x7b, 0x23, 0x2f, 0x3a, 0x53, 0x4f, 0x7a, 0xaf, 0x3e, 0x5f, 0x9f, 0x7f, 0x3d, 0x7b, 0x02, 0xad,
0xff, 0x0a, 0x67, 0x23, 0x4a, 0x9d, 0x29, 0x00, 0x00, 0xd4, 0x83, 0xad, 0xda, 0xba, 0xea, 0x57, 0xdd, 0x93, 0xa8, 0x7f, 0x89, 0x19, 0xf8, 0xbc, 0x73,
0xe5, 0xc6, 0xd7, 0x1f, 0xaf, 0x8f, 0xec, 0xe0, 0x70, 0xd2, 0x67, 0xa7, 0xbc, 0x2d, 0x30, 0xdf,
0xb3, 0x89, 0xfc, 0x75, 0x3b, 0x4c, 0x1a, 0xb7, 0x39, 0xa5, 0xdb, 0x5c, 0xda, 0x71, 0xbf, 0x5f,
0xe5, 0xcb, 0xbb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xee, 0xf5, 0x56, 0xa4, 0xef, 0x2a, 0x00,
0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

6
internal/querycoord/impl.go
View File

@ -183,7 +183,7 @@ func (qc *QueryCoord) LoadCollection(ctx context.Context, req *querypb.LoadColle
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil { if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if collection has been loaded by load collection request, return success // if collection has been loaded by load collection request, return success
if collectionInfo.LoadType == querypb.LoadType_loadCollection { if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
log.Debug("collection has already been loaded, return load success directly", log.Debug("collection has already been loaded, return load success directly",
zap.String("role", typeutil.QueryCoordRole), zap.String("role", typeutil.QueryCoordRole),
zap.Int64("collectionID", collectionID), zap.Int64("collectionID", collectionID),
@ -471,7 +471,7 @@ func (qc *QueryCoord) LoadPartitions(ctx context.Context, req *querypb.LoadParti
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil { if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if the collection has been loaded into memory by load collection request, return error // if the collection has been loaded into memory by load collection request, return error
// should release collection first, then load partitions again // should release collection first, then load partitions again
if collectionInfo.LoadType == querypb.LoadType_loadCollection { if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err = fmt.Errorf("collection %d has been loaded into QueryNode, please release collection firstly", collectionID) err = fmt.Errorf("collection %d has been loaded into QueryNode, please release collection firstly", collectionID)
status.Reason = err.Error() status.Reason = err.Error()
@ -611,7 +611,7 @@ func (qc *QueryCoord) ReleasePartitions(ctx context.Context, req *querypb.Releas
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil { if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if collection has been loaded into memory by load collection request, return error // if collection has been loaded into memory by load collection request, return error
// part of the partitions released after load collection is temporarily not supported, and will be supported soon // part of the partitions released after load collection is temporarily not supported, and will be supported soon
if collectionInfo.LoadType == querypb.LoadType_loadCollection { if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("releasing some partitions after load collection is not supported") err := errors.New("releasing some partitions after load collection is not supported")
status.Reason = err.Error() status.Reason = err.Error()

6
internal/querycoord/index_checker_test.go
View File

@ -73,7 +73,7 @@ func TestReloadFromKV(t *testing.T) {
err = kv.Save(key, string(value)) err = kv.Save(key, string(value))
assert.Nil(t, err) assert.Nil(t, err)
meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection) meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
t.Run("Test_CollectionExist", func(t *testing.T) { t.Run("Test_CollectionExist", func(t *testing.T) {
indexChecker, err := newIndexChecker(baseCtx, kv, meta, nil, nil, nil) indexChecker, err := newIndexChecker(baseCtx, kv, meta, nil, nil, nil)
@ -135,7 +135,7 @@ func TestCheckIndexLoop(t *testing.T) {
childCancel() childCancel()
indexChecker.wg.Wait() indexChecker.wg.Wait()
}) })
meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false)) meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
t.Run("Test_GetIndexInfo", func(t *testing.T) { t.Run("Test_GetIndexInfo", func(t *testing.T) {
childCtx, childCancel := context.WithCancel(context.Background()) childCtx, childCancel := context.WithCancel(context.Background())
indexChecker, err := newIndexChecker(childCtx, kv, meta, nil, nil, broker) indexChecker, err := newIndexChecker(childCtx, kv, meta, nil, nil, broker)
@ -176,7 +176,7 @@ func TestHandoffNotExistSegment(t *testing.T) {
broker, err := newGlobalMetaBroker(ctx, rootCoord, dataCoord, indexCoord) broker, err := newGlobalMetaBroker(ctx, rootCoord, dataCoord, indexCoord)
assert.Nil(t, err) assert.Nil(t, err)
meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false)) meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
segmentInfo := &querypb.SegmentInfo{ segmentInfo := &querypb.SegmentInfo{
SegmentID: defaultSegmentID, SegmentID: defaultSegmentID,

2
internal/querycoord/meta.go
View File

@ -903,7 +903,7 @@ func (m *MetaReplica) setLoadPercentage(collectionID UniqueID, partitionID Uniqu
} }
info := proto.Clone(m.collectionInfos[collectionID]).(*querypb.CollectionInfo) info := proto.Clone(m.collectionInfos[collectionID]).(*querypb.CollectionInfo)
if loadType == querypb.LoadType_loadCollection { if loadType == querypb.LoadType_LoadCollection {
info.InMemoryPercentage = percentage info.InMemoryPercentage = percentage
for _, partitionState := range info.PartitionStates { for _, partitionState := range info.PartitionStates {
if percentage >= 100 { if percentage >= 100 {

12
internal/querycoord/meta_test.go
View File

@ -70,7 +70,7 @@ func TestReplica_Release(t *testing.T) {
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath) etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath)
meta, err := newMeta(context.Background(), etcdKV, nil, nil) meta, err := newMeta(context.Background(), etcdKV, nil, nil)
assert.Nil(t, err) assert.Nil(t, err)
err = meta.addCollection(1, querypb.LoadType_loadCollection, nil) err = meta.addCollection(1, querypb.LoadType_LoadCollection, nil)
require.NoError(t, err) require.NoError(t, err)
collections := meta.showCollections() collections := meta.showCollections()
@ -164,18 +164,18 @@ func TestMetaFunc(t *testing.T) {
}) })
t.Run("Test SetLoadTypeFail", func(t *testing.T) { t.Run("Test SetLoadTypeFail", func(t *testing.T) {
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection) err := meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
assert.NotNil(t, err) assert.NotNil(t, err)
}) })
t.Run("Test SetLoadPercentageFail", func(t *testing.T) { t.Run("Test SetLoadPercentageFail", func(t *testing.T) {
err := meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_loadCollection) err := meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_LoadCollection)
assert.NotNil(t, err) assert.NotNil(t, err)
}) })
t.Run("Test AddCollection", func(t *testing.T) { t.Run("Test AddCollection", func(t *testing.T) {
schema := genDefaultCollectionSchema(false) schema := genDefaultCollectionSchema(false)
err := meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema) err := meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
assert.Nil(t, err) assert.Nil(t, err)
}) })
@ -260,7 +260,7 @@ func TestMetaFunc(t *testing.T) {
}) })
t.Run("Test SetLoadType", func(t *testing.T) { t.Run("Test SetLoadType", func(t *testing.T) {
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection) err := meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
assert.Nil(t, err) assert.Nil(t, err)
}) })
@ -270,7 +270,7 @@ func TestMetaFunc(t *testing.T) {
state, err := meta.getPartitionStatesByID(defaultCollectionID, defaultPartitionID) state, err := meta.getPartitionStatesByID(defaultCollectionID, defaultPartitionID)
assert.Nil(t, err) assert.Nil(t, err)
assert.Equal(t, int64(100), state.InMemoryPercentage) assert.Equal(t, int64(100), state.InMemoryPercentage)
err = meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_loadCollection) err = meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_LoadCollection)
assert.Nil(t, err) assert.Nil(t, err)
info, err := meta.getCollectionInfoByID(defaultCollectionID) info, err := meta.getCollectionInfoByID(defaultCollectionID)
assert.Nil(t, err) assert.Nil(t, err)

2
internal/querycoord/query_coord_test.go
View File

@ -353,7 +353,7 @@ func TestHandoffSegmentLoop(t *testing.T) {
err = queryCoord.scheduler.Enqueue(loadCollectionTask) err = queryCoord.scheduler.Enqueue(loadCollectionTask)
assert.Nil(t, err) assert.Nil(t, err)
waitTaskFinalState(loadCollectionTask, taskExpired) waitTaskFinalState(loadCollectionTask, taskExpired)
queryCoord.meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection) queryCoord.meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
t.Run("Test handoffGrowingSegment", func(t *testing.T) { t.Run("Test handoffGrowingSegment", func(t *testing.T) {
infos := queryCoord.meta.showSegmentInfos(defaultCollectionID, nil) infos := queryCoord.meta.showSegmentInfos(defaultCollectionID, nil)

34
internal/querycoord/task.go
View File

@ -339,7 +339,7 @@ func (lct *loadCollectionTask) updateTaskProcess() {
} }
if allDone { if allDone {
err := lct.meta.setLoadPercentage(collectionID, 0, 100, querypb.LoadType_loadCollection) err := lct.meta.setLoadPercentage(collectionID, 0, 100, querypb.LoadType_LoadCollection)
if err != nil { if err != nil {
log.Error("loadCollectionTask: set load percentage to meta's collectionInfo", zap.Int64("collectionID", collectionID)) log.Error("loadCollectionTask: set load percentage to meta's collectionInfo", zap.Int64("collectionID", collectionID))
lct.setResultInfo(err) lct.setResultInfo(err)
@ -387,8 +387,8 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
return err return err
} }
for _, segmentBingLog := range binlogs { for _, segmentBinlog := range binlogs {
segmentLoadInfo := lct.broker.generateSegmentLoadInfo(ctx, collectionID, partitionID, segmentBingLog, true, lct.Schema) segmentLoadInfo := lct.broker.generateSegmentLoadInfo(ctx, collectionID, partitionID, segmentBinlog, true, lct.Schema)
msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase) msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_LoadSegments msgBase.MsgType = commonpb.MsgType_LoadSegments
loadSegmentReq := &querypb.LoadSegmentsRequest{ loadSegmentReq := &querypb.LoadSegmentsRequest{
@ -396,6 +396,11 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo}, Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo},
Schema: lct.Schema, Schema: lct.Schema,
CollectionID: collectionID, CollectionID: collectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: collectionID,
PartitionIDs: toLoadPartitionIDs,
},
} }
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq) loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
@ -433,6 +438,11 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
//PartitionIDs: toLoadPartitionIDs, //PartitionIDs: toLoadPartitionIDs,
Infos: []*datapb.VchannelInfo{info}, Infos: []*datapb.VchannelInfo{info},
Schema: lct.Schema, Schema: lct.Schema,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: collectionID,
PartitionIDs: toLoadPartitionIDs,
},
} }
watchDmChannelReqs = append(watchDmChannelReqs, watchRequest) watchDmChannelReqs = append(watchDmChannelReqs, watchRequest)
@ -451,7 +461,7 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
metrics.QueryCoordNumChildTasks.WithLabelValues().Add(float64(len(internalTasks))) metrics.QueryCoordNumChildTasks.WithLabelValues().Add(float64(len(internalTasks)))
log.Debug("loadCollectionTask: assign child task done", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID)) log.Debug("loadCollectionTask: assign child task done", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID))
err = lct.meta.addCollection(collectionID, querypb.LoadType_loadCollection, lct.Schema) err = lct.meta.addCollection(collectionID, querypb.LoadType_LoadCollection, lct.Schema)
if err != nil { if err != nil {
log.Error("loadCollectionTask: add collection to meta failed", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID), zap.Error(err)) log.Error("loadCollectionTask: add collection to meta failed", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID), zap.Error(err))
lct.setResultInfo(err) lct.setResultInfo(err)
@ -741,6 +751,11 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo}, Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo},
Schema: lpt.Schema, Schema: lpt.Schema,
CollectionID: collectionID, CollectionID: collectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadPartition,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
},
} }
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq) loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
} }
@ -775,6 +790,11 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
PartitionIDs: partitionIDs, PartitionIDs: partitionIDs,
Infos: []*datapb.VchannelInfo{info}, Infos: []*datapb.VchannelInfo{info},
Schema: lpt.Schema, Schema: lpt.Schema,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadPartition,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
},
} }
watchDmChannelReqs = append(watchDmChannelReqs, watchRequest) watchDmChannelReqs = append(watchDmChannelReqs, watchRequest)
@ -1468,7 +1488,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
continue continue
} }
if collectionInfo.LoadType == querypb.LoadType_loadCollection && ht.meta.hasReleasePartition(collectionID, partitionID) { if collectionInfo.LoadType == querypb.LoadType_LoadCollection && ht.meta.hasReleasePartition(collectionID, partitionID) {
log.Debug("handoffTask: partition has not been released", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID)) log.Debug("handoffTask: partition has not been released", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID))
continue continue
} }
@ -1480,7 +1500,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
} }
} }
if collectionInfo.LoadType != querypb.LoadType_loadCollection && !partitionLoaded { if collectionInfo.LoadType != querypb.LoadType_LoadCollection && !partitionLoaded {
log.Debug("handoffTask: partition has not been loaded into memory", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID), zap.Int64("segmentID", segmentID)) log.Debug("handoffTask: partition has not been loaded into memory", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID), zap.Int64("segmentID", segmentID))
continue continue
} }
@ -1661,7 +1681,7 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
var dmChannelInfos []*datapb.VchannelInfo var dmChannelInfos []*datapb.VchannelInfo
var toRecoverPartitionIDs []UniqueID var toRecoverPartitionIDs []UniqueID
if collectionInfo.LoadType == querypb.LoadType_loadCollection { if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
toRecoverPartitionIDs, err = lbt.broker.showPartitionIDs(ctx, collectionID) toRecoverPartitionIDs, err = lbt.broker.showPartitionIDs(ctx, collectionID)
if err != nil { if err != nil {
log.Error("loadBalanceTask: show collection's partitionIDs failed", zap.Int64("collectionID", collectionID), zap.Error(err)) log.Error("loadBalanceTask: show collection's partitionIDs failed", zap.Int64("collectionID", collectionID), zap.Error(err))

23
internal/querycoord/task_test.go
View File

@ -142,6 +142,11 @@ func genWatchDmChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeID i
PartitionIDs: []UniqueID{defaultPartitionID}, PartitionIDs: []UniqueID{defaultPartitionID},
Schema: schema, Schema: schema,
Infos: []*datapb.VchannelInfo{vChannelInfo}, Infos: []*datapb.VchannelInfo{vChannelInfo},
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
} }
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest) baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 100 baseTask.taskID = 100
@ -175,7 +180,7 @@ func genWatchDmChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeID i
parentTask.addChildTask(watchDmChannelTask) parentTask.addChildTask(watchDmChannelTask)
watchDmChannelTask.setParentTask(parentTask) watchDmChannelTask.setParentTask(parentTask)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema) queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
return watchDmChannelTask return watchDmChannelTask
} }
func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int64) *loadSegmentTask { func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int64) *loadSegmentTask {
@ -194,6 +199,11 @@ func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int6
Schema: schema, Schema: schema,
Infos: []*querypb.SegmentLoadInfo{segmentInfo}, Infos: []*querypb.SegmentLoadInfo{segmentInfo},
CollectionID: defaultCollectionID, CollectionID: defaultCollectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
} }
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest) baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 100 baseTask.taskID = 100
@ -227,7 +237,7 @@ func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int6
parentTask.addChildTask(loadSegmentTask) parentTask.addChildTask(loadSegmentTask)
loadSegmentTask.setParentTask(parentTask) loadSegmentTask.setParentTask(parentTask)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema) queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
return loadSegmentTask return loadSegmentTask
} }
@ -258,6 +268,11 @@ func genWatchDeltaChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeI
}, },
NodeID: nodeID, NodeID: nodeID,
CollectionID: defaultCollectionID, CollectionID: defaultCollectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
} }
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest) baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 300 baseTask.taskID = 300
@ -1229,7 +1244,7 @@ func TestUpdateTaskProcessWhenLoadSegment(t *testing.T) {
node1, err := startQueryNodeServer(ctx) node1, err := startQueryNodeServer(ctx)
assert.Nil(t, err) assert.Nil(t, err)
waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID) waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false)) queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
loadSegmentTask := genLoadSegmentTask(ctx, queryCoord, node1.queryNodeID) loadSegmentTask := genLoadSegmentTask(ctx, queryCoord, node1.queryNodeID)
loadCollectionTask := loadSegmentTask.getParentTask() loadCollectionTask := loadSegmentTask.getParentTask()
@ -1262,7 +1277,7 @@ func TestUpdateTaskProcessWhenWatchDmChannel(t *testing.T) {
node1, err := startQueryNodeServer(ctx) node1, err := startQueryNodeServer(ctx)
assert.Nil(t, err) assert.Nil(t, err)
waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID) waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false)) queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
watchDmChannel := genWatchDmChannelTask(ctx, queryCoord, node1.queryNodeID) watchDmChannel := genWatchDmChannelTask(ctx, queryCoord, node1.queryNodeID)
loadCollectionTask := watchDmChannel.getParentTask() loadCollectionTask := watchDmChannel.getParentTask()

24
internal/querynode/task.go
View File

@ -227,12 +227,20 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
partitionIDs := w.req.GetPartitionIDs() partitionIDs := w.req.GetPartitionIDs()
var lType loadType var lType loadType
switch w.req.GetLoadMeta().GetLoadType() {
case queryPb.LoadType_LoadCollection:
lType = loadTypeCollection
case queryPb.LoadType_LoadPartition:
lType = loadTypePartition
default:
// if no partitionID is specified, load type is load collection // if no partitionID is specified, load type is load collection
if len(partitionIDs) != 0 { if len(partitionIDs) != 0 {
lType = loadTypePartition lType = loadTypePartition
} else { } else {
lType = loadTypeCollection lType = loadTypeCollection
} }
}
// get all vChannels // get all vChannels
vChannels := make([]Channel, 0) vChannels := make([]Channel, 0)
@ -288,7 +296,8 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
}, },
Infos: unFlushedSegments, Infos: unFlushedSegments,
CollectionID: collectionID, CollectionID: collectionID,
Schema: w.req.Schema, Schema: w.req.GetSchema(),
LoadMeta: w.req.GetLoadMeta(),
} }
log.Debug("loading growing segments in WatchDmChannels...", log.Debug("loading growing segments in WatchDmChannels...",
zap.Int64("collectionID", collectionID), zap.Int64("collectionID", collectionID),
@ -432,14 +441,12 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
hCol.addVChannels(vChannels) hCol.addVChannels(vChannels)
hCol.addPChannels(pChannels) hCol.addPChannels(pChannels)
hCol.setLoadType(lType) hCol.setLoadType(lType)
if lType == loadTypePartition { for _, partitionID := range w.req.GetLoadMeta().GetPartitionIDs() {
for _, partitionID := range partitionIDs {
sCol.deleteReleasedPartition(partitionID) sCol.deleteReleasedPartition(partitionID)
hCol.deleteReleasedPartition(partitionID) hCol.deleteReleasedPartition(partitionID)
w.node.streaming.replica.addPartition(collectionID, partitionID) w.node.streaming.replica.addPartition(collectionID, partitionID)
w.node.historical.replica.addPartition(collectionID, partitionID) w.node.historical.replica.addPartition(collectionID, partitionID)
} }
}
log.Debug("watchDMChannel, init replica done", zap.Int64("collectionID", collectionID), zap.Strings("vChannels", vChannels)) log.Debug("watchDMChannel, init replica done", zap.Int64("collectionID", collectionID), zap.Strings("vChannels", vChannels))
// create tSafe // create tSafe
@ -638,15 +645,14 @@ func (l *loadSegmentsTask) Execute(ctx context.Context) error {
var err error var err error
// init meta // init meta
for _, info := range l.req.Infos { collectionID := l.req.GetLoadMeta().GetCollectionID()
collectionID := info.CollectionID l.node.historical.replica.addCollection(collectionID, l.req.GetSchema())
partitionID := info.PartitionID l.node.streaming.replica.addCollection(collectionID, l.req.GetSchema())
l.node.historical.replica.addCollection(collectionID, l.req.Schema) for _, partitionID := range l.req.GetLoadMeta().GetPartitionIDs() {
err = l.node.historical.replica.addPartition(collectionID, partitionID) err = l.node.historical.replica.addPartition(collectionID, partitionID)
if err != nil { if err != nil {
return err return err
} }
l.node.streaming.replica.addCollection(collectionID, l.req.Schema)
err = l.node.streaming.replica.addPartition(collectionID, partitionID) err = l.node.streaming.replica.addPartition(collectionID, partitionID)
if err != nil { if err != nil {
return err return err