admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove RetrieveRequest and RetrieveTask (#6848)

Browse Source 
Signed-off-by: fishpenguin <kun.yu@zilliz.com>
This commit is contained in:
yukun 2021-08-16 17:06:10 +08:00 committed by GitHub
parent b035ec5c7b
commit 671b2737d2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 845 additions and 3029 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1549
internal/core/src/pb/milvus.pb.cc
View File

File diff suppressed because it is too large Load Diff

952
internal/core/src/pb/milvus.pb.h
View File

File diff suppressed because it is too large Load Diff

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

@ -374,10 +374,6 @@ func (s *Server) Search(ctx context.Context, request *milvuspb.SearchRequest) (*
return s.proxy.Search(ctx, request)
}
func (s *Server) Retrieve(ctx context.Context, request *milvuspb.RetrieveRequest) (*milvuspb.RetrieveResults, error) {
return s.proxy.Retrieve(ctx, request)
}
func (s *Server) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*milvuspb.FlushResponse, error) {
return s.proxy.Flush(ctx, request)
}

20
internal/proto/milvus.proto
View File

@ -32,7 +32,6 @@ service MilvusService {
rpc Insert(InsertRequest) returns (MutationResult) {}
rpc Search(SearchRequest) returns (SearchResults) {}
rpc Retrieve(RetrieveRequest) returns (RetrieveResults) {}
rpc Flush(FlushRequest) returns (FlushResponse) {}
rpc Query(QueryRequest) returns (QueryResults) {}
rpc CalcDistance(CalcDistanceRequest) returns (CalcDistanceResults) {}
@ -348,23 +347,6 @@ message SearchRequest {
uint64 guarantee_timestamp = 11; // guarantee_timestamp
}
message RetrieveRequest {
common.MsgBase base = 1; // must
string db_name = 2;
string collection_name = 3; // must
repeated string partition_names = 4; // must
schema.IDs ids = 5; // must
repeated string output_fields = 6; // must
uint64 travel_timestamp = 7;
uint64 guarantee_timestamp = 8; // guarantee_timestamp
}
message RetrieveResults {
common.Status status = 1;
schema.IDs ids = 2;
repeated schema.FieldData fields_data = 3;
}
message Hits {
repeated int64 IDs = 1;
repeated bytes row_data = 2;
@ -395,6 +377,8 @@ message QueryRequest {
string expr = 4;
repeated string output_fields = 5;
repeated string partition_names = 6;
uint64 travel_timestamp = 7;
uint64 guarantee_timestamp = 8; // guarantee_timestamp
}
message QueryResults {

616
internal/proto/milvuspb/milvus.pb.go
View File

@ -2666,156 +2666,6 @@ func (m *SearchRequest) GetGuaranteeTimestamp() uint64 {
return 0
}
type RetrieveRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
DbName string `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
CollectionName string `protobuf:"bytes,3,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
PartitionNames []string `protobuf:"bytes,4,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
Ids *schemapb.IDs `protobuf:"bytes,5,opt,name=ids,proto3" json:"ids,omitempty"`
OutputFields []string `protobuf:"bytes,6,rep,name=output_fields,json=outputFields,proto3" json:"output_fields,omitempty"`
TravelTimestamp uint64 `protobuf:"varint,7,opt,name=travel_timestamp,json=travelTimestamp,proto3" json:"travel_timestamp,omitempty"`
GuaranteeTimestamp uint64 `protobuf:"varint,8,opt,name=guarantee_timestamp,json=guaranteeTimestamp,proto3" json:"guarantee_timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RetrieveRequest) Reset() { *m = RetrieveRequest{} }
func (m *RetrieveRequest) String() string { return proto.CompactTextString(m) }
func (*RetrieveRequest) ProtoMessage() {}
func (*RetrieveRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{40}
}
func (m *RetrieveRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RetrieveRequest.Unmarshal(m, b)
}
func (m *RetrieveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RetrieveRequest.Marshal(b, m, deterministic)
}
func (m *RetrieveRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_RetrieveRequest.Merge(m, src)
}
func (m *RetrieveRequest) XXX_Size() int {
return xxx_messageInfo_RetrieveRequest.Size(m)
}
func (m *RetrieveRequest) XXX_DiscardUnknown() {
xxx_messageInfo_RetrieveRequest.DiscardUnknown(m)
}
var xxx_messageInfo_RetrieveRequest proto.InternalMessageInfo
func (m *RetrieveRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *RetrieveRequest) GetDbName() string {
if m != nil {
return m.DbName
}
return ""
}
func (m *RetrieveRequest) GetCollectionName() string {
if m != nil {
return m.CollectionName
}
return ""
}
func (m *RetrieveRequest) GetPartitionNames() []string {
if m != nil {
return m.PartitionNames
}
return nil
}
func (m *RetrieveRequest) GetIds() *schemapb.IDs {
if m != nil {
return m.Ids
}
return nil
}
func (m *RetrieveRequest) GetOutputFields() []string {
if m != nil {
return m.OutputFields
}
return nil
}
func (m *RetrieveRequest) GetTravelTimestamp() uint64 {
if m != nil {
return m.TravelTimestamp
}
return 0
}
func (m *RetrieveRequest) GetGuaranteeTimestamp() uint64 {
if m != nil {
return m.GuaranteeTimestamp
}
return 0
}
type RetrieveResults struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Ids *schemapb.IDs `protobuf:"bytes,2,opt,name=ids,proto3" json:"ids,omitempty"`
FieldsData []*schemapb.FieldData `protobuf:"bytes,3,rep,name=fields_data,json=fieldsData,proto3" json:"fields_data,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *RetrieveResults) Reset() { *m = RetrieveResults{} }
func (m *RetrieveResults) String() string { return proto.CompactTextString(m) }
func (*RetrieveResults) ProtoMessage() {}
func (*RetrieveResults) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{41}
}
func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_RetrieveResults.Unmarshal(m, b)
}
func (m *RetrieveResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_RetrieveResults.Marshal(b, m, deterministic)
}
func (m *RetrieveResults) XXX_Merge(src proto.Message) {
xxx_messageInfo_RetrieveResults.Merge(m, src)
}
func (m *RetrieveResults) XXX_Size() int {
return xxx_messageInfo_RetrieveResults.Size(m)
}
func (m *RetrieveResults) XXX_DiscardUnknown() {
xxx_messageInfo_RetrieveResults.DiscardUnknown(m)
}
var xxx_messageInfo_RetrieveResults proto.InternalMessageInfo
func (m *RetrieveResults) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *RetrieveResults) GetIds() *schemapb.IDs {
if m != nil {
return m.Ids
}
return nil
}
func (m *RetrieveResults) GetFieldsData() []*schemapb.FieldData {
if m != nil {
return m.FieldsData
}
return nil
}
type Hits struct {
IDs []int64 `protobuf:"varint,1,rep,packed,name=IDs,proto3" json:"IDs,omitempty"`
RowData [][]byte `protobuf:"bytes,2,rep,name=row_data,json=rowData,proto3" json:"row_data,omitempty"`
@ -2829,7 +2679,7 @@ func (m *Hits) Reset() { *m = Hits{} }
func (m *Hits) String() string { return proto.CompactTextString(m) }
func (*Hits) ProtoMessage() {}
func (*Hits) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{42}
return fileDescriptor_02345ba45cc0e303, []int{40}
}
func (m *Hits) XXX_Unmarshal(b []byte) error {
@ -2883,7 +2733,7 @@ func (m *SearchResults) Reset() { *m = SearchResults{} }
func (m *SearchResults) String() string { return proto.CompactTextString(m) }
func (*SearchResults) ProtoMessage() {}
func (*SearchResults) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{43}
return fileDescriptor_02345ba45cc0e303, []int{41}
}
func (m *SearchResults) XXX_Unmarshal(b []byte) error {
@ -2931,7 +2781,7 @@ func (m *FlushRequest) Reset() { *m = FlushRequest{} }
func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
func (*FlushRequest) ProtoMessage() {}
func (*FlushRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{44}
return fileDescriptor_02345ba45cc0e303, []int{42}
}
func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
@ -2986,7 +2836,7 @@ func (m *FlushResponse) Reset() { *m = FlushResponse{} }
func (m *FlushResponse) String() string { return proto.CompactTextString(m) }
func (*FlushResponse) ProtoMessage() {}
func (*FlushResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{45}
return fileDescriptor_02345ba45cc0e303, []int{43}
}
func (m *FlushResponse) XXX_Unmarshal(b []byte) error {
@ -3035,6 +2885,8 @@ type QueryRequest struct {
Expr string `protobuf:"bytes,4,opt,name=expr,proto3" json:"expr,omitempty"`
OutputFields []string `protobuf:"bytes,5,rep,name=output_fields,json=outputFields,proto3" json:"output_fields,omitempty"`
PartitionNames []string `protobuf:"bytes,6,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
TravelTimestamp uint64 `protobuf:"varint,7,opt,name=travel_timestamp,json=travelTimestamp,proto3" json:"travel_timestamp,omitempty"`
GuaranteeTimestamp uint64 `protobuf:"varint,8,opt,name=guarantee_timestamp,json=guaranteeTimestamp,proto3" json:"guarantee_timestamp,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -3044,7 +2896,7 @@ func (m *QueryRequest) Reset() { *m = QueryRequest{} }
func (m *QueryRequest) String() string { return proto.CompactTextString(m) }
func (*QueryRequest) ProtoMessage() {}
func (*QueryRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{46}
return fileDescriptor_02345ba45cc0e303, []int{44}
}
func (m *QueryRequest) XXX_Unmarshal(b []byte) error {
@ -3107,6 +2959,20 @@ func (m *QueryRequest) GetPartitionNames() []string {
return nil
}
func (m *QueryRequest) GetTravelTimestamp() uint64 {
if m != nil {
return m.TravelTimestamp
}
return 0
}
func (m *QueryRequest) GetGuaranteeTimestamp() uint64 {
if m != nil {
return m.GuaranteeTimestamp
}
return 0
}
type QueryResults struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
FieldsData []*schemapb.FieldData `protobuf:"bytes,2,rep,name=fields_data,json=fieldsData,proto3" json:"fields_data,omitempty"`
@ -3119,7 +2985,7 @@ func (m *QueryResults) Reset() { *m = QueryResults{} }
func (m *QueryResults) String() string { return proto.CompactTextString(m) }
func (*QueryResults) ProtoMessage() {}
func (*QueryResults) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{47}
return fileDescriptor_02345ba45cc0e303, []int{45}
}
func (m *QueryResults) XXX_Unmarshal(b []byte) error {
@ -3168,7 +3034,7 @@ func (m *VectorIDs) Reset() { *m = VectorIDs{} }
func (m *VectorIDs) String() string { return proto.CompactTextString(m) }
func (*VectorIDs) ProtoMessage() {}
func (*VectorIDs) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{48}
return fileDescriptor_02345ba45cc0e303, []int{46}
}
func (m *VectorIDs) XXX_Unmarshal(b []byte) error {
@ -3231,7 +3097,7 @@ func (m *VectorsArray) Reset() { *m = VectorsArray{} }
func (m *VectorsArray) String() string { return proto.CompactTextString(m) }
func (*VectorsArray) ProtoMessage() {}
func (*VectorsArray) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{49}
return fileDescriptor_02345ba45cc0e303, []int{47}
}
func (m *VectorsArray) XXX_Unmarshal(b []byte) error {
@ -3311,7 +3177,7 @@ func (m *CalcDistanceRequest) Reset() { *m = CalcDistanceRequest{} }
func (m *CalcDistanceRequest) String() string { return proto.CompactTextString(m) }
func (*CalcDistanceRequest) ProtoMessage() {}
func (*CalcDistanceRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{50}
return fileDescriptor_02345ba45cc0e303, []int{48}
}
func (m *CalcDistanceRequest) XXX_Unmarshal(b []byte) error {
@ -3377,7 +3243,7 @@ func (m *CalcDistanceResults) Reset() { *m = CalcDistanceResults{} }
func (m *CalcDistanceResults) String() string { return proto.CompactTextString(m) }
func (*CalcDistanceResults) ProtoMessage() {}
func (*CalcDistanceResults) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{51}
return fileDescriptor_02345ba45cc0e303, []int{49}
}
func (m *CalcDistanceResults) XXX_Unmarshal(b []byte) error {
@ -3465,7 +3331,7 @@ func (m *PersistentSegmentInfo) Reset() { *m = PersistentSegmentInfo{} }
func (m *PersistentSegmentInfo) String() string { return proto.CompactTextString(m) }
func (*PersistentSegmentInfo) ProtoMessage() {}
func (*PersistentSegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{52}
return fileDescriptor_02345ba45cc0e303, []int{50}
}
func (m *PersistentSegmentInfo) XXX_Unmarshal(b []byte) error {
@ -3534,7 +3400,7 @@ func (m *GetPersistentSegmentInfoRequest) Reset() { *m = GetPersistentSe
func (m *GetPersistentSegmentInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetPersistentSegmentInfoRequest) ProtoMessage() {}
func (*GetPersistentSegmentInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{53}
return fileDescriptor_02345ba45cc0e303, []int{51}
}
func (m *GetPersistentSegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@ -3588,7 +3454,7 @@ func (m *GetPersistentSegmentInfoResponse) Reset() { *m = GetPersistentS
func (m *GetPersistentSegmentInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GetPersistentSegmentInfoResponse) ProtoMessage() {}
func (*GetPersistentSegmentInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{54}
return fileDescriptor_02345ba45cc0e303, []int{52}
}
func (m *GetPersistentSegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@ -3640,7 +3506,7 @@ func (m *QuerySegmentInfo) Reset() { *m = QuerySegmentInfo{} }
func (m *QuerySegmentInfo) String() string { return proto.CompactTextString(m) }
func (*QuerySegmentInfo) ProtoMessage() {}
func (*QuerySegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{55}
return fileDescriptor_02345ba45cc0e303, []int{53}
}
func (m *QuerySegmentInfo) XXX_Unmarshal(b []byte) error {
@ -3723,7 +3589,7 @@ func (m *GetQuerySegmentInfoRequest) Reset() { *m = GetQuerySegmentInfoR
func (m *GetQuerySegmentInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetQuerySegmentInfoRequest) ProtoMessage() {}
func (*GetQuerySegmentInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{56}
return fileDescriptor_02345ba45cc0e303, []int{54}
}
func (m *GetQuerySegmentInfoRequest) XXX_Unmarshal(b []byte) error {
@ -3777,7 +3643,7 @@ func (m *GetQuerySegmentInfoResponse) Reset() { *m = GetQuerySegmentInfo
func (m *GetQuerySegmentInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GetQuerySegmentInfoResponse) ProtoMessage() {}
func (*GetQuerySegmentInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{57}
return fileDescriptor_02345ba45cc0e303, []int{55}
}
func (m *GetQuerySegmentInfoResponse) XXX_Unmarshal(b []byte) error {
@ -3823,7 +3689,7 @@ func (m *DummyRequest) Reset() { *m = DummyRequest{} }
func (m *DummyRequest) String() string { return proto.CompactTextString(m) }
func (*DummyRequest) ProtoMessage() {}
func (*DummyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{58}
return fileDescriptor_02345ba45cc0e303, []int{56}
}
func (m *DummyRequest) XXX_Unmarshal(b []byte) error {
@ -3862,7 +3728,7 @@ func (m *DummyResponse) Reset() { *m = DummyResponse{} }
func (m *DummyResponse) String() string { return proto.CompactTextString(m) }
func (*DummyResponse) ProtoMessage() {}
func (*DummyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{59}
return fileDescriptor_02345ba45cc0e303, []int{57}
}
func (m *DummyResponse) XXX_Unmarshal(b []byte) error {
@ -3900,7 +3766,7 @@ func (m *RegisterLinkRequest) Reset() { *m = RegisterLinkRequest{} }
func (m *RegisterLinkRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterLinkRequest) ProtoMessage() {}
func (*RegisterLinkRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{60}
return fileDescriptor_02345ba45cc0e303, []int{58}
}
func (m *RegisterLinkRequest) XXX_Unmarshal(b []byte) error {
@ -3933,7 +3799,7 @@ func (m *RegisterLinkResponse) Reset() { *m = RegisterLinkResponse{} }
func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterLinkResponse) ProtoMessage() {}
func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{61}
return fileDescriptor_02345ba45cc0e303, []int{59}
}
func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
@ -4011,8 +3877,6 @@ func init() {
proto.RegisterType((*PlaceholderValue)(nil), "milvus.proto.milvus.PlaceholderValue")
proto.RegisterType((*PlaceholderGroup)(nil), "milvus.proto.milvus.PlaceholderGroup")
proto.RegisterType((*SearchRequest)(nil), "milvus.proto.milvus.SearchRequest")
proto.RegisterType((*RetrieveRequest)(nil), "milvus.proto.milvus.RetrieveRequest")
proto.RegisterType((*RetrieveResults)(nil), "milvus.proto.milvus.RetrieveResults")
proto.RegisterType((*Hits)(nil), "milvus.proto.milvus.Hits")
proto.RegisterType((*SearchResults)(nil), "milvus.proto.milvus.SearchResults")
proto.RegisterType((*FlushRequest)(nil), "milvus.proto.milvus.FlushRequest")
@ -4039,194 +3903,190 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{
// 2989 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x5d, 0x6f, 0x24, 0x47,
0xd1, 0xb3, 0xeb, 0xfd, 0xaa, 0x9d, 0xb5, 0xf7, 0xda, 0x1f, 0xe7, 0x6c, 0xee, 0x72, 0xf6, 0x24,
0x47, 0x7c, 0x77, 0xc9, 0x5d, 0xce, 0x97, 0x90, 0x90, 0x00, 0xc9, 0xdd, 0x99, 0xdc, 0x59, 0xb9,
0x0b, 0xce, 0x38, 0x89, 0x08, 0x51, 0xb4, 0x1a, 0xef, 0xb4, 0x77, 0x47, 0x9e, 0x9d, 0x59, 0xa6,
0x7b, 0xed, 0xdb, 0x3c, 0x21, 0x25, 0x20, 0xa1, 0x40, 0x22, 0x04, 0x02, 0xf1, 0x0a, 0xe4, 0x81,
0x37, 0x42, 0x90, 0x40, 0x3c, 0xe7, 0x81, 0x07, 0x24, 0x3e, 0x5e, 0x79, 0xe1, 0x01, 0x1e, 0xf3,
0x07, 0x10, 0x12, 0xa8, 0x3f, 0x66, 0x76, 0x66, 0xb7, 0x67, 0xbd, 0xbe, 0x4d, 0xb0, 0xfd, 0x36,
0x53, 0x5d, 0xd5, 0x5d, 0x55, 0x5d, 0x5d, 0xd5, 0x5d, 0x55, 0xa0, 0xb7, 0x1d, 0x77, 0xaf, 0x4b,
0x2e, 0x77, 0x02, 0x9f, 0xfa, 0x68, 0x2e, 0xfe, 0x77, 0x59, 0xfc, 0xd4, 0xf4, 0x86, 0xdf, 0x6e,
0xfb, 0x9e, 0x00, 0xd6, 0x74, 0xd2, 0x68, 0xe1, 0xb6, 0x25, 0xfe, 0x8c, 0x4f, 0x34, 0x38, 0x7d,
0x33, 0xc0, 0x16, 0xc5, 0x37, 0x7d, 0xd7, 0xc5, 0x0d, 0xea, 0xf8, 0x9e, 0x89, 0xbf, 0xd5, 0xc5,
0x84, 0xa2, 0x27, 0x60, 0x7a, 0xdb, 0x22, 0x78, 0x49, 0x5b, 0xd6, 0x56, 0xcb, 0x6b, 0x67, 0x2e,
0x27, 0xe6, 0x96, 0x73, 0xde, 0x25, 0xcd, 0x1b, 0x16, 0xc1, 0x26, 0xc7, 0x44, 0xa7, 0xa1, 0x60,
0x6f, 0xd7, 0x3d, 0xab, 0x8d, 0x97, 0x32, 0xcb, 0xda, 0x6a, 0xc9, 0xcc, 0xdb, 0xdb, 0x2f, 0x5b,
0x6d, 0x8c, 0x1e, 0x85, 0xd9, 0x46, 0x34, 0xbf, 0x40, 0xc8, 0x72, 0x84, 0x99, 0x3e, 0x98, 0x23,
0x2e, 0x42, 0x5e, 0xf0, 0xb7, 0x34, 0xbd, 0xac, 0xad, 0xea, 0xa6, 0xfc, 0x43, 0x67, 0x01, 0x48,
0xcb, 0x0a, 0x6c, 0x52, 0xf7, 0xba, 0xed, 0xa5, 0xdc, 0xb2, 0xb6, 0x9a, 0x33, 0x4b, 0x02, 0xf2,
0x72, 0xb7, 0x6d, 0xbc, 0xa7, 0xc1, 0xc2, 0x7a, 0xe0, 0x77, 0x8e, 0x85, 0x10, 0xc6, 0xaf, 0x34,
0x98, 0xbf, 0x6d, 0x91, 0xe3, 0xa1, 0xd1, 0xb3, 0x00, 0xd4, 0x69, 0xe3, 0x3a, 0xa1, 0x56, 0xbb,
0xc3, 0xb5, 0x3a, 0x6d, 0x96, 0x18, 0x64, 0x8b, 0x01, 0x8c, 0x37, 0x40, 0xbf, 0xe1, 0xfb, 0xae,
0x89, 0x49, 0xc7, 0xf7, 0x08, 0x46, 0xd7, 0x20, 0x4f, 0xa8, 0x45, 0xbb, 0x44, 0x32, 0xf9, 0xa0,
0x92, 0xc9, 0x2d, 0x8e, 0x62, 0x4a, 0x54, 0x34, 0x0f, 0xb9, 0x3d, 0xcb, 0xed, 0x0a, 0x1e, 0x8b,
0xa6, 0xf8, 0x31, 0xde, 0x84, 0x99, 0x2d, 0x1a, 0x38, 0x5e, 0xf3, 0x33, 0x9c, 0xbc, 0x14, 0x4e,
0xfe, 0x37, 0x0d, 0x1e, 0x58, 0xc7, 0xa4, 0x11, 0x38, 0xdb, 0xc7, 0xc4, 0x74, 0x0d, 0xd0, 0xfb,
0x90, 0x8d, 0x75, 0xae, 0xea, 0xac, 0x99, 0x80, 0x0d, 0x6c, 0x46, 0x6e, 0x70, 0x33, 0xfe, 0x9b,
0x81, 0x9a, 0x4a, 0xa8, 0x49, 0xd4, 0xf7, 0x95, 0xe8, 0x44, 0x65, 0x38, 0xd1, 0xf9, 0x24, 0x91,
0xf4, 0x06, 0xfd, 0xd5, 0xb6, 0x38, 0x20, 0x3a, 0x78, 0x83, 0x52, 0x65, 0x15, 0x52, 0xad, 0xc1,
0xc2, 0x9e, 0x13, 0xd0, 0xae, 0xe5, 0xd6, 0x1b, 0x2d, 0xcb, 0xf3, 0xb0, 0xcb, 0xf5, 0x44, 0x96,
0xa6, 0x97, 0xb3, 0xab, 0x25, 0x73, 0x4e, 0x0e, 0xde, 0x14, 0x63, 0x4c, 0x59, 0x04, 0x3d, 0x09,
0x8b, 0x9d, 0x56, 0x8f, 0x38, 0x8d, 0x21, 0xa2, 0x1c, 0x27, 0x9a, 0x0f, 0x47, 0x13, 0x54, 0x97,
0xe0, 0x54, 0x83, 0x7b, 0x2b, 0xbb, 0xce, 0xb4, 0x26, 0xd4, 0x98, 0xe7, 0x6a, 0xac, 0xca, 0x81,
0x57, 0x43, 0x38, 0x63, 0x2b, 0x44, 0xee, 0xd2, 0x46, 0x8c, 0xa0, 0xc0, 0x09, 0xe6, 0xe4, 0xe0,
0x6b, 0xb4, 0x11, 0xd1, 0x70, 0x47, 0x72, 0xc7, 0xb7, 0xec, 0xe3, 0xe1, 0x48, 0xde, 0xd7, 0x60,
0xc9, 0xc4, 0x2e, 0xb6, 0xc8, 0xf1, 0xb0, 0x71, 0xe3, 0xc7, 0x1a, 0x3c, 0x74, 0x0b, 0xd3, 0x98,
0xb5, 0x50, 0x8b, 0x3a, 0x84, 0x3a, 0x0d, 0x72, 0x94, 0x6c, 0x7d, 0xa0, 0xc1, 0xb9, 0x54, 0xb6,
0x26, 0x39, 0x3c, 0x4f, 0x43, 0x8e, 0x7d, 0x91, 0xa5, 0xcc, 0x72, 0x76, 0xb5, 0xbc, 0xb6, 0xa2,
0xa4, 0x79, 0x09, 0xf7, 0x5e, 0x67, 0x3e, 0x69, 0xd3, 0x72, 0x02, 0x53, 0xe0, 0x1b, 0xff, 0xd0,
0x60, 0x71, 0xab, 0xe5, 0xef, 0xf7, 0x59, 0xfa, 0x3c, 0x14, 0x94, 0x74, 0x27, 0xd9, 0x01, 0x77,
0x82, 0xae, 0xc2, 0x34, 0xed, 0x75, 0x30, 0xf7, 0x44, 0x33, 0x6b, 0x67, 0x2f, 0x2b, 0x2e, 0x07,
0x97, 0x19, 0x93, 0xaf, 0xf6, 0x3a, 0xd8, 0xe4, 0xa8, 0xe8, 0x02, 0x54, 0x07, 0x54, 0x1e, 0x1e,
0xc8, 0xd9, 0xa4, 0xce, 0x89, 0xf1, 0xfb, 0x0c, 0x9c, 0x1e, 0x12, 0x71, 0x12, 0x65, 0xab, 0xd6,
0xce, 0x28, 0xd7, 0x46, 0xe7, 0x21, 0x66, 0x02, 0x75, 0xc7, 0x26, 0x4b, 0xd9, 0xe5, 0xec, 0x6a,
0xd6, 0xac, 0xc4, 0xfc, 0x92, 0x4d, 0xd0, 0xe3, 0x80, 0x86, 0xdc, 0x85, 0xf0, 0x4a, 0xd3, 0xe6,
0xa9, 0x41, 0x7f, 0xc1, 0x7d, 0x92, 0xd2, 0x61, 0x08, 0x15, 0x4c, 0x9b, 0xf3, 0x0a, 0x8f, 0x41,
0xd0, 0x55, 0x98, 0x77, 0xbc, 0xbb, 0xb8, 0xed, 0x07, 0xbd, 0x7a, 0x07, 0x07, 0x0d, 0xec, 0x51,
0xab, 0x89, 0xc9, 0x52, 0x9e, 0x73, 0x34, 0x17, 0x8e, 0x6d, 0xf6, 0x87, 0x8c, 0x8f, 0x35, 0x58,
0x14, 0xb7, 0xae, 0x4d, 0x2b, 0xa0, 0xce, 0x51, 0x47, 0xae, 0xf3, 0x30, 0xd3, 0x09, 0xf9, 0x10,
0x78, 0xd3, 0x1c, 0xaf, 0x12, 0x41, 0xf9, 0x29, 0xfb, 0x48, 0x83, 0x79, 0x76, 0xc9, 0x3a, 0x49,
0x3c, 0xff, 0x5a, 0x83, 0xb9, 0xdb, 0x16, 0x39, 0x49, 0x2c, 0xff, 0x56, 0x86, 0xa0, 0x88, 0xe7,
0xa3, 0x74, 0xad, 0x0c, 0x31, 0xc9, 0x74, 0x18, 0xd5, 0x67, 0x12, 0x5c, 0x13, 0xe3, 0x77, 0xfd,
0x58, 0x75, 0xc2, 0x38, 0xff, 0x83, 0x06, 0x67, 0x6f, 0x61, 0x1a, 0x71, 0x7d, 0x2c, 0x62, 0xda,
0xb8, 0xd6, 0xf2, 0xbe, 0x88, 0xc8, 0x4a, 0xe6, 0x8f, 0x24, 0xf2, 0xbd, 0x97, 0x81, 0x05, 0x16,
0x16, 0x8e, 0x87, 0x11, 0x8c, 0x73, 0x29, 0x57, 0x18, 0x4a, 0x4e, 0x65, 0x28, 0x51, 0x3c, 0xcd,
0x8f, 0x1d, 0x4f, 0x8d, 0xdf, 0x64, 0xc4, 0x3d, 0x20, 0xae, 0x8d, 0x49, 0xb6, 0x45, 0xc1, 0x6b,
0x46, 0xc9, 0xab, 0x01, 0x7a, 0x04, 0xd9, 0x58, 0x0f, 0xe3, 0x63, 0x02, 0x76, 0x6c, 0xc3, 0xe3,
0xf7, 0x35, 0x58, 0x0c, 0x9f, 0x41, 0x5b, 0xb8, 0xd9, 0xc6, 0x1e, 0xbd, 0x7f, 0x1b, 0x1a, 0xb4,
0x80, 0x8c, 0xc2, 0x02, 0xce, 0x40, 0x89, 0x88, 0x75, 0xa2, 0x17, 0x4e, 0x1f, 0x60, 0x7c, 0xa8,
0xc1, 0xe9, 0x21, 0x76, 0x26, 0xd9, 0xc4, 0x25, 0x28, 0x38, 0x9e, 0x8d, 0xef, 0x45, 0xdc, 0x84,
0xbf, 0x6c, 0x64, 0xbb, 0xeb, 0xb8, 0x76, 0xc4, 0x46, 0xf8, 0x8b, 0x56, 0x40, 0xc7, 0x9e, 0xb5,
0xed, 0xe2, 0x3a, 0xc7, 0xe5, 0x86, 0x5c, 0x34, 0xcb, 0x02, 0xb6, 0xc1, 0x40, 0xc6, 0x0f, 0x34,
0x98, 0x63, 0xb6, 0x26, 0x79, 0x24, 0x9f, 0xaf, 0xce, 0x96, 0xa1, 0x1c, 0x33, 0x26, 0xc9, 0x6e,
0x1c, 0x64, 0xec, 0xc2, 0x7c, 0x92, 0x9d, 0x49, 0x74, 0xf6, 0x10, 0x40, 0xb4, 0x23, 0xc2, 0xe6,
0xb3, 0x66, 0x0c, 0x62, 0x7c, 0xaa, 0x01, 0x12, 0x57, 0x2a, 0xae, 0x8c, 0x23, 0xce, 0xb8, 0xec,
0x38, 0xd8, 0xb5, 0xe3, 0x5e, 0xbb, 0xc4, 0x21, 0x7c, 0x78, 0x1d, 0x74, 0x7c, 0x8f, 0x06, 0x56,
0xbd, 0x63, 0x05, 0x56, 0x5b, 0x1c, 0x9e, 0xb1, 0x1c, 0x6c, 0x99, 0x93, 0x6d, 0x72, 0x2a, 0xe3,
0x8f, 0xec, 0x32, 0x26, 0x8d, 0xf2, 0xb8, 0x4b, 0x7c, 0x16, 0x80, 0x1b, 0xad, 0x18, 0xce, 0x89,
0x61, 0x0e, 0xe1, 0x21, 0xec, 0x43, 0x0d, 0xaa, 0x5c, 0x04, 0x21, 0x4f, 0x87, 0x4d, 0x3b, 0x40,
0xa3, 0x0d, 0xd0, 0x8c, 0x38, 0x42, 0x5f, 0x82, 0xbc, 0x54, 0x6c, 0x76, 0x5c, 0xc5, 0x4a, 0x82,
0x03, 0xc4, 0x30, 0x7e, 0xae, 0xc1, 0xc2, 0x80, 0xca, 0x27, 0xb1, 0xe8, 0x57, 0x01, 0x09, 0x09,
0xed, 0xbe, 0xd8, 0x61, 0xb8, 0x3d, 0xaf, 0x8c, 0x2d, 0x83, 0x4a, 0x32, 0x4f, 0x39, 0x03, 0x10,
0x62, 0xfc, 0x45, 0x83, 0x33, 0xb7, 0x30, 0xe5, 0xa8, 0x37, 0x98, 0xef, 0xd8, 0x0c, 0xfc, 0x66,
0x80, 0x09, 0x39, 0xb9, 0xf6, 0xf1, 0x13, 0x71, 0x3f, 0x53, 0x89, 0x34, 0x89, 0xfe, 0x57, 0x40,
0xe7, 0x6b, 0x60, 0xbb, 0x1e, 0xf8, 0xfb, 0x44, 0xda, 0x51, 0x59, 0xc2, 0x4c, 0x7f, 0x9f, 0x1b,
0x04, 0xf5, 0xa9, 0xe5, 0x0a, 0x04, 0x19, 0x18, 0x38, 0x84, 0x0d, 0xf3, 0x33, 0x18, 0x32, 0xc6,
0x26, 0xc7, 0x27, 0x57, 0xc7, 0xbf, 0xd4, 0x60, 0x61, 0x40, 0x94, 0x49, 0x74, 0xfb, 0x94, 0xb8,
0x3d, 0x0a, 0x61, 0x66, 0xd6, 0xce, 0x29, 0x69, 0x62, 0x8b, 0x09, 0x6c, 0x74, 0x0e, 0xca, 0x3b,
0x96, 0xe3, 0xd6, 0x03, 0x6c, 0x11, 0xdf, 0x93, 0x82, 0x02, 0x03, 0x99, 0x1c, 0x62, 0x7c, 0xa2,
0x41, 0x95, 0x3d, 0x41, 0x4f, 0xb8, 0xc7, 0xfb, 0x45, 0x06, 0x2a, 0x1b, 0x1e, 0xc1, 0x01, 0x3d,
0xfe, 0x2f, 0x0c, 0xf4, 0x3c, 0x94, 0xb9, 0x60, 0xa4, 0x6e, 0x5b, 0xd4, 0x92, 0xe1, 0xea, 0x21,
0x65, 0x16, 0xf9, 0x45, 0x86, 0xb7, 0x6e, 0x51, 0xcb, 0x14, 0xda, 0x21, 0xec, 0x1b, 0x3d, 0x08,
0xa5, 0x96, 0x45, 0x5a, 0xf5, 0x5d, 0xdc, 0x13, 0xd7, 0xbe, 0x8a, 0x59, 0x64, 0x80, 0x97, 0x70,
0x8f, 0xa0, 0x07, 0xa0, 0xe8, 0x75, 0xdb, 0xe2, 0x80, 0x15, 0x96, 0xb5, 0xd5, 0x8a, 0x59, 0xf0,
0xba, 0x6d, 0x7e, 0xbc, 0xfe, 0x94, 0x81, 0x99, 0xbb, 0x5d, 0xf6, 0x9e, 0xe1, 0x39, 0xf0, 0xae,
0x4b, 0xef, 0xcf, 0x18, 0x2f, 0x42, 0x56, 0xdc, 0x19, 0x18, 0xc5, 0x92, 0x92, 0xf1, 0x8d, 0x75,
0x62, 0x32, 0x24, 0x5e, 0x67, 0xea, 0x36, 0x1a, 0xf2, 0x92, 0x95, 0xe5, 0xcc, 0x96, 0x18, 0x84,
0x5b, 0x1c, 0x13, 0x05, 0x07, 0x41, 0x74, 0x05, 0xe3, 0xa2, 0xe0, 0x20, 0x10, 0x83, 0x06, 0xe8,
0x56, 0x63, 0xd7, 0xf3, 0xf7, 0x5d, 0x6c, 0x37, 0xb1, 0xcd, 0xb7, 0xbd, 0x68, 0x26, 0x60, 0xc2,
0x30, 0xd8, 0xc6, 0xd7, 0x1b, 0x1e, 0xe5, 0x0f, 0x89, 0x2c, 0x33, 0x0c, 0x06, 0xb9, 0xe9, 0x51,
0x36, 0x6c, 0x63, 0x17, 0x53, 0xcc, 0x87, 0x0b, 0x62, 0x58, 0x40, 0xe4, 0x70, 0xb7, 0x13, 0x51,
0x17, 0xc5, 0xb0, 0x80, 0xb0, 0xe1, 0x33, 0x50, 0xea, 0x27, 0xb9, 0x4b, 0xfd, 0x6c, 0xa0, 0x48,
0x6d, 0xef, 0x41, 0x75, 0xd3, 0xb5, 0x1a, 0xb8, 0xe5, 0xbb, 0x36, 0x0e, 0x78, 0xf4, 0x43, 0x55,
0xc8, 0x52, 0xab, 0x29, 0xc3, 0x2b, 0xfb, 0x44, 0xcf, 0xc8, 0x37, 0x8e, 0x38, 0xb8, 0x8f, 0x28,
0xe3, 0x50, 0x6c, 0x9a, 0x58, 0xea, 0x70, 0x11, 0xf2, 0xbc, 0x34, 0x23, 0x02, 0xaf, 0x6e, 0xca,
0x3f, 0xe3, 0xad, 0xc4, 0xba, 0xb7, 0x02, 0xbf, 0xdb, 0x41, 0x1b, 0xa0, 0x77, 0xfa, 0x30, 0xb6,
0x9b, 0xe9, 0x51, 0x6f, 0x90, 0x69, 0x33, 0x41, 0x6a, 0x7c, 0x9a, 0x85, 0xca, 0x16, 0xb6, 0x82,
0x46, 0xeb, 0x24, 0x24, 0x1b, 0x98, 0xc6, 0x6d, 0xe2, 0x4a, 0x97, 0xc0, 0x3e, 0xd1, 0x25, 0x38,
0x15, 0x13, 0xa8, 0xde, 0x64, 0x0a, 0xe2, 0x96, 0xa1, 0x9b, 0xd5, 0xce, 0xa0, 0xe2, 0x9e, 0x86,
0xa2, 0x4d, 0xdc, 0x3a, 0xdf, 0xa2, 0x02, 0xdf, 0x22, 0xb5, 0x7c, 0xeb, 0xc4, 0xe5, 0x5b, 0x53,
0xb0, 0xc5, 0x07, 0x7a, 0x18, 0x2a, 0x7e, 0x97, 0x76, 0xba, 0xb4, 0x2e, 0x4e, 0xe6, 0x52, 0x91,
0xb3, 0xa7, 0x0b, 0x20, 0x3f, 0xb8, 0x04, 0xbd, 0x08, 0x15, 0xc2, 0x55, 0x19, 0xde, 0x4d, 0x4b,
0xe3, 0x5e, 0xa1, 0x74, 0x41, 0x27, 0x2e, 0xa7, 0xe8, 0x02, 0x54, 0x69, 0x60, 0xed, 0x61, 0x37,
0x56, 0x74, 0x01, 0x6e, 0x8f, 0xb3, 0x02, 0xde, 0x2f, 0xd2, 0x5c, 0x81, 0xb9, 0x66, 0xd7, 0x0a,
0x2c, 0x8f, 0x62, 0x1c, 0xc3, 0x2e, 0x73, 0x6c, 0x14, 0x0d, 0xf5, 0x2b, 0x34, 0x7f, 0xcf, 0xc0,
0xac, 0x89, 0x69, 0xe0, 0xe0, 0x3d, 0x7c, 0x22, 0x76, 0xfc, 0x22, 0x64, 0x1d, 0x9b, 0xf0, 0x1d,
0x1f, 0xe9, 0x7e, 0x1c, 0x9b, 0x0c, 0xef, 0x52, 0x5e, 0xb1, 0x4b, 0x2a, 0xed, 0x16, 0x0e, 0xa5,
0xdd, 0x62, 0xaa, 0x76, 0x3f, 0xd6, 0xe2, 0xda, 0x65, 0x3e, 0x97, 0xdc, 0xb7, 0xd3, 0x65, 0x52,
0x67, 0xc6, 0x91, 0x7a, 0x20, 0xc2, 0x64, 0x0f, 0x1b, 0x61, 0x8c, 0x97, 0x60, 0xfa, 0xb6, 0x43,
0xf9, 0xe1, 0x62, 0x9e, 0x5e, 0xe3, 0xaf, 0x43, 0xee, 0xcf, 0x1f, 0x80, 0x62, 0xe0, 0xef, 0x8b,
0x79, 0x33, 0xdc, 0x2d, 0x15, 0x02, 0x7f, 0x9f, 0x87, 0x25, 0xde, 0x6a, 0xe0, 0x07, 0xd2, 0x5f,
0x65, 0x4c, 0xf9, 0x67, 0x7c, 0x47, 0xeb, 0x3b, 0x94, 0x09, 0x14, 0xf0, 0x3c, 0x14, 0x02, 0x41,
0x3f, 0xb2, 0xf0, 0x1a, 0x5f, 0x89, 0xcb, 0x15, 0x52, 0x19, 0xef, 0x6a, 0xa0, 0xbf, 0xe8, 0x76,
0xc9, 0xe7, 0xe1, 0xd7, 0x54, 0xa5, 0x96, 0xac, 0xba, 0xcc, 0xf3, 0xc3, 0x0c, 0x54, 0x24, 0x1b,
0x93, 0xdc, 0x08, 0x53, 0x59, 0xd9, 0x82, 0x32, 0x5b, 0xb2, 0x4e, 0x70, 0x33, 0xcc, 0x53, 0x95,
0xd7, 0xd6, 0x94, 0x91, 0x20, 0xc1, 0x06, 0x2f, 0x59, 0x6f, 0x71, 0xa2, 0xaf, 0x79, 0x34, 0xe8,
0x99, 0xd0, 0x88, 0x00, 0xb5, 0xb7, 0x60, 0x76, 0x60, 0x98, 0xd9, 0xc6, 0x2e, 0xee, 0x85, 0xa1,
0x6e, 0x17, 0xf7, 0xd0, 0x93, 0xf1, 0xc6, 0x82, 0x34, 0x83, 0xbb, 0xe3, 0x7b, 0xcd, 0xeb, 0x41,
0x60, 0xf5, 0x64, 0xe3, 0xc1, 0xb3, 0x99, 0x67, 0x34, 0xe3, 0x9f, 0x1a, 0xe8, 0xaf, 0x74, 0x71,
0xd0, 0x3b, 0x4a, 0x07, 0x84, 0x60, 0x1a, 0xdf, 0xeb, 0x04, 0xf2, 0xd2, 0xc6, 0xbf, 0x87, 0xfd,
0x47, 0x4e, 0xe1, 0x3f, 0x14, 0x9e, 0x2b, 0xaf, 0x4c, 0x8c, 0xbf, 0xdb, 0x17, 0x73, 0xa2, 0x83,
0x90, 0x38, 0xdd, 0x99, 0x43, 0x9f, 0xee, 0x8f, 0x34, 0x28, 0xbd, 0x8e, 0x1b, 0xd4, 0x0f, 0xd8,
0x89, 0x56, 0xe8, 0x47, 0x1b, 0xe3, 0x8a, 0x9e, 0x19, 0xbc, 0xa2, 0x5f, 0x83, 0xa2, 0x63, 0xd7,
0x2d, 0xb6, 0xb5, 0x5c, 0xc1, 0xa3, 0xbc, 0x54, 0xc1, 0xb1, 0xb9, 0x0d, 0x8c, 0x5f, 0x53, 0xf8,
0xa9, 0x06, 0xba, 0xe0, 0x99, 0x08, 0xca, 0xe7, 0x62, 0xcb, 0x69, 0x2a, 0x7b, 0x93, 0x3f, 0x91,
0xa0, 0xb7, 0xa7, 0xfa, 0xcb, 0x5e, 0x07, 0x60, 0xba, 0x93, 0xe4, 0xc2, 0x5c, 0x97, 0x95, 0xdc,
0x0a, 0x72, 0xae, 0xc7, 0xdb, 0x53, 0x66, 0x89, 0x51, 0xf1, 0x29, 0x6e, 0x14, 0x20, 0xc7, 0xa9,
0x8d, 0xff, 0x68, 0x30, 0x77, 0xd3, 0x72, 0x1b, 0xeb, 0x0e, 0xa1, 0x96, 0xd7, 0x98, 0x20, 0x86,
0x3e, 0x0b, 0x05, 0xbf, 0x53, 0x77, 0xf1, 0x0e, 0x95, 0x2c, 0xad, 0x8c, 0x90, 0x48, 0xa8, 0xc1,
0xcc, 0xfb, 0x9d, 0x3b, 0x78, 0x87, 0xa2, 0x2f, 0x43, 0xd1, 0xef, 0xd4, 0x03, 0xa7, 0xd9, 0xa2,
0x52, 0xfb, 0x63, 0x10, 0x17, 0xfc, 0x8e, 0xc9, 0x28, 0x62, 0x39, 0x9e, 0xe9, 0x43, 0xe6, 0x78,
0x8c, 0xbf, 0x0e, 0x89, 0x3f, 0x81, 0x69, 0x3f, 0x0b, 0x45, 0xc7, 0xa3, 0x75, 0xdb, 0x21, 0xa1,
0x0a, 0xce, 0xaa, 0x6d, 0xc8, 0xa3, 0x5c, 0x02, 0xbe, 0xa7, 0x1e, 0x65, 0x6b, 0xa3, 0x17, 0x00,
0x76, 0x5c, 0xdf, 0x92, 0xd4, 0x42, 0x07, 0xe7, 0xd4, 0xa7, 0x82, 0xa1, 0x85, 0xf4, 0x25, 0x4e,
0xc4, 0x66, 0xe8, 0x6f, 0xe9, 0x9f, 0x35, 0x58, 0xd8, 0xc4, 0x01, 0x71, 0x08, 0xc5, 0x1e, 0x95,
0xf9, 0xd6, 0x0d, 0x6f, 0xc7, 0x4f, 0x26, 0xb6, 0xb5, 0x81, 0xc4, 0xf6, 0x67, 0x93, 0xe6, 0x4d,
0xbc, 0xe0, 0x44, 0x79, 0x25, 0x7c, 0xc1, 0x85, 0x45, 0x24, 0xf1, 0x02, 0x9e, 0x49, 0xd9, 0x26,
0xc9, 0x6f, 0x3c, 0x11, 0x60, 0xfc, 0x48, 0x34, 0x74, 0x28, 0x85, 0xba, 0x7f, 0x83, 0x5d, 0x04,
0xe9, 0x64, 0x07, 0x5c, 0xee, 0x17, 0x60, 0xc0, 0x77, 0xa4, 0xb4, 0x99, 0xfc, 0x4c, 0x83, 0xe5,
0x74, 0xae, 0x26, 0x89, 0x8e, 0x2f, 0x40, 0xce, 0xf1, 0x76, 0xfc, 0x30, 0xfd, 0x77, 0x51, 0xfd,
0x10, 0x52, 0xae, 0x2b, 0x08, 0x8d, 0x7f, 0x69, 0x50, 0xe5, 0xbe, 0xfa, 0x08, 0xb6, 0xbf, 0x8d,
0xdb, 0x75, 0xe2, 0xbc, 0x8d, 0xc3, 0xed, 0x6f, 0xe3, 0xf6, 0x96, 0xf3, 0x36, 0x4e, 0x58, 0x46,
0x2e, 0x69, 0x19, 0xc9, 0x04, 0x49, 0x7e, 0x44, 0x7a, 0xb7, 0x90, 0x48, 0xef, 0x1a, 0xef, 0x6b,
0x50, 0xbb, 0x85, 0xe9, 0xa0, 0xa8, 0x47, 0x67, 0x14, 0x1f, 0x68, 0xf0, 0xa0, 0x92, 0xa1, 0x49,
0xec, 0xe1, 0xb9, 0xa4, 0x3d, 0xa8, 0x1f, 0xc6, 0x43, 0x4b, 0x4a, 0x53, 0xb8, 0x0a, 0xfa, 0x7a,
0xb7, 0xdd, 0x8e, 0x2e, 0x27, 0x2b, 0xa0, 0x07, 0xe2, 0x53, 0xbc, 0x1b, 0x45, 0xb8, 0x2c, 0x4b,
0x18, 0x7b, 0x1d, 0x1a, 0x97, 0xa0, 0x22, 0x49, 0x24, 0xd7, 0x35, 0x28, 0x06, 0xf2, 0x5b, 0xe2,
0x47, 0xff, 0xc6, 0x02, 0xcc, 0x99, 0xb8, 0xc9, 0x2c, 0x31, 0xb8, 0xe3, 0x78, 0xbb, 0x72, 0x19,
0xe3, 0x1d, 0x0d, 0xe6, 0x93, 0x70, 0x39, 0xd7, 0x17, 0xa1, 0x60, 0xd9, 0x76, 0x80, 0x09, 0x19,
0xb9, 0x2d, 0xd7, 0x05, 0x8e, 0x19, 0x22, 0xc7, 0x34, 0x97, 0x19, 0x5b, 0x73, 0x17, 0x57, 0xa0,
0x18, 0x96, 0x60, 0x51, 0x01, 0xb2, 0xd7, 0x5d, 0xb7, 0x3a, 0x85, 0x74, 0x28, 0x6e, 0xc8, 0x3a,
0x63, 0x55, 0xbb, 0xf8, 0x55, 0x98, 0x1d, 0xc8, 0x60, 0xa0, 0x22, 0x4c, 0xbf, 0xec, 0x7b, 0xb8,
0x3a, 0x85, 0xaa, 0xa0, 0xdf, 0x70, 0x3c, 0x2b, 0xe8, 0x89, 0xc8, 0x53, 0xb5, 0xd1, 0x2c, 0x94,
0xb9, 0x07, 0x96, 0x00, 0xbc, 0xf6, 0xef, 0xd3, 0x50, 0xb9, 0xcb, 0x39, 0xd9, 0xc2, 0xc1, 0x9e,
0xd3, 0xc0, 0xa8, 0x0e, 0xd5, 0xc1, 0x26, 0x6a, 0xf4, 0x98, 0x72, 0xcf, 0x52, 0x7a, 0xad, 0x6b,
0xa3, 0x64, 0x33, 0xa6, 0xd0, 0x9b, 0x30, 0x93, 0x6c, 0x6f, 0x46, 0x6a, 0x17, 0xa1, 0xec, 0x81,
0x3e, 0x68, 0xf2, 0x3a, 0x54, 0x12, 0xdd, 0xca, 0xe8, 0x82, 0x72, 0x6e, 0x55, 0x47, 0x73, 0x4d,
0x1d, 0xb5, 0xe3, 0x1d, 0xc5, 0x82, 0xfb, 0x64, 0x4f, 0x65, 0x0a, 0xf7, 0xca, 0xc6, 0xcb, 0x83,
0xb8, 0xb7, 0xe0, 0xd4, 0x50, 0x8b, 0x24, 0x7a, 0x5c, 0x39, 0x7f, 0x5a, 0x2b, 0xe5, 0x41, 0x4b,
0xec, 0x03, 0x1a, 0xee, 0xca, 0x45, 0x97, 0xd5, 0x3b, 0x90, 0xd6, 0x93, 0x5c, 0xbb, 0x32, 0x36,
0x7e, 0xa4, 0xb8, 0xef, 0x6a, 0x70, 0x3a, 0xa5, 0xaf, 0x11, 0x5d, 0x53, 0x4e, 0x37, 0xba, 0x39,
0xb3, 0xf6, 0xe4, 0xe1, 0x88, 0x22, 0x46, 0x3c, 0x98, 0x1d, 0x68, 0xf5, 0x43, 0x97, 0x52, 0xdb,
0x1f, 0x86, 0x7b, 0x1e, 0x6b, 0x8f, 0x8d, 0x87, 0x1c, 0xad, 0xc7, 0xde, 0x6f, 0xc9, 0xfe, 0xb8,
0x94, 0xf5, 0xd4, 0x5d, 0x74, 0x07, 0x6d, 0xe8, 0x1b, 0x50, 0x49, 0x34, 0xb2, 0xa5, 0x58, 0xbc,
0xaa, 0xd9, 0xed, 0xa0, 0xa9, 0xdf, 0x02, 0x3d, 0xde, 0x6f, 0x86, 0x56, 0xd3, 0xce, 0xd2, 0xd0,
0xc4, 0x87, 0x39, 0x4a, 0xfd, 0x76, 0x92, 0x11, 0x47, 0x69, 0xa8, 0x03, 0x67, 0xfc, 0xa3, 0x14,
0x9b, 0x7f, 0xe4, 0x51, 0x3a, 0xf4, 0x12, 0xef, 0x68, 0xb0, 0xa8, 0x6e, 0x57, 0x42, 0x6b, 0x69,
0xb6, 0x99, 0xde, 0x98, 0x55, 0xbb, 0x76, 0x28, 0x9a, 0x48, 0x8b, 0xbb, 0x30, 0x93, 0x6c, 0xca,
0x49, 0xd1, 0xa2, 0xb2, 0x8f, 0xa9, 0x76, 0x69, 0x2c, 0xdc, 0x68, 0xb1, 0xd7, 0xa0, 0x1c, 0x6b,
0x4c, 0x40, 0x8f, 0x8e, 0xb0, 0xe3, 0x78, 0x59, 0xeb, 0x20, 0x4d, 0xb6, 0xa0, 0x92, 0x28, 0x46,
0xa7, 0xd9, 0xb0, 0xa2, 0x47, 0xa0, 0x76, 0x71, 0x1c, 0xd4, 0x48, 0x80, 0x16, 0x54, 0x12, 0xa5,
0xc1, 0x94, 0x95, 0x54, 0x95, 0xd0, 0x94, 0x95, 0x94, 0x95, 0x46, 0x63, 0x0a, 0x7d, 0x3b, 0x56,
0x85, 0x4c, 0x54, 0x7a, 0xd1, 0xd5, 0x91, 0xf3, 0xa8, 0x0a, 0xdd, 0xb5, 0xb5, 0xc3, 0x90, 0x44,
0x2c, 0xbc, 0x02, 0xa5, 0xa8, 0xc0, 0x88, 0xce, 0xa7, 0xba, 0x85, 0xc3, 0xec, 0xd4, 0x16, 0xe4,
0x45, 0xb1, 0x0f, 0x19, 0x29, 0x65, 0xfd, 0x58, 0x25, 0xb0, 0xf6, 0xb0, 0x12, 0x27, 0x59, 0x07,
0x33, 0xa6, 0x90, 0x09, 0x79, 0x91, 0x3a, 0x4c, 0x99, 0x34, 0x51, 0x12, 0xa9, 0x8d, 0xc6, 0x11,
0xf9, 0xc6, 0x29, 0xf4, 0x0d, 0x28, 0x86, 0xb9, 0x5f, 0xf4, 0x48, 0xca, 0xb1, 0x4f, 0x24, 0xde,
0x6b, 0x07, 0x61, 0x85, 0x33, 0x6f, 0x42, 0x8e, 0x27, 0xef, 0xd0, 0xca, 0xa8, 0xc4, 0xde, 0x28,
0x5e, 0x13, 0xb9, 0x3f, 0x63, 0x0a, 0x7d, 0x1d, 0x72, 0xfc, 0xfe, 0x9b, 0x32, 0x63, 0x3c, 0x3b,
0x57, 0x1b, 0x89, 0x12, 0xb2, 0x68, 0x83, 0x1e, 0xcf, 0x0b, 0xa4, 0x38, 0x6e, 0x45, 0xe6, 0xa4,
0x36, 0x0e, 0x66, 0xb8, 0xca, 0xf7, 0x34, 0x58, 0x4a, 0x7b, 0x42, 0xa2, 0xd4, 0xe8, 0x3c, 0xea,
0x1d, 0x5c, 0x7b, 0xea, 0x90, 0x54, 0x91, 0x0a, 0xdf, 0x86, 0x39, 0xc5, 0xc3, 0x05, 0x5d, 0x49,
0x9b, 0x2f, 0xe5, 0xcd, 0x55, 0x7b, 0x62, 0x7c, 0x82, 0x68, 0xed, 0x4d, 0xc8, 0xf1, 0x07, 0x47,
0xca, 0xf6, 0xc5, 0xdf, 0x2f, 0x29, 0x06, 0x91, 0x78, 0xaf, 0x18, 0x53, 0x08, 0x83, 0x1e, 0x7f,
0x7d, 0xa4, 0xec, 0x9f, 0xe2, 0xe1, 0x52, 0xbb, 0x30, 0x06, 0x66, 0xb8, 0xcc, 0x5a, 0x17, 0xf4,
0xcd, 0xc0, 0xbf, 0xd7, 0x0b, 0xaf, 0xfe, 0xff, 0x9f, 0x65, 0x6f, 0x3c, 0xf5, 0xcd, 0x6b, 0x4d,
0x87, 0xb6, 0xba, 0xdb, 0xcc, 0xbb, 0x5c, 0x11, 0xb8, 0x8f, 0x3b, 0xbe, 0xfc, 0xba, 0xe2, 0x78,
0x14, 0x07, 0x9e, 0xe5, 0x5e, 0xe1, 0x73, 0x49, 0x68, 0x67, 0x7b, 0x3b, 0xcf, 0xff, 0xaf, 0xfd,
0x2f, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x57, 0x35, 0x52, 0x26, 0x3a, 0x00, 0x00,
// 2925 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3a, 0xdd, 0x6f, 0x1c, 0x57,
0xf5, 0x9e, 0x5d, 0xef, 0xd7, 0xd9, 0x59, 0x7b, 0x73, 0xfd, 0x11, 0x77, 0x9b, 0x34, 0xf6, 0xf4,
0x97, 0x5f, 0x9d, 0xa4, 0x4d, 0x1a, 0xa7, 0xa5, 0xa5, 0x05, 0xda, 0x24, 0xa6, 0x89, 0xd5, 0xa4,
0xb8, 0xe3, 0xb6, 0x52, 0xa9, 0xaa, 0xd1, 0x78, 0xe7, 0x7a, 0x77, 0xe4, 0xd9, 0x99, 0x65, 0xee,
0xdd, 0x38, 0xdb, 0x27, 0xa4, 0x02, 0x12, 0x2a, 0xb4, 0x42, 0x20, 0x10, 0x6f, 0x08, 0xe8, 0x03,
0x6f, 0x14, 0x90, 0x40, 0x3c, 0xf1, 0xd0, 0x07, 0x1e, 0x90, 0xf8, 0xf8, 0x0b, 0x78, 0xe1, 0xb1,
0xff, 0x01, 0x12, 0xe8, 0x7e, 0xcc, 0xec, 0xcc, 0xfa, 0xce, 0x7a, 0x9d, 0x6d, 0xb0, 0xfd, 0x36,
0x73, 0xee, 0x39, 0xf7, 0x9e, 0x7b, 0xee, 0xb9, 0xe7, 0xdc, 0xf3, 0x01, 0x7a, 0xc7, 0xf5, 0xee,
0xf5, 0xc8, 0xe5, 0x6e, 0x18, 0xd0, 0x00, 0xcd, 0x25, 0xff, 0x2e, 0x8b, 0x9f, 0x86, 0xde, 0x0c,
0x3a, 0x9d, 0xc0, 0x17, 0xc0, 0x86, 0x4e, 0x9a, 0x6d, 0xdc, 0xb1, 0xc5, 0x9f, 0xf1, 0xa9, 0x06,
0xa7, 0x6f, 0x86, 0xd8, 0xa6, 0xf8, 0x66, 0xe0, 0x79, 0xb8, 0x49, 0xdd, 0xc0, 0x37, 0xf1, 0x37,
0x7a, 0x98, 0x50, 0xf4, 0x34, 0x4c, 0x6f, 0xdb, 0x04, 0x2f, 0x69, 0xcb, 0xda, 0x6a, 0x75, 0xed,
0xcc, 0xe5, 0xd4, 0xdc, 0x72, 0xce, 0xbb, 0xa4, 0x75, 0xc3, 0x26, 0xd8, 0xe4, 0x98, 0xe8, 0x34,
0x94, 0x9c, 0x6d, 0xcb, 0xb7, 0x3b, 0x78, 0x29, 0xb7, 0xac, 0xad, 0x56, 0xcc, 0xa2, 0xb3, 0xfd,
0x9a, 0xdd, 0xc1, 0xe8, 0x09, 0x98, 0x6d, 0xc6, 0xf3, 0x0b, 0x84, 0x3c, 0x47, 0x98, 0x19, 0x80,
0x39, 0xe2, 0x22, 0x14, 0x05, 0x7f, 0x4b, 0xd3, 0xcb, 0xda, 0xaa, 0x6e, 0xca, 0x3f, 0x74, 0x16,
0x80, 0xb4, 0xed, 0xd0, 0x21, 0x96, 0xdf, 0xeb, 0x2c, 0x15, 0x96, 0xb5, 0xd5, 0x82, 0x59, 0x11,
0x90, 0xd7, 0x7a, 0x1d, 0xe3, 0x03, 0x0d, 0x16, 0xd6, 0xc3, 0xa0, 0x7b, 0x2c, 0x36, 0x61, 0xfc,
0x4a, 0x83, 0xf9, 0xdb, 0x36, 0x39, 0x1e, 0x12, 0x3d, 0x0b, 0x40, 0xdd, 0x0e, 0xb6, 0x08, 0xb5,
0x3b, 0x5d, 0x2e, 0xd5, 0x69, 0xb3, 0xc2, 0x20, 0x5b, 0x0c, 0x60, 0xbc, 0x0d, 0xfa, 0x8d, 0x20,
0xf0, 0x4c, 0x4c, 0xba, 0x81, 0x4f, 0x30, 0xba, 0x06, 0x45, 0x42, 0x6d, 0xda, 0x23, 0x92, 0xc9,
0x47, 0x95, 0x4c, 0x6e, 0x71, 0x14, 0x53, 0xa2, 0xa2, 0x79, 0x28, 0xdc, 0xb3, 0xbd, 0x9e, 0xe0,
0xb1, 0x6c, 0x8a, 0x1f, 0xe3, 0x1d, 0x98, 0xd9, 0xa2, 0xa1, 0xeb, 0xb7, 0x3e, 0xc7, 0xc9, 0x2b,
0xd1, 0xe4, 0xff, 0xd0, 0xe0, 0x91, 0x75, 0x4c, 0x9a, 0xa1, 0xbb, 0x7d, 0x4c, 0x54, 0xd7, 0x00,
0x7d, 0x00, 0xd9, 0x58, 0xe7, 0xa2, 0xce, 0x9b, 0x29, 0xd8, 0xd0, 0x61, 0x14, 0x86, 0x0f, 0xe3,
0x3f, 0x39, 0x68, 0xa8, 0x36, 0x35, 0x89, 0xf8, 0xbe, 0x1c, 0xdf, 0xa8, 0x1c, 0x27, 0x3a, 0x9f,
0x26, 0x92, 0xd6, 0x60, 0xb0, 0xda, 0x16, 0x07, 0xc4, 0x17, 0x6f, 0x78, 0x57, 0x79, 0xc5, 0xae,
0xd6, 0x60, 0xe1, 0x9e, 0x1b, 0xd2, 0x9e, 0xed, 0x59, 0xcd, 0xb6, 0xed, 0xfb, 0xd8, 0xe3, 0x72,
0x22, 0x4b, 0xd3, 0xcb, 0xf9, 0xd5, 0x8a, 0x39, 0x27, 0x07, 0x6f, 0x8a, 0x31, 0x26, 0x2c, 0x82,
0x9e, 0x81, 0xc5, 0x6e, 0xbb, 0x4f, 0xdc, 0xe6, 0x3e, 0xa2, 0x02, 0x27, 0x9a, 0x8f, 0x46, 0x53,
0x54, 0x97, 0xe0, 0x54, 0x93, 0x5b, 0x2b, 0xc7, 0x62, 0x52, 0x13, 0x62, 0x2c, 0x72, 0x31, 0xd6,
0xe5, 0xc0, 0x1b, 0x11, 0x9c, 0xb1, 0x15, 0x21, 0xf7, 0x68, 0x33, 0x41, 0x50, 0xe2, 0x04, 0x73,
0x72, 0xf0, 0x4d, 0xda, 0x8c, 0x69, 0xb8, 0x21, 0xb9, 0x13, 0xd8, 0xce, 0xf1, 0x30, 0x24, 0x1f,
0x6a, 0xb0, 0x64, 0x62, 0x0f, 0xdb, 0xe4, 0x78, 0xe8, 0xb8, 0xf1, 0x23, 0x0d, 0x1e, 0xbb, 0x85,
0x69, 0x42, 0x5b, 0xa8, 0x4d, 0x5d, 0x42, 0xdd, 0x26, 0x39, 0x4a, 0xb6, 0x3e, 0xd2, 0xe0, 0x5c,
0x26, 0x5b, 0x93, 0x5c, 0x9e, 0xe7, 0xa0, 0xc0, 0xbe, 0xc8, 0x52, 0x6e, 0x39, 0xbf, 0x5a, 0x5d,
0x5b, 0x51, 0xd2, 0xbc, 0x8a, 0xfb, 0x6f, 0x31, 0x9b, 0xb4, 0x69, 0xbb, 0xa1, 0x29, 0xf0, 0x8d,
0x7f, 0x6a, 0xb0, 0xb8, 0xd5, 0x0e, 0xf6, 0x06, 0x2c, 0x3d, 0x0c, 0x01, 0xa5, 0xcd, 0x49, 0x7e,
0xc8, 0x9c, 0xa0, 0xab, 0x30, 0x4d, 0xfb, 0x5d, 0xcc, 0x2d, 0xd1, 0xcc, 0xda, 0xd9, 0xcb, 0x8a,
0xc7, 0xc1, 0x65, 0xc6, 0xe4, 0x1b, 0xfd, 0x2e, 0x36, 0x39, 0x2a, 0xba, 0x00, 0xf5, 0x21, 0x91,
0x47, 0x17, 0x72, 0x36, 0x2d, 0x73, 0x62, 0xfc, 0x21, 0x07, 0xa7, 0xf7, 0x6d, 0x71, 0x12, 0x61,
0xab, 0xd6, 0xce, 0x29, 0xd7, 0x46, 0xe7, 0x21, 0xa1, 0x02, 0x96, 0xeb, 0x90, 0xa5, 0xfc, 0x72,
0x7e, 0x35, 0x6f, 0xd6, 0x12, 0x76, 0xc9, 0x21, 0xe8, 0x29, 0x40, 0xfb, 0xcc, 0x85, 0xb0, 0x4a,
0xd3, 0xe6, 0xa9, 0x61, 0x7b, 0xc1, 0x6d, 0x92, 0xd2, 0x60, 0x08, 0x11, 0x4c, 0x9b, 0xf3, 0x0a,
0x8b, 0x41, 0xd0, 0x55, 0x98, 0x77, 0xfd, 0xbb, 0xb8, 0x13, 0x84, 0x7d, 0xab, 0x8b, 0xc3, 0x26,
0xf6, 0xa9, 0xdd, 0xc2, 0x64, 0xa9, 0xc8, 0x39, 0x9a, 0x8b, 0xc6, 0x36, 0x07, 0x43, 0xc6, 0x6f,
0x35, 0x58, 0x14, 0xaf, 0xae, 0x4d, 0x3b, 0xa4, 0xee, 0x51, 0x7b, 0xae, 0xf3, 0x30, 0xd3, 0x8d,
0xf8, 0x10, 0x78, 0xd3, 0x1c, 0xaf, 0x16, 0x43, 0xf9, 0x2d, 0xfb, 0x44, 0x83, 0x79, 0xf6, 0xc8,
0x3a, 0x49, 0x3c, 0xff, 0x5a, 0x83, 0xb9, 0xdb, 0x36, 0x39, 0x49, 0x2c, 0xff, 0x4e, 0xba, 0xa0,
0x98, 0xe7, 0xa3, 0x34, 0xad, 0x0c, 0x31, 0xcd, 0x74, 0xe4, 0xd5, 0x67, 0x52, 0x5c, 0x13, 0xe3,
0xf7, 0x03, 0x5f, 0x75, 0xc2, 0x38, 0xff, 0xa3, 0x06, 0x67, 0x6f, 0x61, 0x1a, 0x73, 0x7d, 0x2c,
0x7c, 0xda, 0xb8, 0xda, 0xf2, 0xa1, 0xf0, 0xc8, 0x4a, 0xe6, 0x8f, 0xc4, 0xf3, 0x7d, 0x90, 0x83,
0x05, 0xe6, 0x16, 0x8e, 0x87, 0x12, 0x8c, 0xf3, 0x28, 0x57, 0x28, 0x4a, 0x41, 0xa5, 0x28, 0xb1,
0x3f, 0x2d, 0x8e, 0xed, 0x4f, 0x8d, 0xdf, 0xe4, 0xc4, 0x3b, 0x20, 0x29, 0x8d, 0x49, 0x8e, 0x45,
0xc1, 0x6b, 0x4e, 0xc9, 0xab, 0x01, 0x7a, 0x0c, 0xd9, 0x58, 0x8f, 0xfc, 0x63, 0x0a, 0x76, 0x6c,
0xdd, 0xe3, 0xf7, 0x34, 0x58, 0x8c, 0xc2, 0xa0, 0x2d, 0xdc, 0xea, 0x60, 0x9f, 0x3e, 0xb8, 0x0e,
0x0d, 0x6b, 0x40, 0x4e, 0xa1, 0x01, 0x67, 0xa0, 0x42, 0xc4, 0x3a, 0x71, 0x84, 0x33, 0x00, 0x18,
0x1f, 0x6b, 0x70, 0x7a, 0x1f, 0x3b, 0x93, 0x1c, 0xe2, 0x12, 0x94, 0x5c, 0xdf, 0xc1, 0xf7, 0x63,
0x6e, 0xa2, 0x5f, 0x36, 0xb2, 0xdd, 0x73, 0x3d, 0x27, 0x66, 0x23, 0xfa, 0x45, 0x2b, 0xa0, 0x63,
0xdf, 0xde, 0xf6, 0xb0, 0xc5, 0x71, 0xb9, 0x22, 0x97, 0xcd, 0xaa, 0x80, 0x6d, 0x30, 0x90, 0xf1,
0x7d, 0x0d, 0xe6, 0x98, 0xae, 0x49, 0x1e, 0xc9, 0xc3, 0x95, 0xd9, 0x32, 0x54, 0x13, 0xca, 0x24,
0xd9, 0x4d, 0x82, 0x8c, 0x5d, 0x98, 0x4f, 0xb3, 0x33, 0x89, 0xcc, 0x1e, 0x03, 0x88, 0x4f, 0x44,
0xe8, 0x7c, 0xde, 0x4c, 0x40, 0x8c, 0xcf, 0x34, 0x40, 0xe2, 0x49, 0xc5, 0x85, 0x71, 0xc4, 0x19,
0x97, 0x1d, 0x17, 0x7b, 0x4e, 0xd2, 0x6a, 0x57, 0x38, 0x84, 0x0f, 0xaf, 0x83, 0x8e, 0xef, 0xd3,
0xd0, 0xb6, 0xba, 0x76, 0x68, 0x77, 0xc4, 0xe5, 0x19, 0xcb, 0xc0, 0x56, 0x39, 0xd9, 0x26, 0xa7,
0x32, 0xfe, 0xcc, 0x1e, 0x63, 0x52, 0x29, 0x8f, 0xfb, 0x8e, 0xcf, 0x02, 0x70, 0xa5, 0x15, 0xc3,
0x05, 0x31, 0xcc, 0x21, 0xdc, 0x85, 0x7d, 0xac, 0x41, 0x9d, 0x6f, 0x41, 0xec, 0xa7, 0xcb, 0xa6,
0x1d, 0xa2, 0xd1, 0x86, 0x68, 0x46, 0x5c, 0xa1, 0x2f, 0x42, 0x51, 0x0a, 0x36, 0x3f, 0xae, 0x60,
0x25, 0xc1, 0x01, 0xdb, 0x30, 0x7e, 0xae, 0xc1, 0xc2, 0x90, 0xc8, 0x27, 0xd1, 0xe8, 0x37, 0x00,
0x89, 0x1d, 0x3a, 0x83, 0x6d, 0x47, 0xee, 0xf6, 0xbc, 0xd2, 0xb7, 0x0c, 0x0b, 0xc9, 0x3c, 0xe5,
0x0e, 0x41, 0x88, 0xf1, 0x37, 0x0d, 0xce, 0xdc, 0xc2, 0x94, 0xa3, 0xde, 0x60, 0xb6, 0x63, 0x33,
0x0c, 0x5a, 0x21, 0x26, 0xe4, 0xe4, 0xea, 0xc7, 0x8f, 0xc5, 0xfb, 0x4c, 0xb5, 0xa5, 0x49, 0xe4,
0xbf, 0x02, 0x3a, 0x5f, 0x03, 0x3b, 0x56, 0x18, 0xec, 0x11, 0xa9, 0x47, 0x55, 0x09, 0x33, 0x83,
0x3d, 0xae, 0x10, 0x34, 0xa0, 0xb6, 0x27, 0x10, 0xa4, 0x63, 0xe0, 0x10, 0x36, 0xcc, 0xef, 0x60,
0xc4, 0x18, 0x9b, 0x1c, 0x9f, 0x5c, 0x19, 0xff, 0x52, 0x83, 0x85, 0xa1, 0xad, 0x4c, 0x22, 0xdb,
0x67, 0xc5, 0xeb, 0x51, 0x6c, 0x66, 0x66, 0xed, 0x9c, 0x92, 0x26, 0xb1, 0x98, 0xc0, 0x46, 0xe7,
0xa0, 0xba, 0x63, 0xbb, 0x9e, 0x15, 0x62, 0x9b, 0x04, 0xbe, 0xdc, 0x28, 0x30, 0x90, 0xc9, 0x21,
0xc6, 0xa7, 0x1a, 0xd4, 0x59, 0x08, 0x7a, 0xc2, 0x2d, 0xde, 0x2f, 0x72, 0x50, 0xdb, 0xf0, 0x09,
0x0e, 0xe9, 0xf1, 0x8f, 0x30, 0xd0, 0x4b, 0x50, 0xe5, 0x1b, 0x23, 0x96, 0x63, 0x53, 0x5b, 0xba,
0xab, 0xc7, 0x94, 0x59, 0xe4, 0x57, 0x18, 0xde, 0xba, 0x4d, 0x6d, 0x53, 0x48, 0x87, 0xb0, 0x6f,
0xf4, 0x28, 0x54, 0xda, 0x36, 0x69, 0x5b, 0xbb, 0xb8, 0x2f, 0x9e, 0x7d, 0x35, 0xb3, 0xcc, 0x00,
0xaf, 0xe2, 0x3e, 0x41, 0x8f, 0x40, 0xd9, 0xef, 0x75, 0xc4, 0x05, 0x2b, 0x2d, 0x6b, 0xab, 0x35,
0xb3, 0xe4, 0xf7, 0x3a, 0xfc, 0x7a, 0xfd, 0x25, 0x07, 0x33, 0x77, 0x7b, 0x2c, 0x9e, 0xe1, 0x39,
0xf0, 0x9e, 0x47, 0x1f, 0x4c, 0x19, 0x2f, 0x42, 0x5e, 0xbc, 0x19, 0x18, 0xc5, 0x92, 0x92, 0xf1,
0x8d, 0x75, 0x62, 0x32, 0x24, 0x5e, 0x67, 0xea, 0x35, 0x9b, 0xf2, 0x91, 0x95, 0xe7, 0xcc, 0x56,
0x18, 0x84, 0x6b, 0x1c, 0xdb, 0x0a, 0x0e, 0xc3, 0xf8, 0x09, 0xc6, 0xb7, 0x82, 0xc3, 0x50, 0x0c,
0x1a, 0xa0, 0xdb, 0xcd, 0x5d, 0x3f, 0xd8, 0xf3, 0xb0, 0xd3, 0xc2, 0x0e, 0x3f, 0xf6, 0xb2, 0x99,
0x82, 0x09, 0xc5, 0x60, 0x07, 0x6f, 0x35, 0x7d, 0xca, 0x03, 0x89, 0x3c, 0x53, 0x0c, 0x06, 0xb9,
0xe9, 0x53, 0x36, 0xec, 0x60, 0x0f, 0x53, 0xcc, 0x87, 0x4b, 0x62, 0x58, 0x40, 0xe4, 0x70, 0xaf,
0x1b, 0x53, 0x97, 0xc5, 0xb0, 0x80, 0xb0, 0xe1, 0x33, 0x50, 0x19, 0x24, 0xb9, 0x2b, 0x83, 0x6c,
0xa0, 0x48, 0x6d, 0xdf, 0x83, 0xfa, 0xa6, 0x67, 0x37, 0x71, 0x3b, 0xf0, 0x1c, 0x1c, 0x72, 0xef,
0x87, 0xea, 0x90, 0xa7, 0x76, 0x4b, 0xba, 0x57, 0xf6, 0x89, 0x9e, 0x97, 0x31, 0x8e, 0xb8, 0xb8,
0xff, 0xa7, 0xf4, 0x43, 0x89, 0x69, 0x12, 0xa9, 0xc3, 0x45, 0x28, 0xf2, 0xd2, 0x8c, 0x70, 0xbc,
0xba, 0x29, 0xff, 0x8c, 0x77, 0x53, 0xeb, 0xde, 0x0a, 0x83, 0x5e, 0x17, 0x6d, 0x80, 0xde, 0x1d,
0xc0, 0xd8, 0x69, 0x66, 0x7b, 0xbd, 0x61, 0xa6, 0xcd, 0x14, 0xa9, 0xf1, 0x59, 0x1e, 0x6a, 0x5b,
0xd8, 0x0e, 0x9b, 0xed, 0x93, 0x90, 0x6c, 0x60, 0x12, 0x77, 0x88, 0x27, 0x4d, 0x02, 0xfb, 0x44,
0x97, 0xe0, 0x54, 0x62, 0x43, 0x56, 0x8b, 0x09, 0x88, 0x6b, 0x86, 0x6e, 0xd6, 0xbb, 0xc3, 0x82,
0x7b, 0x0e, 0xca, 0x0e, 0xf1, 0x2c, 0x7e, 0x44, 0x25, 0x7e, 0x44, 0xea, 0xfd, 0xad, 0x13, 0x8f,
0x1f, 0x4d, 0xc9, 0x11, 0x1f, 0xe8, 0x71, 0xa8, 0x05, 0x3d, 0xda, 0xed, 0x51, 0x4b, 0xdc, 0xcc,
0xa5, 0x32, 0x67, 0x4f, 0x17, 0x40, 0x7e, 0x71, 0x09, 0x7a, 0x05, 0x6a, 0x84, 0x8b, 0x32, 0x7a,
0x9b, 0x56, 0xc6, 0x7d, 0x42, 0xe9, 0x82, 0x4e, 0x3c, 0x4e, 0xd1, 0x05, 0xa8, 0xd3, 0xd0, 0xbe,
0x87, 0xbd, 0x44, 0xd1, 0x05, 0xb8, 0x3e, 0xce, 0x0a, 0xf8, 0xa0, 0x48, 0x73, 0x05, 0xe6, 0x5a,
0x3d, 0x3b, 0xb4, 0x7d, 0x8a, 0x71, 0x02, 0xbb, 0xca, 0xb1, 0x51, 0x3c, 0x34, 0xa8, 0xd0, 0xbc,
0x0a, 0xd3, 0xb7, 0x5d, 0xca, 0x05, 0xc9, 0x6e, 0xb5, 0xc6, 0x23, 0x01, 0x7e, 0x77, 0x1f, 0x81,
0x72, 0x18, 0xec, 0x09, 0x2b, 0x95, 0xe3, 0x2a, 0x58, 0x0a, 0x83, 0x3d, 0x6e, 0x82, 0x78, 0x59,
0x39, 0x08, 0xa5, 0x6e, 0xe6, 0x4c, 0xf9, 0x67, 0x7c, 0x5b, 0x1b, 0x28, 0x0f, 0x33, 0x30, 0xe4,
0xc1, 0x2c, 0xcc, 0x4b, 0x50, 0x0a, 0x05, 0xfd, 0xc8, 0x22, 0x5b, 0x72, 0x25, 0x6e, 0x25, 0x23,
0x2a, 0xe3, 0x5b, 0x1a, 0xe8, 0xaf, 0x78, 0x3d, 0xf2, 0x30, 0x74, 0x58, 0x95, 0x56, 0xcf, 0xab,
0x53, 0xfa, 0x3f, 0xc8, 0x41, 0x4d, 0xb2, 0x31, 0x89, 0xf7, 0xcf, 0x64, 0x65, 0x0b, 0xaa, 0x6c,
0x49, 0x8b, 0xe0, 0x56, 0x94, 0x93, 0xa8, 0xae, 0xad, 0x29, 0x6f, 0x7d, 0x8a, 0x0d, 0x5e, 0x9e,
0xdc, 0xe2, 0x44, 0x5f, 0xf5, 0x69, 0xd8, 0x37, 0xa1, 0x19, 0x03, 0x1a, 0xef, 0xc2, 0xec, 0xd0,
0x30, 0xd3, 0x8d, 0x5d, 0xdc, 0x8f, 0xcc, 0xda, 0x2e, 0xee, 0xa3, 0x67, 0x92, 0x45, 0xe4, 0x2c,
0xf7, 0x75, 0x27, 0xf0, 0x5b, 0xd7, 0xc3, 0xd0, 0xee, 0xcb, 0x22, 0xf3, 0x0b, 0xb9, 0xe7, 0x35,
0xe3, 0x4f, 0x39, 0xd0, 0x5f, 0xef, 0xe1, 0xb0, 0x7f, 0x94, 0xe6, 0x05, 0xc1, 0x34, 0xbe, 0xdf,
0x0d, 0xa5, 0x83, 0xe6, 0xdf, 0xfb, 0x6f, 0x74, 0x41, 0x71, 0xa3, 0x15, 0x76, 0xa9, 0xa8, 0xb4,
0x4b, 0xaa, 0x2b, 0x5b, 0x3a, 0xd4, 0x95, 0x2d, 0x67, 0x5e, 0x59, 0xa6, 0xdd, 0x52, 0x84, 0x13,
0x5d, 0xb2, 0xd4, 0x3b, 0x24, 0x77, 0xd8, 0x77, 0x88, 0xf1, 0x89, 0x06, 0x95, 0xb7, 0x70, 0x93,
0x06, 0x21, 0xb3, 0x16, 0x0a, 0xd9, 0x6b, 0x63, 0x3c, 0xf5, 0x72, 0xc3, 0x4f, 0xbd, 0x6b, 0x50,
0x76, 0x1d, 0xcb, 0x66, 0x6a, 0xc3, 0x0f, 0x6f, 0xd4, 0x13, 0xa3, 0xe4, 0x3a, 0x5c, 0xbf, 0xc6,
0xcf, 0x4d, 0xff, 0x44, 0x03, 0x5d, 0xf0, 0x4c, 0x04, 0xe5, 0x8b, 0x89, 0xe5, 0x34, 0x95, 0x2e,
0xcb, 0x9f, 0x78, 0xa3, 0xb7, 0xa7, 0x06, 0xcb, 0x5e, 0x07, 0x60, 0xb2, 0x93, 0xe4, 0xe2, 0x2a,
0x2c, 0x2b, 0xb9, 0x15, 0xe4, 0x5c, 0x8e, 0xb7, 0xa7, 0xcc, 0x0a, 0xa3, 0xe2, 0x53, 0xdc, 0x28,
0x41, 0x81, 0x53, 0x1b, 0xff, 0xd6, 0x60, 0xee, 0xa6, 0xed, 0x35, 0xd7, 0x5d, 0x42, 0x6d, 0xbf,
0x39, 0x41, 0xec, 0xf3, 0x02, 0x94, 0x82, 0xae, 0xe5, 0xe1, 0x1d, 0x2a, 0x59, 0x5a, 0x19, 0xb1,
0x23, 0x21, 0x06, 0xb3, 0x18, 0x74, 0xef, 0xe0, 0x1d, 0x8a, 0xbe, 0x04, 0xe5, 0xa0, 0x6b, 0x85,
0x6e, 0xab, 0x4d, 0xa5, 0xf4, 0xc7, 0x20, 0x2e, 0x05, 0x5d, 0x93, 0x51, 0x24, 0x72, 0x05, 0xd3,
0x87, 0xcc, 0x15, 0x18, 0x7f, 0xdf, 0xb7, 0xfd, 0x09, 0x54, 0xfb, 0x05, 0x28, 0xbb, 0x3e, 0xb5,
0x1c, 0x97, 0x44, 0x22, 0x38, 0xab, 0xd6, 0x21, 0x9f, 0xf2, 0x1d, 0xf0, 0x33, 0xf5, 0x29, 0x5b,
0x1b, 0xbd, 0x0c, 0xb0, 0xe3, 0x05, 0xb6, 0xa4, 0x16, 0x32, 0x38, 0xa7, 0xbe, 0x15, 0x0c, 0x2d,
0xa2, 0xaf, 0x70, 0x22, 0x36, 0xc3, 0xe0, 0x48, 0xff, 0xaa, 0xc1, 0xc2, 0x26, 0x0e, 0x89, 0x4b,
0x28, 0xf6, 0xa9, 0xcc, 0xdb, 0x6d, 0xf8, 0x3b, 0x41, 0x3a, 0x41, 0xaa, 0x0d, 0x25, 0x48, 0x3f,
0x9f, 0x74, 0x61, 0x2a, 0x12, 0x10, 0x69, 0xfa, 0x28, 0x12, 0x88, 0x8a, 0x11, 0x22, 0x92, 0x9a,
0xc9, 0x38, 0x26, 0xc9, 0x6f, 0x32, 0xa0, 0x34, 0x7e, 0x28, 0x1a, 0x03, 0x94, 0x9b, 0x7a, 0x70,
0x85, 0x5d, 0x04, 0x69, 0xc0, 0x87, 0xcc, 0xf9, 0xff, 0xc3, 0x90, 0xed, 0xc8, 0x68, 0x57, 0xf8,
0xa9, 0x06, 0xcb, 0xd9, 0x5c, 0x4d, 0xe2, 0x79, 0x5f, 0x86, 0x82, 0xeb, 0xef, 0x04, 0x51, 0x1a,
0xe9, 0xa2, 0xfa, 0x41, 0xad, 0x5c, 0x57, 0x10, 0x1a, 0xff, 0xd2, 0xa0, 0xce, 0x6d, 0xf5, 0x11,
0x1c, 0x7f, 0x07, 0x77, 0x2c, 0xe2, 0xbe, 0x87, 0xa3, 0xe3, 0xef, 0xe0, 0xce, 0x96, 0xfb, 0x1e,
0x4e, 0x69, 0x46, 0x21, 0xad, 0x19, 0xe9, 0x40, 0xbb, 0x38, 0x22, 0x4d, 0x58, 0x4a, 0xa5, 0x09,
0x8d, 0x0f, 0x35, 0x68, 0xdc, 0xc2, 0x74, 0x78, 0xab, 0x47, 0xa7, 0x14, 0x1f, 0x69, 0xf0, 0xa8,
0x92, 0xa1, 0x49, 0xf4, 0xe1, 0xc5, 0xb4, 0x3e, 0xa8, 0x03, 0xac, 0x7d, 0x4b, 0x4a, 0x55, 0xb8,
0x0a, 0xfa, 0x7a, 0xaf, 0xd3, 0x89, 0x1f, 0x3e, 0x2b, 0xa0, 0x87, 0xe2, 0x53, 0xc4, 0x1f, 0xc2,
0x5d, 0x56, 0x25, 0x8c, 0x45, 0x19, 0xc6, 0x25, 0xa8, 0x49, 0x12, 0xc9, 0x75, 0x03, 0xca, 0xa1,
0xfc, 0x96, 0xf8, 0xf1, 0xbf, 0xb1, 0x00, 0x73, 0x26, 0x6e, 0x31, 0x4d, 0x0c, 0xef, 0xb8, 0xfe,
0xae, 0x5c, 0xc6, 0x78, 0x5f, 0x83, 0xf9, 0x34, 0x5c, 0xce, 0xf5, 0x05, 0x28, 0xd9, 0x8e, 0x13,
0x62, 0x42, 0x46, 0x1e, 0xcb, 0x75, 0x81, 0x63, 0x46, 0xc8, 0x09, 0xc9, 0xe5, 0xc6, 0x96, 0xdc,
0xc5, 0x15, 0x28, 0x47, 0xa5, 0x3c, 0x54, 0x82, 0xfc, 0x75, 0xcf, 0xab, 0x4f, 0x21, 0x1d, 0xca,
0x1b, 0xb2, 0x5e, 0x55, 0xd7, 0x2e, 0x7e, 0x05, 0x66, 0x87, 0x22, 0x61, 0x54, 0x86, 0xe9, 0xd7,
0x02, 0x1f, 0xd7, 0xa7, 0x50, 0x1d, 0xf4, 0x1b, 0xae, 0x6f, 0x87, 0x7d, 0xe1, 0x79, 0xea, 0x0e,
0x9a, 0x85, 0x2a, 0xb7, 0xc0, 0x12, 0x80, 0xd7, 0x7e, 0x76, 0x1a, 0x6a, 0x77, 0x39, 0x27, 0x5b,
0x38, 0xbc, 0xe7, 0x36, 0x31, 0xb2, 0xa0, 0x3e, 0xdc, 0x8c, 0x8b, 0x9e, 0x54, 0x9e, 0x59, 0x46,
0xcf, 0x6e, 0x63, 0xd4, 0xde, 0x8c, 0x29, 0xf4, 0x0e, 0xcc, 0xa4, 0xdb, 0x64, 0x91, 0xda, 0x44,
0x28, 0x7b, 0x69, 0x0f, 0x9a, 0xdc, 0x82, 0x5a, 0xaa, 0xeb, 0x15, 0x5d, 0x50, 0xce, 0xad, 0xea,
0x8c, 0x6d, 0xa8, 0xbd, 0x76, 0xb2, 0x33, 0x55, 0x70, 0x9f, 0xee, 0xcd, 0xcb, 0xe0, 0x5e, 0xd9,
0xc0, 0x77, 0x10, 0xf7, 0x36, 0x9c, 0xda, 0xd7, 0x6a, 0x87, 0x9e, 0x52, 0xce, 0x9f, 0xd5, 0x92,
0x77, 0xd0, 0x12, 0x7b, 0x80, 0xf6, 0x77, 0x77, 0xa2, 0xcb, 0xea, 0x13, 0xc8, 0xea, 0x6d, 0x6d,
0x5c, 0x19, 0x1b, 0x3f, 0x16, 0xdc, 0x77, 0x34, 0x38, 0x9d, 0xd1, 0x1f, 0x87, 0xae, 0x29, 0xa7,
0x1b, 0xdd, 0xe4, 0xd7, 0x78, 0xe6, 0x70, 0x44, 0x31, 0x23, 0x3e, 0xcc, 0x0e, 0xb5, 0x8c, 0xa1,
0x4b, 0x99, 0x65, 0xf4, 0xfd, 0xbd, 0x73, 0x8d, 0x27, 0xc7, 0x43, 0x8e, 0xd7, 0x63, 0xb1, 0x61,
0xba, 0xcf, 0x2a, 0x63, 0x3d, 0x75, 0x37, 0xd6, 0x41, 0x07, 0xfa, 0x36, 0xd4, 0x52, 0x0d, 0x51,
0x19, 0x1a, 0xaf, 0x6a, 0x9a, 0x3a, 0x68, 0xea, 0x77, 0x41, 0x4f, 0xf6, 0x2d, 0xa1, 0xd5, 0xac,
0xbb, 0xb4, 0x6f, 0xe2, 0xc3, 0x5c, 0xa5, 0x41, 0x5b, 0xc2, 0x88, 0xab, 0xb4, 0xaf, 0x93, 0x63,
0xfc, 0xab, 0x94, 0x98, 0x7f, 0xe4, 0x55, 0x3a, 0xf4, 0x12, 0xef, 0x6b, 0xb0, 0xa8, 0x6e, 0x7b,
0x41, 0x6b, 0x59, 0xba, 0x99, 0xdd, 0xe0, 0xd3, 0xb8, 0x76, 0x28, 0x9a, 0x58, 0x8a, 0xbb, 0x30,
0x93, 0x6e, 0xee, 0xc8, 0x90, 0xa2, 0xb2, 0x1f, 0xa6, 0x71, 0x69, 0x2c, 0xdc, 0x78, 0xb1, 0x37,
0xa1, 0x9a, 0x28, 0x70, 0xa3, 0x27, 0x46, 0xe8, 0x71, 0xb2, 0x3c, 0x72, 0x90, 0x24, 0xdb, 0x50,
0x4b, 0x15, 0x35, 0xb3, 0x74, 0x58, 0x51, 0x6b, 0x6e, 0x5c, 0x1c, 0x07, 0x35, 0xde, 0x40, 0x1b,
0x6a, 0xa9, 0x12, 0x53, 0xc6, 0x4a, 0xaa, 0x8a, 0x5a, 0xc6, 0x4a, 0xca, 0x8a, 0x95, 0x31, 0x85,
0xbe, 0x99, 0xa8, 0x66, 0xa5, 0x2a, 0x86, 0xe8, 0xea, 0xc8, 0x79, 0x54, 0x05, 0xd3, 0xc6, 0xda,
0x61, 0x48, 0x62, 0x16, 0x5e, 0x87, 0x4a, 0x5c, 0xa8, 0x42, 0xe7, 0x33, 0xcd, 0xc2, 0x61, 0x4e,
0x6a, 0x0b, 0x8a, 0xa2, 0x68, 0x84, 0x8c, 0x8c, 0xf2, 0x70, 0xa2, 0xa2, 0xd4, 0x78, 0x5c, 0x89,
0x93, 0xae, 0xa7, 0x18, 0x53, 0xc8, 0x84, 0xa2, 0x48, 0x4b, 0x66, 0x4c, 0x9a, 0x4a, 0xad, 0x37,
0x46, 0xe3, 0x88, 0x5c, 0xe6, 0x14, 0xda, 0x84, 0x02, 0x4f, 0xdf, 0xa1, 0x95, 0x51, 0xa9, 0xbd,
0x51, 0x33, 0xa6, 0xb2, 0x7f, 0xc6, 0x14, 0xfa, 0x1a, 0x14, 0xf8, 0x2b, 0x35, 0x63, 0xc6, 0x64,
0x7e, 0xae, 0x31, 0x12, 0x25, 0x62, 0xd1, 0x01, 0x3d, 0x19, 0xbd, 0x67, 0x98, 0x57, 0x45, 0x7e,
0xa3, 0x31, 0x0e, 0x66, 0xb4, 0xca, 0x77, 0x35, 0x58, 0xca, 0x0a, 0xf4, 0x50, 0xa6, 0x0f, 0x1d,
0x15, 0xad, 0x36, 0x9e, 0x3d, 0x24, 0x55, 0x2c, 0xc2, 0xf7, 0x60, 0x4e, 0x11, 0x5e, 0xa0, 0x2b,
0x59, 0xf3, 0x65, 0x44, 0x46, 0x8d, 0xa7, 0xc7, 0x27, 0x88, 0xd7, 0xde, 0x84, 0x02, 0x0f, 0x0b,
0x32, 0x8e, 0x2f, 0x19, 0x65, 0x64, 0x28, 0x44, 0x2a, 0xaa, 0x30, 0xa6, 0x10, 0x06, 0x3d, 0x19,
0x23, 0x64, 0x9c, 0x9f, 0x22, 0xbc, 0x68, 0x5c, 0x18, 0x03, 0x33, 0x5a, 0x66, 0xad, 0x07, 0xfa,
0x66, 0x18, 0xdc, 0xef, 0x47, 0x0f, 0xf4, 0xff, 0xcd, 0xb2, 0x37, 0x9e, 0xfd, 0xfa, 0xb5, 0x96,
0x4b, 0xdb, 0xbd, 0x6d, 0x66, 0x03, 0xae, 0x08, 0xdc, 0xa7, 0xdc, 0x40, 0x7e, 0x5d, 0x71, 0x7d,
0x8a, 0x43, 0xdf, 0xf6, 0xae, 0xf0, 0xb9, 0x24, 0xb4, 0xbb, 0xbd, 0x5d, 0xe4, 0xff, 0xd7, 0xfe,
0x1b, 0x00, 0x00, 0xff, 0xff, 0x1a, 0xa4, 0x5f, 0x7a, 0x14, 0x38, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -4263,7 +4123,6 @@ type MilvusServiceClient interface {
DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
Insert(ctx context.Context, in *InsertRequest, opts ...grpc.CallOption) (*MutationResult, error)
Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResults, error)
Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error)
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResults, error)
CalcDistance(ctx context.Context, in *CalcDistanceRequest, opts ...grpc.CallOption) (*CalcDistanceResults, error)
@ -4480,15 +4339,6 @@ func (c *milvusServiceClient) Search(ctx context.Context, in *SearchRequest, opt
return out, nil
}
func (c *milvusServiceClient) Retrieve(ctx context.Context, in *RetrieveRequest, opts ...grpc.CallOption) (*RetrieveResults, error) {
out := new(RetrieveResults)
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/Retrieve", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *milvusServiceClient) Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error) {
out := new(FlushResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/Flush", in, out, opts...)
@ -4576,7 +4426,6 @@ type MilvusServiceServer interface {
DropIndex(context.Context, *DropIndexRequest) (*commonpb.Status, error)
Insert(context.Context, *InsertRequest) (*MutationResult, error)
Search(context.Context, *SearchRequest) (*SearchResults, error)
Retrieve(context.Context, *RetrieveRequest) (*RetrieveResults, error)
Flush(context.Context, *FlushRequest) (*FlushResponse, error)
Query(context.Context, *QueryRequest) (*QueryResults, error)
CalcDistance(context.Context, *CalcDistanceRequest) (*CalcDistanceResults, error)
@ -4657,9 +4506,6 @@ func (*UnimplementedMilvusServiceServer) Insert(ctx context.Context, req *Insert
func (*UnimplementedMilvusServiceServer) Search(ctx context.Context, req *SearchRequest) (*SearchResults, error) {
return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
}
func (*UnimplementedMilvusServiceServer) Retrieve(ctx context.Context, req *RetrieveRequest) (*RetrieveResults, error) {
return nil, status.Errorf(codes.Unimplemented, "method Retrieve not implemented")
}
func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRequest) (*FlushResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
}
@ -5082,24 +4928,6 @@ func _MilvusService_Search_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _MilvusService_Retrieve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RetrieveRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MilvusServiceServer).Retrieve(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.milvus.MilvusService/Retrieve",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MilvusServiceServer).Retrieve(ctx, req.(*RetrieveRequest))
}
return interceptor(ctx, in, info, handler)
}
func _MilvusService_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FlushRequest)
if err := dec(in); err != nil {
@ -5318,10 +5146,6 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
MethodName: "Search",
Handler: _MilvusService_Search_Handler,
},
{
MethodName: "Retrieve",
Handler: _MilvusService_Retrieve_Handler,
},
{
MethodName: "Flush",
Handler: _MilvusService_Flush_Handler,

8
internal/proxy/dummyreq.go
View File

@ -27,17 +27,17 @@ func parseDummyRequestType(str string) (*dummyRequestType, error) {
return drt, nil
}
type dummyRetrieveRequest struct {
type dummyQueryRequest struct {
RequestType string `json:"request_type"`
DbName string `json:"dbname"`
CollectionName string `json:"collection_name"`
PartitionNames []string `json:"partition_names"`
Ids []int64 `json:"ids"`
Expr string `json:"expr"`
OutputFields []string `json:"output_fields"`
}
func parseDummyRetrieveRequest(str string) (*dummyRetrieveRequest, error) {
dr := &dummyRetrieveRequest{}
func parseDummyQueryRequest(str string) (*dummyQueryRequest, error) {
dr := &dummyQueryRequest{}
if err := json.Unmarshal([]byte(str), &dr); err != nil {
return nil, err

69
internal/proxy/dummyreq_test.go
View File

@ -11,49 +11,30 @@
package proxy
import (
"testing"
// func TestParseDummyQueryRequest(t *testing.T) {
// invalidStr := `{"request_type":"query"`
// _, err := parseDummyQueryRequest(invalidStr)
// assert.NotNil(t, err)
"github.com/stretchr/testify/assert"
)
// onlytypeStr := `{"request_type":"query"}`
// drr, err := parseDummyQueryRequest(onlytypeStr)
// assert.Nil(t, err)
// assert.Equal(t, drr.RequestType, "query")
// assert.Equal(t, len(drr.DbName), 0)
func TestParseDummyRequestType(t *testing.T) {
invalidStr := `{"request_type":"retrieve"`
_, err := parseDummyRequestType(invalidStr)
assert.NotNil(t, err)
retrievetypeStr := `{"request_type":"retrieve"}`
drt, err := parseDummyRequestType(retrievetypeStr)
assert.Nil(t, err)
assert.Equal(t, drt.RequestType, "retrieve")
}
func TestParseDummyRetrieveRequest(t *testing.T) {
invalidStr := `{"request_type":"retrieve"`
_, err := parseDummyRetrieveRequest(invalidStr)
assert.NotNil(t, err)
onlytypeStr := `{"request_type":"retrieve"}`
drr, err := parseDummyRetrieveRequest(onlytypeStr)
assert.Nil(t, err)
assert.Equal(t, drr.RequestType, "retrieve")
assert.Equal(t, len(drr.DbName), 0)
fulltypeStr := `{
"request_type":"retrieve",
"dbname":"",
"collection_name":"test",
"partition_names": [],
"ids": [100, 101],
"output_fields": ["_id", "age"]
}`
drr2, err := parseDummyRetrieveRequest(fulltypeStr)
assert.Nil(t, err)
assert.Equal(t, drr2.RequestType, "retrieve")
assert.Equal(t, len(drr2.DbName), 0)
assert.Equal(t, drr2.CollectionName, "test")
assert.Equal(t, len(drr2.PartitionNames), 0)
assert.Equal(t, len(drr2.Ids), 2)
assert.Equal(t, drr2.Ids, []int64{100, 101})
assert.Equal(t, drr2.OutputFields, []string{"_id", "age"})
}
// fulltypeStr := `{
// "request_type":"query",
// "dbname":"",
// "collection_name":"test",
// "partition_names": [],
// "expr": "_id in [ 100 ,101 ]",
// "output_fields": ["_id", "age"]
// }`
// drr2, err := parseDummyQueryRequest(fulltypeStr)
// assert.Nil(t, err)
// assert.Equal(t, drr2.RequestType, "retrieve")
// assert.Equal(t, len(drr2.DbName), 0)
// assert.Equal(t, drr2.CollectionName, "test")
// assert.Equal(t, len(drr2.PartitionNames), 0)
// assert.Equal(t, drr2.OutputFields, []string{"_id", "age"})
// }

320
internal/proxy/impl.go
View File

@ -26,7 +26,6 @@ import (
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/planpb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
@ -1319,75 +1318,6 @@ func (node *Proxy) Search(ctx context.Context, request *milvuspb.SearchRequest)
return qt.result, nil
}
func (node *Proxy) Retrieve(ctx context.Context, request *milvuspb.RetrieveRequest) (*milvuspb.RetrieveResults, error) {
if !node.checkHealthy() {
return &milvuspb.RetrieveResults{
Status: unhealthyStatus(),
}, nil
}
rt := &RetrieveTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
RetrieveRequest: &internalpb.RetrieveRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Retrieve,
SourceID: Params.ProxyID,
},
ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
},
resultBuf: make(chan []*internalpb.RetrieveResults),
retrieve: request,
chMgr: node.chMgr,
qc: node.queryCoord,
}
err := node.sched.DqQueue.Enqueue(rt)
if err != nil {
return &milvuspb.RetrieveResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
log.Debug("Retrieve",
zap.String("role", Params.RoleName),
zap.Int64("msgID", rt.Base.MsgID),
zap.Uint64("timestamp", rt.Base.Timestamp),
zap.String("db", request.DbName),
zap.String("collection", request.CollectionName),
zap.Any("partitions", request.PartitionNames),
zap.Any("len(Ids)", len(request.Ids.IdField.(*schemapb.IDs_IntId).IntId.Data)))
defer func() {
idsCount := 0
if rt.result != nil {
idsCount = len(rt.result.Ids.IdField.(*schemapb.IDs_IntId).IntId.Data)
}
log.Debug("Retrieve Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", rt.Base.MsgID),
zap.Uint64("timestamp", rt.Base.Timestamp),
zap.String("db", request.DbName),
zap.String("collection", request.CollectionName),
zap.Any("partitions", request.PartitionNames),
zap.Any("len(Ids)", idsCount))
}()
err = rt.WaitToFinish()
if err != nil {
return &milvuspb.RetrieveResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
return rt.result, nil
}
func (node *Proxy) Flush(ctx context.Context, request *milvuspb.FlushRequest) (*milvuspb.FlushResponse, error) {
resp := &milvuspb.FlushResponse{
Status: &commonpb.Status{
@ -1443,133 +1373,72 @@ func (node *Proxy) Query(ctx context.Context, request *milvuspb.QueryRequest) (*
Status: unhealthyStatus(),
}, nil
}
schemaPb, err := globalMetaCache.GetCollectionSchema(ctx, request.CollectionName)
if err != nil { // err is not nil if collection not exists
return nil, err
queryRequest := &milvuspb.QueryRequest{
DbName: request.DbName,
CollectionName: request.CollectionName,
PartitionNames: request.PartitionNames,
Expr: request.Expr,
OutputFields: request.OutputFields,
}
schema, err := typeutil.CreateSchemaHelper(schemaPb)
qt := &QueryTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
RetrieveRequest: &internalpb.RetrieveRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Retrieve,
SourceID: Params.ProxyID,
},
ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
},
resultBuf: make(chan []*internalpb.RetrieveResults),
query: queryRequest,
chMgr: node.chMgr,
qc: node.queryCoord,
}
err := node.sched.DqQueue.Enqueue(qt)
if err != nil {
return nil, err
}
if request.Expr == "" {
errMsg := "Query expression is empty!"
return nil, fmt.Errorf(errMsg)
}
parseRetrieveTask := func(exprString string) ([]int64, error) {
expr, err := parseQueryExpr(schema, exprString)
if err != nil {
return nil, err
}
switch xExpr := expr.Expr.(type) {
case *planpb.Expr_TermExpr:
var ids []int64
for _, value := range xExpr.TermExpr.Values {
switch v := value.Val.(type) {
case *planpb.GenericValue_Int64Val:
ids = append(ids, v.Int64Val)
default:
return nil, errors.New("column is not int64")
}
}
if !xExpr.TermExpr.ColumnInfo.IsPrimaryKey {
return nil, errors.New("column is not primary key")
}
return ids, nil
default:
return nil, errors.New("not top level term")
}
}
ids, err := parseRetrieveTask(request.Expr)
if err == nil {
retrieveRequest := &milvuspb.RetrieveRequest{
DbName: request.DbName,
CollectionName: request.CollectionName,
PartitionNames: request.PartitionNames,
Ids: &schemapb.IDs{
IdField: &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: ids,
},
},
},
OutputFields: request.OutputFields,
}
rt := &RetrieveTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
RetrieveRequest: &internalpb.RetrieveRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Retrieve,
SourceID: Params.ProxyID,
},
ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
},
resultBuf: make(chan []*internalpb.RetrieveResults),
retrieve: retrieveRequest,
chMgr: node.chMgr,
qc: node.queryCoord,
}
err := node.sched.DqQueue.Enqueue(rt)
if err != nil {
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
log.Debug("Retrieve",
zap.String("role", Params.RoleName),
zap.Int64("msgID", rt.Base.MsgID),
zap.Uint64("timestamp", rt.Base.Timestamp),
zap.String("db", retrieveRequest.DbName),
zap.String("collection", retrieveRequest.CollectionName),
zap.Any("partitions", retrieveRequest.PartitionNames),
zap.Any("len(Ids)", len(retrieveRequest.Ids.IdField.(*schemapb.IDs_IntId).IntId.Data)))
defer func() {
log.Debug("Retrieve Done",
zap.Error(err),
zap.String("role", Params.RoleName),
zap.Int64("msgID", rt.Base.MsgID),
zap.Uint64("timestamp", rt.Base.Timestamp),
zap.String("db", retrieveRequest.DbName),
zap.String("collection", retrieveRequest.CollectionName),
zap.Any("partitions", retrieveRequest.PartitionNames))
}()
err = rt.WaitToFinish()
if err != nil {
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
return &milvuspb.QueryResults{
Status: rt.result.Status,
FieldsData: rt.result.FieldsData,
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
log.Debug("Query",
zap.String("role", Params.RoleName),
zap.Int64("msgID", qt.Base.MsgID),
zap.Uint64("timestamp", qt.Base.Timestamp),
zap.String("db", queryRequest.DbName),
zap.String("collection", queryRequest.CollectionName),
zap.Any("partitions", queryRequest.PartitionNames))
defer func() {
log.Debug("Query Done",
zap.String("role", Params.RoleName),
zap.Int64("msgID", qt.Base.MsgID),
zap.Uint64("timestamp", qt.Base.Timestamp),
zap.String("db", queryRequest.DbName),
zap.String("collection", queryRequest.CollectionName),
zap.Any("partitions", queryRequest.PartitionNames))
}()
err = qt.WaitToFinish()
if err != nil {
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
Status: qt.result.Status,
FieldsData: qt.result.FieldsData,
}, nil
}
func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDistanceRequest) (*milvuspb.CalcDistanceResults, error) {
@ -1584,17 +1453,57 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
}, nil
}
retrieveTask := func(ids *milvuspb.VectorIDs) (*milvuspb.RetrieveResults, error) {
query := func(ids *milvuspb.VectorIDs) (*milvuspb.QueryResults, error) {
outputFields := []string{ids.FieldName}
retrieveRequest := &milvuspb.RetrieveRequest{
queryRequest := &milvuspb.QueryRequest{
DbName: "",
CollectionName: ids.CollectionName,
PartitionNames: ids.PartitionNames,
Ids: ids.IdArray,
OutputFields: outputFields,
}
return node.Retrieve(ctx, retrieveRequest)
qt := &QueryTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
RetrieveRequest: &internalpb.RetrieveRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Retrieve,
SourceID: Params.ProxyID,
},
Ids: ids.IdArray,
ResultChannelID: strconv.FormatInt(Params.ProxyID, 10),
},
resultBuf: make(chan []*internalpb.RetrieveResults),
query: queryRequest,
chMgr: node.chMgr,
qc: node.queryCoord,
}
err := node.sched.DqQueue.Enqueue(qt)
if err != nil {
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
err = qt.WaitToFinish()
if err != nil {
return &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
return &milvuspb.QueryResults{
Status: qt.result.Status,
FieldsData: qt.result.FieldsData,
}, nil
}
// the vectors retrieved are random order, we need re-arrange the vectors by the order of input ids
@ -1674,7 +1583,7 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
vectorsLeft := request.GetOpLeft().GetDataArray()
opLeft := request.GetOpLeft().GetIdArray()
if opLeft != nil {
result, err := retrieveTask(opLeft)
result, err := query(opLeft)
if err != nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{
@ -1707,7 +1616,7 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
vectorsRight := request.GetOpRight().GetDataArray()
opRight := request.GetOpRight().GetIdArray()
if opRight != nil {
result, err := retrieveTask(opRight)
result, err := query(opRight)
if err != nil {
return &milvuspb.CalcDistanceResults{
Status: &commonpb.Status{
@ -2010,30 +1919,23 @@ func (node *Proxy) Dummy(ctx context.Context, req *milvuspb.DummyRequest) (*milv
return failedResponse, nil
}
if drt.RequestType == "retrieve" {
drr, err := parseDummyRetrieveRequest(req.RequestType)
if drt.RequestType == "query" {
drr, err := parseDummyQueryRequest(req.RequestType)
if err != nil {
log.Debug("Failed to parse dummy retrieve request")
log.Debug("Failed to parse dummy query request")
return failedResponse, nil
}
request := &milvuspb.RetrieveRequest{
request := &milvuspb.QueryRequest{
DbName: drr.DbName,
CollectionName: drr.CollectionName,
PartitionNames: drr.PartitionNames,
Ids: &schemapb.IDs{
IdField: &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: drr.Ids,
},
},
},
OutputFields: drr.OutputFields,
OutputFields: drr.OutputFields,
}
_, err = node.Retrieve(ctx, request)
_, err = node.Query(ctx, request)
if err != nil {
log.Debug("Failed to execute dummy retrieve")
log.Debug("Failed to execute dummy query")
return failedResponse, err
}

330
internal/proxy/task.go
View File

@ -53,6 +53,7 @@ const (
DropCollectionTaskName = "DropCollectionTask"
SearchTaskName = "SearchTask"
RetrieveTaskName = "RetrieveTask"
QueryTaskName = "QueryTask"
AnnsFieldKey = "anns_field"
TopKKey = "topk"
MetricTypeKey = "metric_type"
@ -1990,118 +1991,146 @@ func (st *SearchTask) PostExecute(ctx context.Context) error {
}
}
type RetrieveTask struct {
type QueryTask struct {
Condition
*internalpb.RetrieveRequest
ctx context.Context
resultBuf chan []*internalpb.RetrieveResults
result *milvuspb.RetrieveResults
retrieve *milvuspb.RetrieveRequest
result *milvuspb.QueryResults
query *milvuspb.QueryRequest
chMgr channelsMgr
qc types.QueryCoord
}
func (rt *RetrieveTask) TraceCtx() context.Context {
return rt.ctx
func (qt *QueryTask) TraceCtx() context.Context {
return qt.ctx
}
func (rt *RetrieveTask) ID() UniqueID {
return rt.Base.MsgID
func (qt *QueryTask) ID() UniqueID {
return qt.Base.MsgID
}
func (rt *RetrieveTask) SetID(uid UniqueID) {
rt.Base.MsgID = uid
func (qt *QueryTask) SetID(uid UniqueID) {
qt.Base.MsgID = uid
}
func (rt *RetrieveTask) Name() string {
func (qt *QueryTask) Name() string {
return RetrieveTaskName
}
func (rt *RetrieveTask) Type() commonpb.MsgType {
return rt.Base.MsgType
func (qt *QueryTask) Type() commonpb.MsgType {
return qt.Base.MsgType
}
func (rt *RetrieveTask) BeginTs() Timestamp {
return rt.Base.Timestamp
func (qt *QueryTask) BeginTs() Timestamp {
return qt.Base.Timestamp
}
func (rt *RetrieveTask) EndTs() Timestamp {
return rt.Base.Timestamp
func (qt *QueryTask) EndTs() Timestamp {
return qt.Base.Timestamp
}
func (rt *RetrieveTask) SetTs(ts Timestamp) {
rt.Base.Timestamp = ts
func (qt *QueryTask) SetTs(ts Timestamp) {
qt.Base.Timestamp = ts
}
func (rt *RetrieveTask) OnEnqueue() error {
rt.Base.MsgType = commonpb.MsgType_Retrieve
func (qt *QueryTask) OnEnqueue() error {
qt.Base.MsgType = commonpb.MsgType_Retrieve
return nil
}
func (rt *RetrieveTask) getChannels() ([]pChan, error) {
collID, err := globalMetaCache.GetCollectionID(rt.ctx, rt.retrieve.CollectionName)
func (qt *QueryTask) getChannels() ([]pChan, error) {
collID, err := globalMetaCache.GetCollectionID(qt.ctx, qt.query.CollectionName)
if err != nil {
return nil, err
}
return rt.chMgr.getChannels(collID)
return qt.chMgr.getChannels(collID)
}
func (rt *RetrieveTask) getVChannels() ([]vChan, error) {
collID, err := globalMetaCache.GetCollectionID(rt.ctx, rt.retrieve.CollectionName)
func (qt *QueryTask) getVChannels() ([]vChan, error) {
collID, err := globalMetaCache.GetCollectionID(qt.ctx, qt.query.CollectionName)
if err != nil {
return nil, err
}
_, err = rt.chMgr.getChannels(collID)
_, err = qt.chMgr.getChannels(collID)
if err != nil {
err := rt.chMgr.createDMLMsgStream(collID)
err := qt.chMgr.createDMLMsgStream(collID)
if err != nil {
return nil, err
}
}
return rt.chMgr.getVChannels(collID)
return qt.chMgr.getVChannels(collID)
}
func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
rt.Base.MsgType = commonpb.MsgType_Retrieve
rt.Base.SourceID = Params.ProxyID
func parseIdsFromExpr(exprStr string, schema *typeutil.SchemaHelper) ([]int64, error) {
expr, err := parseQueryExpr(schema, exprStr)
if err != nil {
return nil, err
}
collectionName := rt.retrieve.CollectionName
switch xExpr := expr.Expr.(type) {
case *planpb.Expr_TermExpr:
var ids []int64
for _, value := range xExpr.TermExpr.Values {
switch v := value.Val.(type) {
case *planpb.GenericValue_Int64Val:
ids = append(ids, v.Int64Val)
default:
return nil, errors.New("column is not int64")
}
}
if !xExpr.TermExpr.ColumnInfo.IsPrimaryKey {
return nil, errors.New("column is not primary key")
}
return ids, nil
default:
return nil, errors.New("not top level term")
}
}
func (qt *QueryTask) PreExecute(ctx context.Context) error {
qt.Base.MsgType = commonpb.MsgType_Retrieve
qt.Base.SourceID = Params.ProxyID
collectionName := qt.query.CollectionName
collectionID, err := globalMetaCache.GetCollectionID(ctx, collectionName)
if err != nil {
log.Debug("Failed to get collection id.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return err
}
log.Info("Get collection id by name.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
if err := ValidateCollectionName(rt.retrieve.CollectionName); err != nil {
if err := ValidateCollectionName(qt.query.CollectionName); err != nil {
log.Debug("Invalid collection name.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return err
}
log.Info("Validate collection name.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
for _, tag := range rt.retrieve.PartitionNames {
for _, tag := range qt.query.PartitionNames {
if err := ValidatePartitionTag(tag, false); err != nil {
log.Debug("Invalid partition name.", zap.Any("partitionName", tag),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return err
}
}
log.Info("Validate partition names.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
// check if collection was already loaded into query node
showResp, err := rt.qc.ShowCollections(rt.ctx, &querypb.ShowCollectionsRequest{
showResp, err := qt.qc.ShowCollections(qt.ctx, &querypb.ShowCollectionsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_ShowCollections,
MsgID: rt.Base.MsgID,
Timestamp: rt.Base.Timestamp,
MsgID: qt.Base.MsgID,
Timestamp: qt.Base.Timestamp,
SourceID: Params.ProxyID,
},
DbID: 0, // TODO(dragondriver)
@ -2127,32 +2156,50 @@ func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
return fmt.Errorf("collection %v was not loaded into memory", collectionName)
}
schema, err := globalMetaCache.GetCollectionSchema(ctx, qt.query.CollectionName)
if err != nil { // err is not nil if collection not exists
return err
}
schemaHelper, err := typeutil.CreateSchemaHelper(schema)
if err != nil {
return err
}
// TODO(dragondriver): necessary to check if partition was loaded into query node?
rt.Base.MsgType = commonpb.MsgType_Retrieve
if rt.retrieve.Ids == nil {
errMsg := "Retrieve ids is nil"
return errors.New(errMsg)
if qt.Ids == nil {
if qt.query.Expr == "" {
errMsg := "Query expression is empty"
return fmt.Errorf(errMsg)
}
ids, err := parseIdsFromExpr(qt.query.Expr, schemaHelper)
if err != nil {
return err
}
qt.Base.MsgType = commonpb.MsgType_Retrieve
qt.Ids = &schemapb.IDs{
IdField: &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: ids,
},
},
}
}
rt.Ids = rt.retrieve.Ids
schema, err := globalMetaCache.GetCollectionSchema(ctx, collectionName)
qt.query.OutputFields, err = translateOutputFields(qt.query.OutputFields, schema, true)
if err != nil {
return err
}
rt.retrieve.OutputFields, err = translateOutputFields(rt.retrieve.OutputFields, schema, true)
if err != nil {
return err
}
log.Debug("translate output fields", zap.Any("OutputFields", rt.retrieve.OutputFields))
if len(rt.retrieve.OutputFields) == 0 {
log.Debug("translate output fields", zap.Any("OutputFields", qt.query.OutputFields))
if len(qt.query.OutputFields) == 0 {
for _, field := range schema.Fields {
if field.FieldID >= 100 && field.DataType != schemapb.DataType_FloatVector && field.DataType != schemapb.DataType_BinaryVector {
rt.OutputFieldsId = append(rt.OutputFieldsId, field.FieldID)
qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
}
}
} else {
addPrimaryKey := false
for _, reqField := range rt.retrieve.OutputFields {
for _, reqField := range qt.query.OutputFields {
findField := false
for _, field := range schema.Fields {
if reqField == field.Name {
@ -2160,10 +2207,10 @@ func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
addPrimaryKey = true
}
findField = true
rt.OutputFieldsId = append(rt.OutputFieldsId, field.FieldID)
qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
} else {
if field.IsPrimaryKey && !addPrimaryKey {
rt.OutputFieldsId = append(rt.OutputFieldsId, field.FieldID)
qt.OutputFieldsId = append(qt.OutputFieldsId, field.FieldID)
addPrimaryKey = true
}
}
@ -2174,48 +2221,48 @@ func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
}
}
}
log.Debug("translate output fields to field ids", zap.Any("OutputFieldsID", rt.OutputFieldsId))
log.Debug("translate output fields to field ids", zap.Any("OutputFieldsID", qt.OutputFieldsId))
travelTimestamp := rt.retrieve.TravelTimestamp
travelTimestamp := qt.query.TravelTimestamp
if travelTimestamp == 0 {
travelTimestamp = rt.BeginTs()
travelTimestamp = qt.BeginTs()
}
guaranteeTimestamp := rt.retrieve.GuaranteeTimestamp
guaranteeTimestamp := qt.query.GuaranteeTimestamp
if guaranteeTimestamp == 0 {
guaranteeTimestamp = rt.BeginTs()
guaranteeTimestamp = qt.BeginTs()
}
rt.RetrieveRequest.TravelTimestamp = travelTimestamp
rt.RetrieveRequest.GuaranteeTimestamp = guaranteeTimestamp
qt.TravelTimestamp = travelTimestamp
qt.GuaranteeTimestamp = guaranteeTimestamp
rt.ResultChannelID = Params.RetrieveResultChannelNames[0]
rt.DbID = 0 // todo(yukun)
qt.ResultChannelID = Params.RetrieveResultChannelNames[0]
qt.DbID = 0 // todo(yukun)
rt.CollectionID = collectionID
rt.PartitionIDs = make([]UniqueID, 0)
qt.CollectionID = collectionID
qt.PartitionIDs = make([]UniqueID, 0)
partitionsMap, err := globalMetaCache.GetPartitions(ctx, collectionName)
if err != nil {
log.Debug("Failed to get partitions in collection.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return err
}
log.Info("Get partitions in collection.", zap.Any("collectionName", collectionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
partitionsRecord := make(map[UniqueID]bool)
for _, partitionName := range rt.retrieve.PartitionNames {
for _, partitionName := range qt.query.PartitionNames {
pattern := fmt.Sprintf("^%s$", partitionName)
re, err := regexp.Compile(pattern)
if err != nil {
log.Debug("Failed to compile partition name regex expression.", zap.Any("partitionName", partitionName),
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return errors.New("invalid partition names")
}
found := false
for name, pID := range partitionsMap {
if re.MatchString(name) {
if _, exist := partitionsRecord[pID]; !exist {
rt.PartitionIDs = append(rt.PartitionIDs, pID)
qt.PartitionIDs = append(qt.PartitionIDs, pID)
partitionsRecord[pID] = true
}
found = true
@ -2228,46 +2275,46 @@ func (rt *RetrieveTask) PreExecute(ctx context.Context) error {
}
}
log.Info("Retrieve PreExecute done.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
log.Info("Query PreExecute done.",
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return nil
}
func (rt *RetrieveTask) Execute(ctx context.Context) error {
func (qt *QueryTask) Execute(ctx context.Context) error {
var tsMsg msgstream.TsMsg = &msgstream.RetrieveMsg{
RetrieveRequest: *rt.RetrieveRequest,
RetrieveRequest: *qt.RetrieveRequest,
BaseMsg: msgstream.BaseMsg{
Ctx: ctx,
HashValues: []uint32{uint32(Params.ProxyID)},
BeginTimestamp: rt.Base.Timestamp,
EndTimestamp: rt.Base.Timestamp,
BeginTimestamp: qt.Base.Timestamp,
EndTimestamp: qt.Base.Timestamp,
},
}
msgPack := msgstream.MsgPack{
BeginTs: rt.Base.Timestamp,
EndTs: rt.Base.Timestamp,
BeginTs: qt.Base.Timestamp,
EndTs: qt.Base.Timestamp,
Msgs: make([]msgstream.TsMsg, 1),
}
msgPack.Msgs[0] = tsMsg
collectionName := rt.retrieve.CollectionName
collectionName := qt.query.CollectionName
collID, err := globalMetaCache.GetCollectionID(ctx, collectionName)
if err != nil {
return err
}
stream, err := rt.chMgr.getDQLStream(collID)
stream, err := qt.chMgr.getDQLStream(collID)
if err != nil {
err = rt.chMgr.createDQLStream(collID)
err = qt.chMgr.createDQLStream(collID)
if err != nil {
rt.result.Status.ErrorCode = commonpb.ErrorCode_UnexpectedError
rt.result.Status.Reason = err.Error()
qt.result.Status.ErrorCode = commonpb.ErrorCode_UnexpectedError
qt.result.Status.Reason = err.Error()
return err
}
stream, err = rt.chMgr.getDQLStream(collID)
stream, err = qt.chMgr.getDQLStream(collID)
if err != nil {
rt.result.Status.ErrorCode = commonpb.ErrorCode_UnexpectedError
rt.result.Status.Reason = err.Error()
qt.result.Status.ErrorCode = commonpb.ErrorCode_UnexpectedError
qt.result.Status.Reason = err.Error()
return err
}
}
@ -2275,24 +2322,24 @@ func (rt *RetrieveTask) Execute(ctx context.Context) error {
log.Debug("proxy", zap.Int("length of retrieveMsg", len(msgPack.Msgs)))
if err != nil {
log.Debug("Failed to send retrieve request.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
}
log.Info("Retrieve Execute done.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
log.Info("Query Execute done.",
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return err
}
func (rt *RetrieveTask) PostExecute(ctx context.Context) error {
func (qt *QueryTask) PostExecute(ctx context.Context) error {
t0 := time.Now()
defer func() {
log.Debug("WaitAndPostExecute", zap.Any("time cost", time.Since(t0)))
}()
select {
case <-rt.TraceCtx().Done():
log.Debug("proxy", zap.Int64("Retrieve: wait to finish failed, timeout!, taskID:", rt.ID()))
return fmt.Errorf("RetrieveTask:wait to finish failed, timeout : %d", rt.ID())
case retrieveResults := <-rt.resultBuf:
case <-qt.TraceCtx().Done():
log.Debug("proxy", zap.Int64("Query: wait to finish failed, timeout!, taskID:", qt.ID()))
return fmt.Errorf("QueryTask:wait to finish failed, timeout : %d", qt.ID())
case retrieveResults := <-qt.resultBuf:
retrieveResult := make([]*internalpb.RetrieveResults, 0)
var reason string
for _, partialRetrieveResult := range retrieveResults {
@ -2304,87 +2351,56 @@ func (rt *RetrieveTask) PostExecute(ctx context.Context) error {
}
if len(retrieveResult) == 0 {
rt.result = &milvuspb.RetrieveResults{
qt.result = &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: reason,
},
}
log.Debug("Retrieve failed on all querynodes.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
log.Debug("Query failed on all querynodes.",
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return errors.New(reason)
}
availableQueryNodeNum := 0
rt.result = &milvuspb.RetrieveResults{
qt.result = &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
Ids: &schemapb.IDs{},
FieldsData: make([]*schemapb.FieldData, 0),
}
for idx, partialRetrieveResult := range retrieveResult {
log.Debug("Index-" + strconv.Itoa(idx))
availableQueryNodeNum++
if partialRetrieveResult.Ids == nil {
reason += "ids is nil\n"
continue
} else {
intIds, intOk := partialRetrieveResult.Ids.IdField.(*schemapb.IDs_IntId)
strIds, strOk := partialRetrieveResult.Ids.IdField.(*schemapb.IDs_StrId)
if !intOk && !strOk {
reason += "ids is empty\n"
continue
}
if !intOk {
if idsStr, ok := rt.result.Ids.IdField.(*schemapb.IDs_StrId); ok {
idsStr.StrId.Data = append(idsStr.StrId.Data, strIds.StrId.Data...)
} else {
rt.result.Ids.IdField = &schemapb.IDs_StrId{
StrId: &schemapb.StringArray{
Data: strIds.StrId.Data,
},
}
}
} else {
if idsInt, ok := rt.result.Ids.IdField.(*schemapb.IDs_IntId); ok {
idsInt.IntId.Data = append(idsInt.IntId.Data, intIds.IntId.Data...)
} else {
rt.result.Ids.IdField = &schemapb.IDs_IntId{
IntId: &schemapb.LongArray{
Data: intIds.IntId.Data,
},
}
}
}
if idx == 0 {
rt.result.FieldsData = append(rt.result.FieldsData, partialRetrieveResult.FieldsData...)
qt.result.FieldsData = append(qt.result.FieldsData, partialRetrieveResult.FieldsData...)
} else {
for k, fieldData := range partialRetrieveResult.FieldsData {
switch fieldType := fieldData.Field.(type) {
case *schemapb.FieldData_Scalars:
switch scalarType := fieldType.Scalars.Data.(type) {
case *schemapb.ScalarField_BoolData:
rt.result.FieldsData[k].GetScalars().GetBoolData().Data = append(rt.result.FieldsData[k].GetScalars().GetBoolData().Data, scalarType.BoolData.Data...)
qt.result.FieldsData[k].GetScalars().GetBoolData().Data = append(qt.result.FieldsData[k].GetScalars().GetBoolData().Data, scalarType.BoolData.Data...)
case *schemapb.ScalarField_IntData:
rt.result.FieldsData[k].GetScalars().GetIntData().Data = append(rt.result.FieldsData[k].GetScalars().GetIntData().Data, scalarType.IntData.Data...)
qt.result.FieldsData[k].GetScalars().GetIntData().Data = append(qt.result.FieldsData[k].GetScalars().GetIntData().Data, scalarType.IntData.Data...)
case *schemapb.ScalarField_LongData:
rt.result.FieldsData[k].GetScalars().GetLongData().Data = append(rt.result.FieldsData[k].GetScalars().GetLongData().Data, scalarType.LongData.Data...)
qt.result.FieldsData[k].GetScalars().GetLongData().Data = append(qt.result.FieldsData[k].GetScalars().GetLongData().Data, scalarType.LongData.Data...)
case *schemapb.ScalarField_FloatData:
rt.result.FieldsData[k].GetScalars().GetFloatData().Data = append(rt.result.FieldsData[k].GetScalars().GetFloatData().Data, scalarType.FloatData.Data...)
qt.result.FieldsData[k].GetScalars().GetFloatData().Data = append(qt.result.FieldsData[k].GetScalars().GetFloatData().Data, scalarType.FloatData.Data...)
case *schemapb.ScalarField_DoubleData:
rt.result.FieldsData[k].GetScalars().GetDoubleData().Data = append(rt.result.FieldsData[k].GetScalars().GetDoubleData().Data, scalarType.DoubleData.Data...)
qt.result.FieldsData[k].GetScalars().GetDoubleData().Data = append(qt.result.FieldsData[k].GetScalars().GetDoubleData().Data, scalarType.DoubleData.Data...)
default:
log.Debug("Retrieve received not supported data type")
log.Debug("Query received not supported data type")
}
case *schemapb.FieldData_Vectors:
switch vectorType := fieldType.Vectors.Data.(type) {
case *schemapb.VectorField_BinaryVector:
rt.result.FieldsData[k].GetVectors().Data.(*schemapb.VectorField_BinaryVector).BinaryVector = append(rt.result.FieldsData[k].GetVectors().Data.(*schemapb.VectorField_BinaryVector).BinaryVector, vectorType.BinaryVector...)
qt.result.FieldsData[k].GetVectors().Data.(*schemapb.VectorField_BinaryVector).BinaryVector = append(qt.result.FieldsData[k].GetVectors().Data.(*schemapb.VectorField_BinaryVector).BinaryVector, vectorType.BinaryVector...)
case *schemapb.VectorField_FloatVector:
rt.result.FieldsData[k].GetVectors().GetFloatVector().Data = append(rt.result.FieldsData[k].GetVectors().GetFloatVector().Data, vectorType.FloatVector.Data...)
qt.result.FieldsData[k].GetVectors().GetFloatVector().Data = append(qt.result.FieldsData[k].GetVectors().GetFloatVector().Data, vectorType.FloatVector.Data...)
}
default:
}
@ -2396,8 +2412,8 @@ func (rt *RetrieveTask) PostExecute(ctx context.Context) error {
if availableQueryNodeNum == 0 {
log.Info("Not any valid result found.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
rt.result = &milvuspb.RetrieveResults{
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
qt.result = &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: reason,
@ -2406,10 +2422,10 @@ func (rt *RetrieveTask) PostExecute(ctx context.Context) error {
return nil
}
if len(rt.result.FieldsData) == 0 {
log.Info("Retrieve result is nil.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
rt.result = &milvuspb.RetrieveResults{
if len(qt.result.FieldsData) == 0 {
log.Info("Query result is nil.",
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
qt.result = &milvuspb.QueryResults{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_EmptyCollection,
Reason: reason,
@ -2418,23 +2434,23 @@ func (rt *RetrieveTask) PostExecute(ctx context.Context) error {
return nil
}
schema, err := globalMetaCache.GetCollectionSchema(ctx, rt.retrieve.CollectionName)
schema, err := globalMetaCache.GetCollectionSchema(ctx, qt.query.CollectionName)
if err != nil {
return err
}
for i := 0; i < len(rt.result.FieldsData); i++ {
for i := 0; i < len(qt.result.FieldsData); i++ {
for _, field := range schema.Fields {
if field.FieldID == rt.OutputFieldsId[i] {
rt.result.FieldsData[i].FieldName = field.Name
rt.result.FieldsData[i].FieldId = field.FieldID
rt.result.FieldsData[i].Type = field.DataType
if field.FieldID == qt.OutputFieldsId[i] {
qt.result.FieldsData[i].FieldName = field.Name
qt.result.FieldsData[i].FieldId = field.FieldID
qt.result.FieldsData[i].Type = field.DataType
}
}
}
}
log.Info("Retrieve PostExecute done.",
zap.Any("requestID", rt.Base.MsgID), zap.Any("requestType", "retrieve"))
log.Info("Query PostExecute done.",
zap.Any("requestID", qt.Base.MsgID), zap.Any("requestType", "query"))
return nil
}

6
internal/proxy/task_scheduler.go
View File

@ -808,9 +808,9 @@ func (sched *TaskScheduler) collectResultLoop() {
continue
}
st, ok := t.(*RetrieveTask)
st, ok := t.(*QueryTask)
if !ok {
log.Debug("Proxy collectResultLoop type assert t as RetrieveTask failed")
log.Debug("Proxy collectResultLoop type assert t as QueryTask failed")
delete(queryResultBufs, reqID)
queryResultBufFlags[reqID] = true
continue
@ -842,7 +842,7 @@ func (sched *TaskScheduler) collectResultLoop() {
//t := sched.getTaskByReqID(reqID)
{
colName := t.(*RetrieveTask).retrieve.CollectionName
colName := t.(*QueryTask).query.CollectionName
log.Debug("Proxy collectResultLoop", zap.String("collection name", colName), zap.String("reqID", reqIDStr), zap.Int("answer cnt", len(queryResultBufs[reqID].resultBuf)))
}