test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-11-30 02:48:45 +08:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

Add unittest for timesync when there is only one proxy

Browse Source 
Signed-off-by: neza2017 <yefu.chen@zilliz.com>
This commit is contained in:
neza2017 2020-09-10 19:12:23 +08:00 committed by yefu.chen
parent b4e76c9490
commit be35568af1
17 changed files with 1075 additions and 34612 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

377
pkg/message/message.pb.go
View File

@ -2844,6 +2844,8 @@ type SearchMsg struct {
Timestamp uint64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"` Timestamp uint64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
ClientId int64 `protobuf:"varint,6,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` ClientId int64 `protobuf:"varint,6,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
ExtraParams []*KeyValuePair `protobuf:"bytes,7,rep,name=extra_params,json=extraParams,proto3" json:"extra_params,omitempty"` ExtraParams []*KeyValuePair `protobuf:"bytes,7,rep,name=extra_params,json=extraParams,proto3" json:"extra_params,omitempty"`
Json []string `protobuf:"bytes,8,rep,name=json,proto3" json:"json,omitempty"`
Dsl string `protobuf:"bytes,9,opt,name=dsl,proto3" json:"dsl,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -2923,6 +2925,20 @@ func (m *SearchMsg) GetExtraParams() []*KeyValuePair {
return nil return nil
} }
func (m *SearchMsg) GetJson() []string {
if m != nil {
return m.Json
}
return nil
}
func (m *SearchMsg) GetDsl() string {
if m != nil {
return m.Dsl
}
return ""
}
type TimeSyncMsg struct { type TimeSyncMsg struct {
Peer_Id int64 `protobuf:"varint,1,opt,name=peer_Id,json=peerId,proto3" json:"peer_Id,omitempty"` Peer_Id int64 `protobuf:"varint,1,opt,name=peer_Id,json=peerId,proto3" json:"peer_Id,omitempty"`
Timestamp uint64 `protobuf:"varint,2,opt,name=Timestamp,json=timestamp,proto3" json:"Timestamp,omitempty"` Timestamp uint64 `protobuf:"varint,2,opt,name=Timestamp,json=timestamp,proto3" json:"Timestamp,omitempty"`
@ -3092,184 +3108,185 @@ func init() {
func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) } func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) }
var fileDescriptor_33c57e4bae7b9afd = []byte{ var fileDescriptor_33c57e4bae7b9afd = []byte{
// 2859 bytes of a gzipped FileDescriptorProto // 2876 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xdd, 0x72, 0xdb, 0xc6, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x3a, 0xdd, 0x72, 0xdb, 0xc6,
0xf5, 0x27, 0x08, 0x8a, 0x24, 0x0e, 0x48, 0x09, 0x5a, 0xcb, 0xb6, 0x6c, 0xc7, 0x7f, 0x3b, 0xf8, 0xd5, 0x04, 0x41, 0x91, 0xc4, 0x01, 0x29, 0x41, 0x6b, 0xd9, 0x96, 0xed, 0xf8, 0xb3, 0x83, 0x6f,
0xcf, 0xb4, 0x8e, 0x3b, 0xe3, 0x49, 0x94, 0xd4, 0x76, 0xeb, 0x24, 0x0d, 0x3f, 0x20, 0x09, 0x35, 0xa6, 0x75, 0xdc, 0x19, 0x4f, 0xa2, 0xa4, 0xb6, 0x5b, 0x27, 0x69, 0xf8, 0x03, 0x49, 0xa8, 0x29,
0x45, 0xca, 0x4b, 0xc8, 0xce, 0xc7, 0x74, 0x50, 0x88, 0x58, 0xd3, 0x68, 0x48, 0x80, 0x05, 0x40, 0x52, 0x5e, 0x42, 0x76, 0x7e, 0xa6, 0x83, 0x42, 0xc4, 0x9a, 0x46, 0x43, 0x02, 0x2c, 0x00, 0x5a,
0xcb, 0xbc, 0xed, 0x7d, 0x3b, 0xd3, 0xcb, 0xce, 0xf4, 0xa6, 0x7d, 0x84, 0xf6, 0x2d, 0xfa, 0x02, 0xe6, 0x6d, 0xef, 0xdb, 0x99, 0x5e, 0xf6, 0xb2, 0x7d, 0x84, 0xf6, 0x0d, 0x7a, 0xd9, 0x17, 0xc8,
0xb9, 0xc8, 0x4c, 0x2f, 0x3b, 0x7d, 0x8c, 0xce, 0x7e, 0x80, 0x04, 0x28, 0x52, 0x22, 0xa3, 0xf6, 0x45, 0x66, 0x7a, 0xd9, 0xe9, 0x63, 0x74, 0xf6, 0x07, 0x24, 0x40, 0x91, 0x12, 0x19, 0xb5, 0x57,
0x4a, 0xcb, 0xb3, 0xbb, 0x67, 0xcf, 0xf7, 0xfe, 0xce, 0x42, 0x50, 0x1d, 0x92, 0x28, 0x72, 0xfa, 0x5a, 0x9e, 0xdd, 0x73, 0xf6, 0xfc, 0xef, 0x39, 0x07, 0x82, 0xea, 0x90, 0x44, 0x91, 0xd3, 0x27,
0xe4, 0xd1, 0x28, 0x0c, 0xe2, 0x00, 0xa9, 0x43, 0x6f, 0xf0, 0x76, 0x1c, 0x3d, 0xea, 0x87, 0xa3, 0x8f, 0x46, 0x61, 0x10, 0x07, 0x48, 0x1d, 0x7a, 0x83, 0xb7, 0xe3, 0xe8, 0x51, 0x3f, 0x1c, 0xf5,
0x9e, 0xfe, 0x0a, 0x8a, 0xdd, 0xd8, 0x89, 0xc7, 0x11, 0xfa, 0x29, 0x00, 0x09, 0xc3, 0x20, 0xb4, 0xf4, 0x57, 0x50, 0xec, 0xc6, 0x4e, 0x3c, 0x8e, 0xd0, 0x4f, 0x01, 0x48, 0x18, 0x06, 0xa1, 0xdd,
0x7b, 0x81, 0x4b, 0x76, 0xa5, 0xfb, 0xd2, 0x83, 0xcd, 0xbd, 0x1b, 0x8f, 0x52, 0x6b, 0x1f, 0x19, 0x0b, 0x5c, 0xb2, 0x2b, 0xdd, 0x97, 0x1e, 0x6c, 0xee, 0xdd, 0x78, 0x94, 0x3a, 0xfb, 0xc8, 0xa0,
0x74, 0xba, 0x11, 0xb8, 0x04, 0x2b, 0x24, 0x19, 0xa2, 0x1b, 0x50, 0x0c, 0x89, 0x13, 0x05, 0xfe, 0xdb, 0x8d, 0xc0, 0x25, 0x58, 0x21, 0xc9, 0x12, 0xdd, 0x80, 0x62, 0x48, 0x9c, 0x28, 0xf0, 0x77,
0x6e, 0xfe, 0xbe, 0xf4, 0x40, 0xc1, 0xe2, 0x97, 0xfe, 0x18, 0x2a, 0xcf, 0xc9, 0xe4, 0xa5, 0x33, 0xf3, 0xf7, 0xa5, 0x07, 0x0a, 0x16, 0xbf, 0xf4, 0xc7, 0x50, 0x79, 0x4e, 0x26, 0x2f, 0x9d, 0xc1,
0x18, 0x93, 0x63, 0xc7, 0x0b, 0x91, 0x06, 0xf2, 0xb7, 0x64, 0xc2, 0xf8, 0x2a, 0x98, 0x0e, 0xd1, 0x98, 0x1c, 0x3b, 0x5e, 0x88, 0x34, 0x90, 0xbf, 0x25, 0x13, 0x46, 0x57, 0xc1, 0x74, 0x89, 0x76,
0x0e, 0x6c, 0xbc, 0xa5, 0xd3, 0x62, 0x23, 0xff, 0xa1, 0xff, 0x0c, 0x36, 0x1b, 0xc1, 0x60, 0x40, 0x60, 0xe3, 0x2d, 0xdd, 0x16, 0x88, 0xfc, 0x87, 0xfe, 0x33, 0xd8, 0x6c, 0x04, 0x83, 0x01, 0xe9,
0x7a, 0xb1, 0x17, 0xf8, 0x6d, 0x67, 0x48, 0xd0, 0x8f, 0x61, 0xab, 0x37, 0xa5, 0xd8, 0xbe, 0x33, 0xc5, 0x5e, 0xe0, 0xb7, 0x9d, 0x21, 0x41, 0x3f, 0x86, 0xad, 0xde, 0x14, 0x62, 0xfb, 0xce, 0x90,
0x24, 0x82, 0xcb, 0x66, 0x2f, 0xb3, 0x50, 0x1f, 0x00, 0xca, 0x6e, 0x6d, 0x79, 0x51, 0x8c, 0x7e, 0x08, 0x2a, 0x9b, 0xbd, 0xcc, 0x41, 0x7d, 0x00, 0x28, 0x8b, 0xda, 0xf2, 0xa2, 0x18, 0xfd, 0x04,
0x02, 0xc5, 0x88, 0x69, 0xc8, 0x76, 0xa9, 0x7b, 0xd7, 0x32, 0x3a, 0x71, 0xe5, 0xb1, 0x58, 0x82, 0x8a, 0x11, 0x93, 0x90, 0x61, 0xa9, 0x7b, 0xd7, 0x32, 0x32, 0x71, 0xe1, 0xb1, 0x38, 0x82, 0x3e,
0x3e, 0x00, 0x6d, 0xee, 0xac, 0x68, 0x37, 0x7f, 0x5f, 0x7e, 0xa0, 0xe0, 0xad, 0xec, 0x61, 0x91, 0x00, 0x6d, 0xee, 0xae, 0x68, 0x37, 0x7f, 0x5f, 0x7e, 0xa0, 0xe0, 0xad, 0xec, 0x65, 0x91, 0xde,
0xde, 0x05, 0x65, 0xdf, 0x23, 0x03, 0x77, 0x2d, 0x19, 0xd1, 0x5d, 0x80, 0xd7, 0x74, 0x17, 0x5f, 0x05, 0x65, 0xdf, 0x23, 0x03, 0x77, 0x2d, 0x1e, 0xd1, 0x5d, 0x80, 0xd7, 0x14, 0x8b, 0x9f, 0xe1,
0xc3, 0x35, 0x57, 0x5e, 0x27, 0x7c, 0xf4, 0x7f, 0x48, 0x50, 0x3a, 0x72, 0x46, 0x23, 0xcf, 0xef, 0x92, 0x2b, 0xaf, 0x13, 0x3a, 0xfa, 0x3f, 0x24, 0x28, 0x1d, 0x39, 0xa3, 0x91, 0xe7, 0xf7, 0xd7,
0xaf, 0x27, 0xf8, 0x02, 0x01, 0xf2, 0x0b, 0x05, 0xa0, 0x5c, 0x7b, 0x6f, 0xc8, 0xd0, 0xd9, 0x95, 0x63, 0x7c, 0x01, 0x03, 0xf9, 0x85, 0x0c, 0x50, 0xaa, 0xbd, 0x37, 0x64, 0xe8, 0xec, 0xca, 0x8b,
0x17, 0x71, 0x65, 0x53, 0x58, 0x2c, 0x41, 0x9f, 0x42, 0x85, 0xbc, 0x8b, 0x43, 0xc7, 0x1e, 0x39, 0xa8, 0xb2, 0x2d, 0x2c, 0x8e, 0xa0, 0x4f, 0xa1, 0x42, 0xde, 0xc5, 0xa1, 0x63, 0x8f, 0x9c, 0xd0,
0xa1, 0x33, 0x8c, 0x76, 0x0b, 0xf7, 0xe5, 0x07, 0xea, 0xde, 0xad, 0xcc, 0x96, 0xb4, 0x97, 0xb1, 0x19, 0x46, 0xbb, 0x85, 0xfb, 0xf2, 0x03, 0x75, 0xef, 0x56, 0x06, 0x25, 0x6d, 0x65, 0xac, 0xb2,
0xca, 0x96, 0x1f, 0xb3, 0xd5, 0x7a, 0x04, 0xaa, 0xd0, 0x65, 0x7d, 0x47, 0x3c, 0x81, 0xca, 0x90, 0xe3, 0xc7, 0xec, 0xb4, 0x1e, 0x81, 0x2a, 0x64, 0x59, 0xdf, 0x10, 0x4f, 0xa0, 0x32, 0xe4, 0xb8,
0xef, 0xb5, 0x07, 0x5e, 0x14, 0x33, 0x27, 0xa8, 0x7b, 0x3b, 0x99, 0x2d, 0x82, 0x39, 0x56, 0x87, 0xf6, 0xc0, 0x8b, 0x62, 0x66, 0x04, 0x75, 0x6f, 0x27, 0x83, 0x22, 0x88, 0x63, 0x75, 0x38, 0xbb,
0xb3, 0x53, 0xf4, 0xe7, 0xb0, 0x79, 0xec, 0x84, 0xb1, 0x47, 0x15, 0x66, 0x72, 0xac, 0xee, 0x1b, 0x45, 0x7f, 0x0e, 0x9b, 0xc7, 0x4e, 0x18, 0x7b, 0x54, 0x60, 0xc6, 0xc7, 0xea, 0xb6, 0xd1, 0x40,
0x0d, 0xe4, 0xd8, 0xe9, 0x0b, 0xbb, 0xd1, 0xa1, 0x3e, 0x80, 0xea, 0x94, 0xd9, 0xfa, 0x3a, 0x3c, 0x8e, 0x9d, 0xbe, 0xd0, 0x1b, 0x5d, 0xea, 0x03, 0xa8, 0x4e, 0x89, 0xad, 0x2f, 0xc3, 0x23, 0xb8,
0x82, 0x6b, 0xa3, 0x64, 0xb7, 0x1d, 0x3b, 0x7d, 0xdb, 0x09, 0x43, 0x67, 0x22, 0xe2, 0x69, 0x7b, 0x36, 0x4a, 0xb0, 0xed, 0xd8, 0xe9, 0xdb, 0x4e, 0x18, 0x3a, 0x13, 0xe1, 0x4f, 0xdb, 0xd3, 0x2d,
0x3a, 0x65, 0x39, 0xfd, 0x1a, 0x9d, 0xd0, 0x5f, 0xc0, 0xd6, 0x4b, 0xd2, 0x8b, 0x83, 0x10, 0x07, 0xcb, 0xe9, 0xd7, 0xe8, 0x86, 0xfe, 0x02, 0xb6, 0x5e, 0x92, 0x5e, 0x1c, 0x84, 0x38, 0x38, 0xc3,
0x67, 0x98, 0xf4, 0x82, 0xd0, 0x65, 0xe1, 0x32, 0x08, 0x9c, 0xd8, 0x76, 0x9d, 0xd8, 0xd9, 0x95, 0xa4, 0x17, 0x84, 0x2e, 0x73, 0x97, 0x41, 0xe0, 0xc4, 0xb6, 0xeb, 0xc4, 0xce, 0xae, 0x74, 0x5f,
0xee, 0xcb, 0x0f, 0xf2, 0x58, 0x61, 0x94, 0xa6, 0x13, 0x3b, 0xe8, 0x1e, 0xa8, 0xa7, 0x9e, 0xef, 0x7e, 0x90, 0xc7, 0x0a, 0x83, 0x34, 0x9d, 0xd8, 0x41, 0xf7, 0x40, 0x3d, 0xf5, 0x7c, 0x27, 0x9c,
0x84, 0x13, 0x3e, 0x4f, 0x25, 0xaf, 0x60, 0xe0, 0x24, 0xba, 0x40, 0xff, 0x35, 0x28, 0x86, 0x1f, 0xf0, 0x7d, 0xca, 0x79, 0x05, 0x03, 0x07, 0xd1, 0x03, 0xfa, 0xaf, 0x41, 0x31, 0xfc, 0xd8, 0x8b,
0x7b, 0xf1, 0xc4, 0x74, 0xa3, 0xf5, 0x84, 0xff, 0x11, 0x6c, 0x11, 0xb6, 0xd3, 0xf6, 0xdc, 0x94, 0x27, 0xa6, 0x1b, 0xad, 0xc7, 0xfc, 0x8f, 0x60, 0x8b, 0x30, 0x4c, 0xdb, 0x73, 0x53, 0x8c, 0xcb,
0xe0, 0x32, 0xae, 0x12, 0xc1, 0x90, 0x0b, 0xbd, 0x0f, 0x15, 0x21, 0x34, 0x97, 0xf8, 0x31, 0x94, 0xb8, 0x4a, 0x04, 0x41, 0xce, 0xf4, 0x3e, 0x54, 0x04, 0xd3, 0x9c, 0xe3, 0xc7, 0x50, 0x0a, 0xd9,
0x42, 0x36, 0x8a, 0x98, 0xb8, 0xea, 0xde, 0x7b, 0x99, 0x53, 0xe6, 0x14, 0xc4, 0xc9, 0x62, 0xfd, 0x2a, 0x62, 0xec, 0xaa, 0x7b, 0xef, 0x65, 0x6e, 0x99, 0x13, 0x10, 0x27, 0x87, 0xf5, 0x6f, 0x40,
0x1b, 0x50, 0xf9, 0x1c, 0x77, 0x1a, 0x82, 0xc2, 0x6f, 0x68, 0x51, 0xe1, 0x9e, 0x62, 0x63, 0xf4, 0xe5, 0x7b, 0xdc, 0x68, 0x08, 0x0a, 0xbf, 0xa1, 0x49, 0x85, 0x5b, 0x8a, 0xad, 0xd1, 0x53, 0x80,
0x14, 0x20, 0x0c, 0xce, 0x6c, 0xbe, 0x83, 0x29, 0x3b, 0x1f, 0x8b, 0x69, 0x49, 0xb0, 0x12, 0x26, 0x30, 0x38, 0xb3, 0x39, 0x06, 0x13, 0x76, 0xde, 0x17, 0xd3, 0x9c, 0x60, 0x25, 0x4c, 0x6e, 0xd1,
0xa7, 0xe8, 0x7d, 0x91, 0xab, 0x47, 0x24, 0x76, 0xe6, 0x52, 0x50, 0x9a, 0x4b, 0x41, 0xf4, 0x01, 0xfb, 0x22, 0x56, 0x8f, 0x48, 0xec, 0xcc, 0x85, 0xa0, 0x34, 0x17, 0x82, 0xe8, 0x03, 0x28, 0xc4,
0x14, 0xe2, 0xc9, 0x88, 0xa7, 0xcf, 0xe6, 0xde, 0xf5, 0x0c, 0x7f, 0x6a, 0x53, 0x6b, 0x32, 0x22, 0x93, 0x11, 0x0f, 0x9f, 0xcd, 0xbd, 0xeb, 0x19, 0xfa, 0x54, 0xa7, 0xd6, 0x64, 0x44, 0x30, 0x3b,
0x98, 0x2d, 0xa1, 0x01, 0xe3, 0x7a, 0x43, 0x96, 0x48, 0x32, 0xa6, 0x43, 0xbd, 0x06, 0x45, 0x9e, 0x42, 0x1d, 0xc6, 0xf5, 0x86, 0x2c, 0x90, 0x64, 0x4c, 0x97, 0x7a, 0x0d, 0x8a, 0x3c, 0x84, 0xd0,
0x42, 0xe8, 0x09, 0xa8, 0xfc, 0x94, 0x21, 0x89, 0x9d, 0xc4, 0x16, 0xd9, 0x7a, 0x3a, 0x15, 0x09, 0x13, 0x50, 0xf9, 0x2d, 0x43, 0x12, 0x3b, 0x89, 0x2e, 0xb2, 0xf9, 0x74, 0xca, 0x12, 0xe6, 0x0c,
0x73, 0x81, 0xe8, 0x30, 0xd2, 0xef, 0x42, 0x09, 0x07, 0x67, 0xcc, 0xbd, 0x08, 0x0a, 0xa7, 0x83, 0xd1, 0x65, 0xa4, 0xdf, 0x85, 0x12, 0x0e, 0xce, 0x98, 0x79, 0x11, 0x14, 0x4e, 0x07, 0xc1, 0x29,
0xe0, 0x94, 0xc9, 0x58, 0xc1, 0x6c, 0xac, 0xff, 0x25, 0x0f, 0xaa, 0xe9, 0x47, 0x24, 0x8c, 0xd7, 0xe3, 0xb1, 0x82, 0xd9, 0x5a, 0xff, 0x73, 0x1e, 0x54, 0xd3, 0x8f, 0x48, 0x18, 0xaf, 0xe9, 0xdd,
0x8c, 0xee, 0x59, 0xe2, 0xe7, 0x2f, 0x4f, 0xfc, 0x8f, 0x80, 0x5a, 0x2f, 0xe2, 0x61, 0x25, 0x2f, 0xb3, 0xc0, 0xcf, 0x5f, 0x1e, 0xf8, 0x1f, 0x01, 0xd5, 0x5e, 0xc4, 0xdd, 0x4a, 0x5e, 0x10, 0x7b,
0xc8, 0x3d, 0x21, 0x22, 0x2e, 0xd3, 0x65, 0x4c, 0xd8, 0x05, 0x01, 0x53, 0x58, 0x10, 0x30, 0xe8, 0x82, 0x45, 0x5c, 0xa6, 0xc7, 0x18, 0xb3, 0x0b, 0x1c, 0xa6, 0xb0, 0xc0, 0x61, 0xd0, 0xff, 0x43,
0xff, 0xa1, 0x9a, 0xc9, 0x8a, 0xdd, 0x0d, 0x26, 0x6e, 0x25, 0x9d, 0x0f, 0xe7, 0x0a, 0x4f, 0x71, 0x35, 0x13, 0x15, 0xbb, 0x1b, 0x8c, 0xdd, 0x4a, 0x3a, 0x1e, 0xce, 0x25, 0x9e, 0xe2, 0x5a, 0x89,
0xad, 0xc2, 0xf3, 0x6f, 0x09, 0xd4, 0x2e, 0x71, 0xc2, 0xde, 0x9b, 0x35, 0x6d, 0xf4, 0x0c, 0x2a, 0xe7, 0xdf, 0x12, 0xa8, 0x5d, 0xe2, 0x84, 0xbd, 0x37, 0x6b, 0xea, 0xe8, 0x19, 0x54, 0xde, 0x32,
0x6f, 0x59, 0x08, 0xf1, 0x73, 0x45, 0xd5, 0xd9, 0x5d, 0x10, 0x63, 0x8c, 0x31, 0x56, 0xdf, 0xa6, 0x17, 0xe2, 0xf7, 0x8a, 0xac, 0xb3, 0xbb, 0xc0, 0xc7, 0x18, 0x61, 0xac, 0xbe, 0x4d, 0xb9, 0x2c,
0x42, 0x96, 0x46, 0x43, 0x34, 0x60, 0xd1, 0xa0, 0x60, 0x3a, 0x3c, 0xaf, 0x6a, 0x81, 0xa5, 0xfe, 0xf5, 0x86, 0x68, 0xc0, 0xbc, 0x41, 0xc1, 0x74, 0x79, 0x5e, 0xd4, 0x02, 0x0b, 0xfd, 0x8b, 0x45,
0xc5, 0xaa, 0x6e, 0xac, 0xa5, 0xea, 0x19, 0xec, 0x70, 0x4d, 0x4d, 0xbf, 0x4b, 0xfa, 0x43, 0xe2, 0xdd, 0x58, 0x4b, 0xd4, 0x33, 0xd8, 0xe1, 0x92, 0x9a, 0x7e, 0x97, 0xf4, 0x87, 0xc4, 0x17, 0x6e,
0x8b, 0xb0, 0xd0, 0xa1, 0xfa, 0xda, 0x1b, 0x90, 0x99, 0x2f, 0x24, 0x76, 0xb4, 0x4a, 0x89, 0x89, 0xa1, 0x43, 0xf5, 0xb5, 0x37, 0x20, 0x33, 0x5b, 0x48, 0xec, 0x6a, 0x95, 0x02, 0x13, 0x4b, 0x3c,
0x27, 0x9e, 0x41, 0x25, 0x62, 0x7b, 0xa7, 0xda, 0x4a, 0xe7, 0xb4, 0x4d, 0x99, 0x11, 0xab, 0xd1, 0x83, 0x4a, 0xc4, 0x70, 0xa7, 0xd2, 0x4a, 0xe7, 0xa4, 0x4d, 0xa9, 0x11, 0xab, 0xd1, 0xec, 0x87,
0xec, 0x87, 0xfe, 0x27, 0x09, 0xca, 0xac, 0xb4, 0x78, 0x64, 0xcd, 0xca, 0xa2, 0x81, 0xec, 0xb9, 0xfe, 0x27, 0x09, 0xca, 0x2c, 0xb5, 0x78, 0x64, 0xcd, 0xcc, 0xa2, 0x81, 0xec, 0xb9, 0x91, 0xc8,
0x91, 0xa8, 0x26, 0x74, 0x88, 0xee, 0x80, 0xf2, 0xd6, 0x19, 0x78, 0xae, 0x1d, 0x06, 0x67, 0x2c, 0x26, 0x74, 0x89, 0xee, 0x80, 0xf2, 0xd6, 0x19, 0x78, 0xae, 0x1d, 0x06, 0x67, 0xcc, 0xdb, 0xca,
0xda, 0xca, 0xb8, 0xcc, 0x08, 0x38, 0x38, 0xcb, 0x86, 0x62, 0x61, 0x95, 0x50, 0xd4, 0xff, 0x96, 0xb8, 0xcc, 0x00, 0x38, 0x38, 0xcb, 0xba, 0x62, 0x61, 0x15, 0x57, 0xd4, 0xff, 0x9a, 0x07, 0xf5,
0x07, 0xf5, 0xc5, 0x98, 0x84, 0x13, 0x4c, 0xa2, 0xf1, 0x60, 0xcd, 0xaa, 0xfd, 0x11, 0x94, 0x89, 0xc5, 0x98, 0x84, 0x13, 0x4c, 0xa2, 0xf1, 0x60, 0xcd, 0xac, 0xfd, 0x11, 0x94, 0x89, 0x90, 0x4b,
0xd0, 0x4b, 0x58, 0x24, 0x5b, 0x03, 0x12, 0xa5, 0xf1, 0x74, 0x19, 0xba, 0x09, 0x25, 0x5a, 0x98, 0x68, 0x24, 0x9b, 0x03, 0x12, 0xa1, 0xf1, 0xf4, 0x18, 0xba, 0x09, 0x25, 0x9a, 0x98, 0xfc, 0x71,
0xfc, 0x71, 0x52, 0x0b, 0x8a, 0x61, 0x70, 0xd6, 0x1e, 0x0f, 0x29, 0x38, 0x8a, 0x7a, 0x41, 0x48, 0x92, 0x0b, 0x8a, 0x61, 0x70, 0xd6, 0x1e, 0x0f, 0x69, 0x71, 0x14, 0xf5, 0x82, 0x90, 0xf0, 0x97,
0xf8, 0xcd, 0x99, 0xc7, 0xe2, 0x17, 0x7a, 0x0f, 0x14, 0xd7, 0x8b, 0x62, 0xc7, 0xef, 0x11, 0xee, 0x33, 0x8f, 0xc5, 0x2f, 0xf4, 0x1e, 0x28, 0xae, 0x17, 0xc5, 0x8e, 0xdf, 0x23, 0xdc, 0xe0, 0x79,
0xf0, 0x3c, 0x9e, 0x11, 0xae, 0x16, 0xfc, 0xe8, 0x16, 0x94, 0x7f, 0x4b, 0x75, 0xb7, 0x3d, 0x77, 0x3c, 0x03, 0x5c, 0xcd, 0xf9, 0xd1, 0x2d, 0x28, 0xff, 0x96, 0xca, 0x6e, 0x7b, 0xee, 0x6e, 0x89,
0xb7, 0xc4, 0xa4, 0x29, 0xb1, 0xdf, 0xa6, 0x4b, 0xed, 0xdc, 0x1b, 0x78, 0xc4, 0x8f, 0xe9, 0x5c, 0x71, 0x53, 0x62, 0xbf, 0x4d, 0x97, 0xea, 0xb9, 0x37, 0xf0, 0x88, 0x1f, 0xd3, 0xbd, 0x32, 0xdb,
0x99, 0xcd, 0x95, 0x39, 0xc1, 0x74, 0xf5, 0x5f, 0x81, 0xda, 0x8d, 0x43, 0x7a, 0x9f, 0x92, 0xd1, 0x2b, 0x73, 0x80, 0xe9, 0xea, 0xbf, 0x02, 0xb5, 0x1b, 0x87, 0xf4, 0x3d, 0x25, 0xa3, 0xc1, 0x64,
0x60, 0xb2, 0x9e, 0xcd, 0xde, 0x87, 0x4a, 0xc4, 0xf6, 0xda, 0x21, 0xdd, 0x2c, 0xae, 0x50, 0x35, 0x3d, 0x9d, 0xbd, 0x0f, 0x95, 0x88, 0xe1, 0xda, 0x21, 0x45, 0x16, 0x4f, 0xa8, 0x1a, 0xcd, 0xe8,
0x9a, 0xf1, 0xd3, 0x5f, 0x81, 0x52, 0x0f, 0x82, 0xc1, 0x0f, 0x60, 0x7e, 0x17, 0xe0, 0x34, 0x08, 0xe9, 0xaf, 0x40, 0xa9, 0x07, 0xc1, 0xe0, 0x07, 0x10, 0xbf, 0x0b, 0x70, 0x1a, 0x04, 0x83, 0x14,
0x06, 0x29, 0xd6, 0x65, 0xac, 0x9c, 0x26, 0xbc, 0xf4, 0x28, 0x8d, 0xfa, 0x70, 0x70, 0xd6, 0x08, 0xe9, 0x32, 0x56, 0x4e, 0x13, 0x5a, 0x7a, 0x94, 0xae, 0xfa, 0x70, 0x70, 0xd6, 0x08, 0xc6, 0xfe,
0xc6, 0xfe, 0x9a, 0x2e, 0xff, 0x10, 0x76, 0x52, 0xf5, 0x81, 0xba, 0xb2, 0x47, 0x99, 0xb0, 0xb3, 0x9a, 0x26, 0xff, 0x10, 0x76, 0x52, 0xf9, 0x81, 0x9a, 0xb2, 0x47, 0x89, 0xb0, 0xbb, 0x64, 0x8c,
0x64, 0x8c, 0x7a, 0xe7, 0xd8, 0xeb, 0x77, 0xa0, 0xd4, 0x08, 0x86, 0x43, 0xc7, 0x77, 0x69, 0x38, 0x7a, 0xe7, 0xc8, 0xeb, 0x77, 0xa0, 0xd4, 0x08, 0x86, 0x43, 0xc7, 0x77, 0xa9, 0x3b, 0xf7, 0x86,
0xf7, 0x86, 0x6e, 0x02, 0x6c, 0x7b, 0x43, 0x57, 0xff, 0xa7, 0x04, 0x60, 0xfa, 0x2e, 0x79, 0xc7, 0x6e, 0x52, 0xd8, 0xf6, 0x86, 0xae, 0xfe, 0x4f, 0x09, 0xc0, 0xf4, 0x5d, 0xf2, 0x8e, 0x87, 0xe2,
0x53, 0xf1, 0x7f, 0x83, 0xe3, 0xb2, 0xb7, 0x98, 0x3c, 0x7f, 0x8b, 0xdd, 0x05, 0xf0, 0xa8, 0x08, 0xff, 0xa6, 0x8e, 0xcb, 0xbe, 0x62, 0xf2, 0xfc, 0x2b, 0x76, 0x17, 0xc0, 0xa3, 0x2c, 0xf0, 0xed,
0x7c, 0xba, 0xc0, 0xa7, 0x19, 0x85, 0x4d, 0x5f, 0xad, 0xe8, 0x7c, 0x01, 0xb0, 0x3f, 0x18, 0x47, 0x02, 0xdf, 0x66, 0x10, 0xb6, 0x7d, 0xb5, 0xa4, 0xf3, 0x05, 0xc0, 0xfe, 0x60, 0x1c, 0x89, 0xec,
0xa2, 0xba, 0xee, 0xc1, 0xf5, 0x39, 0x91, 0x33, 0x25, 0xe7, 0x5a, 0x56, 0x70, 0x8e, 0x1a, 0x4e, 0xba, 0x07, 0xd7, 0xe7, 0x58, 0xce, 0xa4, 0x9c, 0x6b, 0x59, 0xc6, 0x79, 0xd5, 0x70, 0x02, 0x95,
0xa0, 0xd2, 0x08, 0x86, 0x23, 0xa7, 0xb7, 0xee, 0x2d, 0xf6, 0x1e, 0x28, 0xf1, 0x9b, 0x90, 0x44, 0x46, 0x30, 0x1c, 0x39, 0xbd, 0x75, 0x5f, 0xb1, 0xf7, 0x40, 0x89, 0xdf, 0x84, 0x24, 0x7a, 0x13,
0x6f, 0x82, 0x01, 0x87, 0x00, 0x12, 0x9e, 0x11, 0xf4, 0x13, 0xd8, 0x6a, 0x92, 0x01, 0x89, 0x49, 0x0c, 0x78, 0x09, 0x20, 0xe1, 0x19, 0x40, 0x3f, 0x81, 0xad, 0x26, 0x19, 0x90, 0x98, 0xd4, 0x27,
0x7d, 0x62, 0x36, 0xd7, 0xe4, 0x7c, 0x0b, 0xca, 0x73, 0x48, 0xa7, 0xe4, 0x09, 0x8c, 0xf3, 0x75, 0x66, 0x73, 0x4d, 0xca, 0xb7, 0xa0, 0x3c, 0x57, 0xe9, 0x94, 0x3c, 0x51, 0xe3, 0x7c, 0x9d, 0xee,
0xba, 0x27, 0x31, 0xfd, 0xd7, 0xc1, 0x7a, 0x3e, 0xbd, 0x03, 0x0a, 0xc5, 0x2f, 0xb6, 0xe7, 0xbf, 0x49, 0x4c, 0xff, 0x75, 0xb0, 0x9e, 0x4d, 0xef, 0x80, 0x42, 0xeb, 0x17, 0xdb, 0xf3, 0x5f, 0x07,
0x0e, 0x84, 0x37, 0xcb, 0x94, 0x40, 0x39, 0xe9, 0xdf, 0xc0, 0xf6, 0x01, 0x89, 0x05, 0x48, 0x6b, 0xc2, 0x9a, 0x65, 0x0a, 0xa0, 0x94, 0xf4, 0x6f, 0x60, 0xfb, 0x80, 0xc4, 0xa2, 0x48, 0x6b, 0x46,
0x46, 0x6b, 0x0a, 0x7d, 0x17, 0x20, 0xe2, 0x65, 0x9f, 0xa6, 0x34, 0x8f, 0x57, 0x45, 0x50, 0x4c, 0x6b, 0x32, 0x7d, 0x17, 0x20, 0xe2, 0x69, 0x9f, 0x86, 0x34, 0xf7, 0x57, 0x45, 0x40, 0x4c, 0x57,
0x57, 0x1f, 0xc3, 0x66, 0x02, 0xff, 0xf8, 0x25, 0xfc, 0xdf, 0x30, 0x07, 0x45, 0x9d, 0xb3, 0xd0, 0x1f, 0xc3, 0x66, 0x52, 0xfe, 0xf1, 0x47, 0xf8, 0xbf, 0xa1, 0x0e, 0x5a, 0x75, 0xce, 0x5c, 0x2f,
0x8b, 0x58, 0xc1, 0x56, 0x04, 0x84, 0xe1, 0xad, 0xd1, 0x87, 0xa0, 0xf1, 0x5b, 0x92, 0x21, 0x1c, 0x62, 0x09, 0x5b, 0x11, 0x25, 0x0c, 0x6f, 0x8d, 0x3e, 0x04, 0x8d, 0xbf, 0x92, 0xac, 0xc2, 0xe1,
0xae, 0x12, 0x2b, 0x79, 0x43, 0xe2, 0x47, 0x9e, 0x40, 0x75, 0x32, 0x9e, 0x11, 0xf4, 0x3f, 0x48, 0x22, 0xb1, 0x94, 0x37, 0x24, 0x7e, 0xe4, 0x89, 0xaa, 0x4e, 0xc6, 0x33, 0x80, 0xfe, 0x07, 0x49,
0x02, 0xa1, 0x51, 0x74, 0x85, 0x3e, 0x01, 0x85, 0x56, 0x7b, 0x9b, 0xe1, 0x30, 0xe9, 0x02, 0x1c, 0x54, 0x68, 0xb4, 0xba, 0x42, 0x9f, 0x80, 0x42, 0xb3, 0xbd, 0xcd, 0xea, 0x30, 0xe9, 0x82, 0x3a,
0x76, 0x98, 0xc3, 0x65, 0x57, 0x8c, 0x51, 0xfd, 0xdc, 0xe5, 0x4d, 0x3d, 0x73, 0x77, 0xc1, 0xe5, 0xec, 0x30, 0x87, 0xcb, 0xae, 0x58, 0xa3, 0xfa, 0xb9, 0xc7, 0x9b, 0x5a, 0xe6, 0xee, 0x82, 0xc7,
0x3d, 0x13, 0xeb, 0x30, 0x97, 0xb9, 0xc3, 0xeb, 0x25, 0xd1, 0x93, 0xea, 0xdf, 0x49, 0x00, 0x29, 0x7b, 0xc6, 0xd6, 0x61, 0x2e, 0xf3, 0x86, 0xd7, 0x4b, 0xa2, 0x27, 0xd5, 0xbf, 0x93, 0x00, 0x52,
0xe9, 0x37, 0x21, 0xef, 0xf1, 0x1c, 0x2f, 0xe0, 0xbc, 0xe7, 0x52, 0x64, 0x96, 0xca, 0x4d, 0x36, 0xdc, 0x6f, 0x42, 0xde, 0xe3, 0x31, 0x5e, 0xc0, 0x79, 0xcf, 0xa5, 0x95, 0x59, 0x2a, 0x36, 0xd9,
0x9e, 0x02, 0x47, 0xf9, 0x72, 0xe0, 0xf8, 0x29, 0x54, 0x78, 0x76, 0xae, 0xdc, 0x57, 0x79, 0xd3, 0x7a, 0x5a, 0x38, 0xca, 0x97, 0x17, 0x8e, 0x9f, 0x42, 0x85, 0x47, 0xe7, 0xca, 0x7d, 0x95, 0x37,
0x7a, 0x12, 0x5d, 0x31, 0x79, 0x0f, 0x60, 0x3b, 0x65, 0x05, 0x81, 0xda, 0xf7, 0x92, 0x5e, 0x7c, 0xcd, 0x27, 0xd1, 0x15, 0x83, 0xf7, 0x00, 0xb6, 0x53, 0x5a, 0x10, 0x55, 0xfb, 0x5e, 0xd2, 0x8b,
0x15, 0xcc, 0x2e, 0x4c, 0xf4, 0xbd, 0x04, 0x8a, 0x45, 0xc2, 0x21, 0xbb, 0x69, 0x2f, 0x43, 0xd5, 0xaf, 0x52, 0xb3, 0x0b, 0x15, 0x7d, 0x2f, 0x81, 0x62, 0x91, 0x70, 0xc8, 0x5e, 0xda, 0xcb, 0xaa,
0x77, 0x40, 0xf1, 0xfc, 0xd8, 0x4e, 0x1a, 0x7e, 0x1a, 0x4f, 0x65, 0xcf, 0x8f, 0x99, 0x8c, 0xf4, 0xea, 0x3b, 0xa0, 0x78, 0x7e, 0x6c, 0x27, 0x0d, 0x3f, 0xf5, 0xa7, 0xb2, 0xe7, 0xc7, 0x8c, 0x47,
0xfa, 0x70, 0x83, 0xf1, 0xe9, 0x80, 0x88, 0x79, 0x1a, 0x51, 0x12, 0x56, 0x39, 0x8d, 0x2f, 0xe1, 0xfa, 0x7c, 0xb8, 0xc1, 0xf8, 0x74, 0x40, 0xc4, 0x3e, 0xf5, 0x28, 0x09, 0xab, 0x1c, 0xc6, 0x8f,
0x10, 0x61, 0x4c, 0xd8, 0x25, 0x5b, 0xe0, 0x57, 0x17, 0x23, 0xd0, 0x6b, 0x76, 0x07, 0x36, 0x4e, 0xf0, 0x12, 0x61, 0x4c, 0xd8, 0x23, 0x5b, 0xe0, 0x4f, 0x17, 0x03, 0xd0, 0x67, 0x76, 0x07, 0x36,
0x83, 0x20, 0x8a, 0x19, 0x94, 0xcc, 0x63, 0xfe, 0xe3, 0x8a, 0x18, 0xd2, 0x01, 0x95, 0x55, 0xa8, 0x4e, 0x83, 0x20, 0x8a, 0x59, 0x29, 0x99, 0xc7, 0xfc, 0xc7, 0x15, 0x6b, 0x48, 0x07, 0x54, 0x96,
0x90, 0x18, 0xef, 0x46, 0x21, 0x7a, 0x0a, 0xe5, 0x60, 0x44, 0x42, 0x27, 0x0e, 0x42, 0x11, 0x91, 0xa1, 0x42, 0x62, 0xbc, 0x1b, 0x85, 0xe8, 0x29, 0x94, 0x83, 0x11, 0x09, 0x9d, 0x38, 0x08, 0x85,
0x59, 0x1b, 0x89, 0xb5, 0x1d, 0xb1, 0x06, 0x4f, 0x57, 0xa3, 0x5d, 0x28, 0xb1, 0xb1, 0xef, 0x8a, 0x47, 0x66, 0x75, 0x24, 0xce, 0x76, 0xc4, 0x19, 0x3c, 0x3d, 0x8d, 0x76, 0xa1, 0xc4, 0xd6, 0xbe,
0x68, 0x49, 0x7e, 0xea, 0x7f, 0x97, 0x00, 0xb0, 0xe3, 0xf7, 0xc9, 0x4a, 0x16, 0xdc, 0x4b, 0xf3, 0x2b, 0xbc, 0x25, 0xf9, 0xa9, 0xff, 0x4d, 0x02, 0xc0, 0x8e, 0xdf, 0x27, 0x2b, 0x69, 0x70, 0x2f,
0x39, 0x0f, 0x4b, 0x53, 0xc2, 0x4e, 0x4f, 0x98, 0x19, 0x46, 0xbe, 0xc8, 0x30, 0xeb, 0x75, 0xf5, 0x4d, 0xe7, 0x7c, 0x59, 0x9a, 0x62, 0x76, 0x7a, 0xc3, 0x4c, 0x31, 0xf2, 0x45, 0x8a, 0x59, 0xaf,
0xdf, 0x49, 0x49, 0xa7, 0xb6, 0x92, 0xd8, 0xf7, 0x40, 0xe5, 0x70, 0x84, 0x0b, 0x92, 0x67, 0x82, 0xab, 0xff, 0x4e, 0x4a, 0x3a, 0xb5, 0x95, 0xd8, 0xbe, 0x07, 0x2a, 0x2f, 0x47, 0x38, 0x23, 0x79,
0x00, 0x23, 0xd5, 0x99, 0x34, 0xa9, 0x86, 0x51, 0x5e, 0xa3, 0x61, 0xa4, 0x29, 0x18, 0x07, 0xa3, 0xc6, 0x08, 0x30, 0x50, 0x9d, 0x71, 0x93, 0x6a, 0x18, 0xe5, 0x35, 0x1a, 0x46, 0x1a, 0x82, 0x71,
0x6f, 0x45, 0x30, 0xb0, 0xf1, 0x15, 0x33, 0xe3, 0x1d, 0x54, 0x28, 0x44, 0x21, 0x8e, 0xcf, 0x35, 0x30, 0xfa, 0x56, 0x38, 0x03, 0x5b, 0x5f, 0x31, 0x32, 0xde, 0x41, 0x85, 0x96, 0x28, 0xc4, 0xf1,
0x7b, 0x00, 0x1b, 0x41, 0xaf, 0x37, 0x4e, 0x1c, 0x8e, 0x32, 0x6c, 0x3a, 0x74, 0x06, 0xf3, 0x05, 0xb9, 0x64, 0x0f, 0x60, 0x23, 0xe8, 0xf5, 0xc6, 0x89, 0xc1, 0x51, 0x86, 0x4c, 0x87, 0xee, 0x60,
0xe8, 0x73, 0xa8, 0xf6, 0x89, 0x4f, 0x42, 0x67, 0x60, 0x33, 0xcd, 0x84, 0x87, 0xb2, 0x07, 0x1f, 0x7e, 0x00, 0x7d, 0x0e, 0xd5, 0x3e, 0xf1, 0x49, 0xe8, 0x0c, 0x6c, 0x26, 0x99, 0xb0, 0x50, 0xf6,
0xf0, 0x15, 0x1c, 0x98, 0x56, 0xfa, 0xa9, 0x5f, 0xfa, 0xef, 0xf3, 0x50, 0x49, 0x4f, 0xa3, 0x2f, 0xe2, 0x03, 0x7e, 0x82, 0x17, 0xa6, 0x95, 0x7e, 0xea, 0x97, 0xfe, 0xfb, 0x3c, 0x54, 0xd2, 0xdb,
0xa0, 0x7a, 0xca, 0x45, 0x11, 0x0c, 0xa5, 0x05, 0xdd, 0x6e, 0x5a, 0xd8, 0xc3, 0x1c, 0xae, 0x9c, 0xe8, 0x0b, 0xa8, 0x9e, 0x72, 0x56, 0x04, 0x41, 0x69, 0x41, 0xb7, 0x9b, 0x66, 0xf6, 0x30, 0x87,
0xa6, 0x85, 0x7f, 0x02, 0x10, 0x93, 0x70, 0x38, 0x95, 0x47, 0x3a, 0xd7, 0x7e, 0x4e, 0x73, 0xf7, 0x2b, 0xa7, 0x69, 0xe6, 0x9f, 0x00, 0xc4, 0x24, 0x1c, 0x4e, 0xf9, 0x91, 0xce, 0xb5, 0x9f, 0xd3,
0x30, 0x87, 0x95, 0x78, 0x9a, 0xc8, 0x3f, 0x07, 0x35, 0xa4, 0x41, 0x29, 0x76, 0xf2, 0x57, 0xa2, 0xd8, 0x3d, 0xcc, 0x61, 0x25, 0x9e, 0x06, 0xf2, 0xcf, 0x41, 0x0d, 0xa9, 0x53, 0x0a, 0x4c, 0x3e,
0x9b, 0x59, 0xc4, 0x3d, 0x0d, 0xda, 0xc3, 0x1c, 0x86, 0x70, 0x16, 0xc2, 0x9f, 0x4d, 0x4b, 0x30, 0x25, 0xba, 0x99, 0xad, 0xb8, 0xa7, 0x4e, 0x7b, 0x98, 0xc3, 0x10, 0xce, 0x5c, 0xf8, 0xb3, 0x69,
0xdf, 0x5c, 0x58, 0xd0, 0x51, 0xa4, 0x62, 0x67, 0x56, 0x7d, 0xd9, 0x4f, 0x5a, 0x7d, 0xd9, 0x3e, 0x0a, 0xe6, 0xc8, 0x85, 0x05, 0x1d, 0x45, 0xca, 0x77, 0x66, 0xd9, 0x97, 0xfd, 0xa4, 0xd9, 0x97,
0xfd, 0x5f, 0x12, 0x54, 0x53, 0x9d, 0xc7, 0x71, 0x7d, 0xf5, 0x7b, 0x6b, 0xcd, 0x47, 0x97, 0xf3, 0xe1, 0xe9, 0xff, 0x92, 0xa0, 0x9a, 0xea, 0x3c, 0x8e, 0xeb, 0xab, 0xbf, 0x5b, 0x6b, 0x0e, 0x5d,
0xae, 0x93, 0x17, 0x58, 0x7a, 0xb9, 0xeb, 0xae, 0x98, 0x4c, 0xbf, 0x93, 0x61, 0x9b, 0x77, 0xf3, 0xce, 0x9b, 0x4e, 0x5e, 0xa0, 0xe9, 0xe5, 0xa6, 0xbb, 0x62, 0x30, 0xfd, 0x4e, 0x86, 0x6d, 0xde,
0x9d, 0x90, 0x23, 0x97, 0xa3, 0xa8, 0xbf, 0xba, 0xb2, 0x99, 0xde, 0x88, 0xfb, 0xf8, 0xb2, 0x36, 0xcd, 0x77, 0x42, 0x5e, 0xb9, 0x1c, 0x45, 0xfd, 0xd5, 0x85, 0xcd, 0xf4, 0x46, 0xdc, 0xc6, 0x97,
0x5d, 0x03, 0x79, 0xec, 0xb9, 0xc9, 0x9b, 0xc5, 0xd8, 0x73, 0x17, 0x75, 0xa9, 0xe7, 0x1b, 0x72, 0xb5, 0xe9, 0x1a, 0xc8, 0x63, 0xcf, 0x4d, 0x66, 0x16, 0x63, 0xcf, 0x5d, 0xd4, 0xa5, 0x9e, 0x6f,
0x8a, 0xbb, 0xbc, 0x21, 0x89, 0x62, 0x67, 0x38, 0x62, 0x65, 0xb6, 0x80, 0x67, 0x84, 0x39, 0x18, 0xc8, 0x69, 0xdd, 0xe5, 0x0d, 0x49, 0x14, 0x3b, 0xc3, 0x11, 0x4b, 0xb3, 0x05, 0x3c, 0x03, 0xcc,
0x52, 0x9c, 0x83, 0x21, 0x74, 0xba, 0xf7, 0xc6, 0xf1, 0x7d, 0x32, 0x98, 0x35, 0x25, 0x8a, 0xa0, 0x95, 0x21, 0xc5, 0xb9, 0x32, 0x84, 0x6e, 0xf7, 0xde, 0x38, 0xbe, 0x4f, 0x06, 0xb3, 0xa6, 0x44,
0x98, 0x54, 0x80, 0x7c, 0x30, 0x62, 0xfd, 0xc8, 0xe6, 0x1c, 0x90, 0xea, 0x8c, 0xd8, 0xa5, 0x99, 0x11, 0x10, 0x93, 0x32, 0x90, 0x0f, 0x46, 0xac, 0x1f, 0xd9, 0x9c, 0x2b, 0xa4, 0x3a, 0x23, 0xf6,
0x0f, 0x46, 0xd9, 0xde, 0x45, 0xc9, 0xf6, 0x2e, 0xe7, 0x9c, 0x00, 0x6b, 0x39, 0xe1, 0xcf, 0x79, 0x68, 0xe6, 0x83, 0x51, 0xb6, 0x77, 0x51, 0xb2, 0xbd, 0xcb, 0x39, 0x23, 0xc0, 0x5a, 0x46, 0xf8,
0x50, 0x78, 0xb4, 0xad, 0x65, 0xfc, 0x54, 0xe1, 0xe2, 0xa6, 0x5f, 0xb1, 0x70, 0x9d, 0xb3, 0xb7, 0x7b, 0x1e, 0x14, 0xee, 0x6d, 0x6b, 0x29, 0x3f, 0x95, 0xb8, 0xb8, 0xea, 0x57, 0x4c, 0x5c, 0xe7,
0xbc, 0xc0, 0xde, 0xc2, 0x4d, 0x85, 0x99, 0x9b, 0x2e, 0xf6, 0x40, 0xc6, 0x3c, 0xc5, 0x4b, 0xcc, 0xf4, 0x2d, 0x2f, 0xd0, 0xb7, 0x30, 0x53, 0x61, 0x66, 0xa6, 0x8b, 0x2d, 0x90, 0x51, 0x4f, 0xf1,
0x53, 0x5a, 0xb3, 0x2c, 0xaa, 0x96, 0x37, 0x24, 0xdd, 0x89, 0xdf, 0xa3, 0xf6, 0xb9, 0x09, 0xa5, 0x12, 0xf5, 0x94, 0xd6, 0x6a, 0x28, 0x93, 0x51, 0x5c, 0x99, 0x85, 0x10, 0x1f, 0xc5, 0x89, 0x59,
0x11, 0x21, 0xa1, 0x6d, 0xba, 0x02, 0xc6, 0x15, 0xe9, 0x4f, 0x93, 0x09, 0x68, 0x4d, 0x05, 0xcc, 0x87, 0x32, 0x9d, 0x75, 0xe8, 0xef, 0x40, 0xb5, 0xbc, 0x21, 0xe9, 0x4e, 0xfc, 0x1e, 0xd5, 0xe2,
0xcf, 0x0b, 0xb8, 0x07, 0x4a, 0x34, 0xf1, 0x7b, 0xf6, 0x52, 0x88, 0x44, 0xf9, 0x33, 0x6f, 0x97, 0x4d, 0x28, 0x8d, 0x08, 0x09, 0x6d, 0xd3, 0x15, 0xc5, 0x5e, 0x91, 0xfe, 0x34, 0x99, 0x18, 0xd6,
0x23, 0x31, 0xd2, 0xbf, 0x01, 0x78, 0x4e, 0x26, 0x7b, 0x5d, 0xd2, 0xa7, 0x07, 0x0b, 0x93, 0x48, 0x54, 0x8c, 0xfc, 0xbc, 0x18, 0x7b, 0xa0, 0x44, 0x13, 0xbf, 0x67, 0x2f, 0x2d, 0xa4, 0x28, 0x7d,
0x4b, 0x4c, 0x92, 0xbf, 0x38, 0x28, 0x65, 0x86, 0x39, 0x66, 0x41, 0xf9, 0xf0, 0xaf, 0x05, 0x50, 0xe6, 0x13, 0xe5, 0x48, 0xac, 0xf4, 0x6f, 0x00, 0x9e, 0x93, 0xc9, 0x5e, 0x97, 0xf4, 0xe9, 0xc5,
0xa6, 0x5f, 0x34, 0x90, 0x0a, 0xa5, 0xee, 0x49, 0xa3, 0x61, 0x74, 0xbb, 0x5a, 0x0e, 0xed, 0x80, 0x42, 0x71, 0xd2, 0x12, 0xc5, 0xe5, 0x2f, 0x76, 0x5d, 0x99, 0x55, 0x26, 0x33, 0xd7, 0x7d, 0xf8,
0x76, 0xd2, 0x36, 0xbe, 0x3c, 0x36, 0x1a, 0x96, 0xd1, 0xb4, 0x0d, 0x8c, 0x3b, 0x58, 0x93, 0x10, 0x97, 0x02, 0x28, 0xd3, 0xef, 0x1e, 0x48, 0x85, 0x52, 0xf7, 0xa4, 0xd1, 0x30, 0xba, 0x5d, 0x2d,
0x82, 0xcd, 0x46, 0xa7, 0xdd, 0x36, 0x1a, 0x96, 0xbd, 0x5f, 0x33, 0x5b, 0x46, 0x53, 0xcb, 0xa3, 0x87, 0x76, 0x40, 0x3b, 0x69, 0x1b, 0x5f, 0x1e, 0x1b, 0x0d, 0xcb, 0x68, 0xda, 0x06, 0xc6, 0x1d,
0xeb, 0xb0, 0x7d, 0x6c, 0xe0, 0x23, 0xb3, 0xdb, 0x35, 0x3b, 0x6d, 0xbb, 0x69, 0xb4, 0x4d, 0xa3, 0xac, 0x49, 0x08, 0xc1, 0x66, 0xa3, 0xd3, 0x6e, 0x1b, 0x0d, 0xcb, 0xde, 0xaf, 0x99, 0x2d, 0xa3,
0xa9, 0xc9, 0xe8, 0x16, 0x5c, 0x6f, 0x74, 0x5a, 0x2d, 0xa3, 0x61, 0x51, 0x72, 0xbb, 0x63, 0xd9, 0xa9, 0xe5, 0xd1, 0x75, 0xd8, 0x3e, 0x36, 0xf0, 0x91, 0xd9, 0xed, 0x9a, 0x9d, 0xb6, 0xdd, 0x34,
0xc6, 0x97, 0x66, 0xd7, 0xea, 0x6a, 0x05, 0xca, 0xdb, 0x6c, 0xb5, 0x8c, 0x83, 0x5a, 0xcb, 0xae, 0xda, 0xa6, 0xd1, 0xd4, 0x64, 0x74, 0x0b, 0xae, 0x37, 0x3a, 0xad, 0x96, 0xd1, 0xb0, 0x28, 0xb8,
0xe1, 0x83, 0x93, 0x23, 0xa3, 0x6d, 0x69, 0x1b, 0x94, 0x4f, 0x42, 0x6d, 0x9a, 0x47, 0x46, 0x9b, 0xdd, 0xb1, 0x6c, 0xe3, 0x4b, 0xb3, 0x6b, 0x75, 0xb5, 0x02, 0xa5, 0x6d, 0xb6, 0x5a, 0xc6, 0x41,
0xb2, 0xd3, 0x4a, 0xe8, 0x06, 0xa0, 0x84, 0x6c, 0xb6, 0x9b, 0xc6, 0x97, 0xb6, 0xf5, 0xd5, 0xb1, 0xad, 0x65, 0xd7, 0xf0, 0xc1, 0xc9, 0x91, 0xd1, 0xb6, 0xb4, 0x0d, 0x4a, 0x27, 0x81, 0x36, 0xcd,
0xa1, 0x95, 0xd1, 0x1d, 0xb8, 0x99, 0xd0, 0xd3, 0xe7, 0xd4, 0x8e, 0x0c, 0x4d, 0x41, 0x1a, 0x54, 0x23, 0xa3, 0x4d, 0xc9, 0x69, 0x25, 0x74, 0x03, 0x50, 0x02, 0x36, 0xdb, 0x4d, 0xe3, 0x4b, 0xdb,
0x92, 0x49, 0xab, 0x73, 0xfc, 0x5c, 0x83, 0x34, 0x77, 0xdc, 0x79, 0x85, 0x8d, 0x46, 0x07, 0x37, 0xfa, 0xea, 0xd8, 0xd0, 0xca, 0xe8, 0x0e, 0xdc, 0x4c, 0xe0, 0xe9, 0x7b, 0x6a, 0x47, 0x86, 0xa6,
0x35, 0x35, 0x4d, 0x7e, 0x69, 0x34, 0xac, 0x0e, 0xb6, 0xcd, 0xa6, 0x56, 0xa1, 0xc2, 0x27, 0xe4, 0x20, 0x0d, 0x2a, 0xc9, 0xa6, 0xd5, 0x39, 0x7e, 0xae, 0x41, 0x9a, 0x3a, 0xee, 0xbc, 0xc2, 0x46,
0xae, 0x51, 0xc3, 0x8d, 0x43, 0x1b, 0x1b, 0xdd, 0x93, 0x96, 0xa5, 0x55, 0xa9, 0x09, 0xf6, 0xcd, 0xa3, 0x83, 0x9b, 0x9a, 0x9a, 0x06, 0xbf, 0x34, 0x1a, 0x56, 0x07, 0xdb, 0x66, 0x53, 0xab, 0x50,
0x96, 0xc1, 0x34, 0xda, 0xef, 0x9c, 0xb4, 0x9b, 0xda, 0x26, 0xda, 0x02, 0xf5, 0xc8, 0xb0, 0x6a, 0xe6, 0x13, 0x70, 0xd7, 0xa8, 0xe1, 0xc6, 0xa1, 0x8d, 0x8d, 0xee, 0x49, 0xcb, 0xd2, 0xaa, 0x54,
0x89, 0x4d, 0xb6, 0xe8, 0xf9, 0x8d, 0x5a, 0xe3, 0xd0, 0x48, 0x28, 0x1a, 0xda, 0x85, 0x9d, 0x46, 0x05, 0xfb, 0x66, 0xcb, 0x60, 0x12, 0xed, 0x77, 0x4e, 0xda, 0x4d, 0x6d, 0x13, 0x6d, 0x81, 0x7a,
0xad, 0x4d, 0x37, 0x35, 0xb0, 0x51, 0xb3, 0x0c, 0x7b, 0xbf, 0xd3, 0x6a, 0x1a, 0x58, 0xdb, 0xa6, 0x64, 0x58, 0xb5, 0x44, 0x27, 0x5b, 0xf4, 0xfe, 0x46, 0xad, 0x71, 0x68, 0x24, 0x10, 0x0d, 0xed,
0x0a, 0xce, 0xcd, 0x98, 0x2d, 0x43, 0x43, 0xa9, 0x1d, 0x4d, 0xa3, 0x65, 0xcc, 0x76, 0x5c, 0x4b, 0xc2, 0x4e, 0xa3, 0xd6, 0xa6, 0x48, 0x0d, 0x6c, 0xd4, 0x2c, 0xc3, 0xde, 0xef, 0xb4, 0x9a, 0x06,
0xed, 0x48, 0x66, 0xe8, 0x8e, 0x1d, 0xaa, 0x4c, 0xfd, 0xc4, 0x6c, 0x35, 0x85, 0xa1, 0xb8, 0xd3, 0xd6, 0xb6, 0xa9, 0x80, 0x73, 0x3b, 0x66, 0xcb, 0xd0, 0x50, 0x0a, 0xa3, 0x69, 0xb4, 0x8c, 0x19,
0xae, 0xa3, 0x6d, 0xa8, 0x26, 0xca, 0xb4, 0x5b, 0x66, 0xd7, 0xd2, 0x6e, 0xa0, 0x9b, 0x70, 0x2d, 0xc6, 0xb5, 0x14, 0x46, 0xb2, 0x43, 0x31, 0x76, 0xa8, 0x30, 0xf5, 0x13, 0xb3, 0xd5, 0x14, 0x8a,
0x21, 0x1d, 0x19, 0x16, 0x36, 0x1b, 0xdc, 0xaa, 0x37, 0xe9, 0xda, 0xce, 0x89, 0x65, 0x77, 0xf6, 0xe2, 0x46, 0xbb, 0x8e, 0xb6, 0xa1, 0x9a, 0x08, 0xd3, 0x6e, 0x99, 0x5d, 0x4b, 0xbb, 0x81, 0x6e,
0xed, 0x23, 0xe3, 0xa8, 0x83, 0xbf, 0xd2, 0x76, 0x1f, 0xfe, 0x51, 0x82, 0x72, 0x82, 0xdd, 0x51, 0xc2, 0xb5, 0x04, 0x74, 0x64, 0x58, 0xd8, 0x6c, 0x70, 0xad, 0xde, 0xa4, 0x67, 0x3b, 0x27, 0x96,
0x19, 0x0a, 0xed, 0x4e, 0xdb, 0xd0, 0x72, 0x74, 0x54, 0xef, 0x74, 0x5a, 0x9a, 0x44, 0x47, 0x66, 0xdd, 0xd9, 0xb7, 0x8f, 0x8c, 0xa3, 0x0e, 0xfe, 0x4a, 0xdb, 0x7d, 0xf8, 0x47, 0x09, 0xca, 0x49,
0xdb, 0x7a, 0xaa, 0xe5, 0x91, 0x02, 0x1b, 0x66, 0xdb, 0xfa, 0xe8, 0xb1, 0x26, 0x8b, 0xe1, 0xc7, 0x85, 0x8f, 0xca, 0x50, 0x68, 0x77, 0xda, 0x86, 0x96, 0xa3, 0xab, 0x7a, 0xa7, 0xd3, 0xd2, 0x24,
0x7b, 0x5a, 0x41, 0x0c, 0x1f, 0x7f, 0xa2, 0x6d, 0xd0, 0xe1, 0x7e, 0xab, 0x53, 0xb3, 0x34, 0x40, 0xba, 0x32, 0xdb, 0xd6, 0x53, 0x2d, 0x8f, 0x14, 0xd8, 0x30, 0xdb, 0xd6, 0x47, 0x8f, 0x35, 0x59,
0x00, 0xc5, 0x66, 0xe7, 0xa4, 0xde, 0x32, 0x34, 0x95, 0x8e, 0xbb, 0x16, 0x36, 0xdb, 0x07, 0xda, 0x2c, 0x3f, 0xde, 0xd3, 0x0a, 0x62, 0xf9, 0xf8, 0x13, 0x6d, 0x83, 0x2e, 0xf7, 0x5b, 0x9d, 0x9a,
0x0e, 0x95, 0x40, 0x78, 0xa2, 0x6e, 0xb6, 0x6b, 0xf8, 0x2b, 0xcd, 0xa5, 0xd6, 0x14, 0x24, 0xbe, 0xa5, 0x01, 0x02, 0x28, 0x36, 0x3b, 0x27, 0xf5, 0x96, 0xa1, 0xa9, 0x74, 0xdd, 0xb5, 0xb0, 0xd9,
0x99, 0x3c, 0x6c, 0xc0, 0xd6, 0x1c, 0xda, 0x44, 0x45, 0xc8, 0xb7, 0x2c, 0x2d, 0x87, 0x4a, 0x20, 0x3e, 0xd0, 0x76, 0x28, 0x07, 0xc2, 0x12, 0x75, 0xb3, 0x5d, 0xc3, 0x5f, 0x69, 0x2e, 0xd5, 0xa6,
0xb7, 0x2c, 0x43, 0x93, 0x28, 0xc1, 0x78, 0xa1, 0xe5, 0xe9, 0xdf, 0x03, 0x4b, 0x93, 0xe9, 0xc4, 0x00, 0x71, 0x64, 0xf2, 0xb0, 0x01, 0x5b, 0x73, 0x35, 0x29, 0x2a, 0x42, 0xbe, 0x65, 0x69, 0x39,
0x81, 0x65, 0x68, 0x05, 0x4a, 0x68, 0x1b, 0xda, 0xc6, 0xc3, 0xa7, 0xb0, 0xc1, 0x10, 0x0c, 0x0d, 0x54, 0x02, 0xb9, 0x65, 0x19, 0x9a, 0x44, 0x01, 0xc6, 0x0b, 0x2d, 0x4f, 0xff, 0x1e, 0x58, 0x9a,
0x7c, 0xb3, 0xfd, 0xb2, 0xd6, 0x32, 0x9b, 0x5c, 0xaf, 0xa3, 0x93, 0xae, 0xa5, 0x49, 0x4c, 0xaa, 0x4c, 0x37, 0x0e, 0x2c, 0x43, 0x2b, 0x50, 0x40, 0xdb, 0xd0, 0x36, 0x1e, 0x3e, 0x85, 0x0d, 0x56,
0xc3, 0xce, 0x49, 0x8b, 0x06, 0x79, 0x05, 0xca, 0x94, 0x4a, 0xbd, 0xae, 0xc9, 0x0f, 0xef, 0x43, 0xe7, 0x50, 0xc7, 0x37, 0xdb, 0x2f, 0x6b, 0x2d, 0xb3, 0xc9, 0xe5, 0x3a, 0x3a, 0xe9, 0x5a, 0x9a,
0x91, 0x97, 0x65, 0xba, 0xc6, 0x6c, 0x77, 0x0d, 0x4c, 0x4f, 0xa6, 0x1a, 0x31, 0x7f, 0x68, 0xd2, 0xc4, 0xb8, 0x3a, 0xec, 0x9c, 0xb4, 0xa8, 0x93, 0x57, 0xa0, 0x4c, 0xa1, 0xd4, 0xea, 0x9a, 0xfc,
0xc3, 0x7b, 0x50, 0x4e, 0x92, 0x99, 0x72, 0xc4, 0x46, 0x8d, 0xf2, 0x56, 0x60, 0xe3, 0x15, 0x36, 0xf0, 0x3e, 0x14, 0x79, 0xf2, 0xa6, 0x67, 0xcc, 0x76, 0xd7, 0xc0, 0xf4, 0x66, 0x2a, 0x11, 0xb3,
0xe9, 0x82, 0xbd, 0xef, 0xab, 0x50, 0x3d, 0x62, 0xa9, 0xdf, 0x25, 0xe1, 0x5b, 0xaf, 0x47, 0xd0, 0x87, 0x26, 0x3d, 0xbc, 0x07, 0xe5, 0x24, 0x98, 0x29, 0x45, 0x6c, 0xd4, 0x28, 0x6d, 0x05, 0x36,
0x2f, 0x40, 0x6b, 0x84, 0xc4, 0x89, 0xc9, 0xac, 0xcf, 0x46, 0x0b, 0x3f, 0xf6, 0xdc, 0x5e, 0xd4, 0x5e, 0x61, 0x93, 0x1e, 0xd8, 0xfb, 0xbe, 0x0a, 0xd5, 0x23, 0x16, 0xfa, 0x5d, 0x12, 0xbe, 0xf5,
0x69, 0xeb, 0x39, 0xb4, 0x0f, 0xd5, 0x43, 0x27, 0x4a, 0xed, 0xbe, 0x33, 0x87, 0x8e, 0xd3, 0xa5, 0x7a, 0x04, 0xfd, 0x02, 0xb4, 0x46, 0x48, 0x9c, 0x98, 0xcc, 0xba, 0x71, 0xb4, 0xf0, 0x93, 0xd0,
0xfb, 0xf6, 0x8d, 0x73, 0x38, 0x8a, 0xbf, 0x25, 0xe5, 0x90, 0x09, 0xa8, 0x49, 0xa2, 0x5e, 0xe8, 0xed, 0x45, 0xfd, 0xb8, 0x9e, 0x43, 0xfb, 0x50, 0x3d, 0x74, 0xa2, 0x14, 0xf6, 0x9d, 0xb9, 0x1a,
0x9d, 0x92, 0x55, 0x99, 0x2d, 0x94, 0x53, 0xcf, 0xa1, 0x17, 0xd4, 0x4f, 0x63, 0x3f, 0x5e, 0x95, 0x3a, 0x9d, 0xe0, 0x6f, 0xdf, 0x38, 0x57, 0x6d, 0xf1, 0x89, 0x53, 0x0e, 0x99, 0x80, 0x9a, 0x24,
0xcf, 0xbd, 0x25, 0x93, 0xd3, 0x47, 0xa7, 0x1c, 0xfa, 0x25, 0x6c, 0x75, 0xdf, 0xd0, 0x9f, 0xc9, 0xea, 0x85, 0xde, 0x29, 0x59, 0x95, 0xd8, 0x42, 0x3e, 0xf5, 0x1c, 0x7a, 0x41, 0xed, 0x34, 0xf6,
0x5c, 0x34, 0x67, 0x25, 0xf1, 0x28, 0xb5, 0x94, 0x57, 0xf2, 0x55, 0x54, 0xcf, 0xa1, 0x63, 0x40, 0xe3, 0x55, 0xe9, 0xdc, 0x5b, 0xb2, 0x39, 0x1d, 0x4d, 0xe5, 0xd0, 0x2f, 0x61, 0xab, 0xfb, 0x86,
0x59, 0x5e, 0xec, 0x61, 0xe3, 0x42, 0x09, 0x97, 0x4d, 0xb2, 0x87, 0x8c, 0x1c, 0x6a, 0xc2, 0x66, 0xfe, 0x4c, 0xf6, 0xa2, 0x39, 0x2d, 0x89, 0xd1, 0xd5, 0x52, 0x5a, 0xc9, 0xb7, 0x53, 0x3d, 0x87,
0x33, 0x0c, 0x46, 0xab, 0xea, 0xbb, 0xc4, 0x93, 0x9f, 0x81, 0xca, 0x43, 0x81, 0x3d, 0xa1, 0xa1, 0x8e, 0x01, 0x65, 0x69, 0xb1, 0xf1, 0xc7, 0x85, 0x1c, 0x2e, 0xdb, 0x64, 0xe3, 0x8e, 0x1c, 0x6a,
0x2c, 0xf2, 0x9c, 0x3d, 0xab, 0x2d, 0xdb, 0xde, 0x80, 0x6a, 0xe2, 0xc0, 0x4b, 0x18, 0x2c, 0x9b, 0xc2, 0x66, 0x33, 0x0c, 0x46, 0xab, 0xca, 0xbb, 0xc4, 0x92, 0x9f, 0x81, 0xca, 0x5d, 0x81, 0x0d,
0xd0, 0x73, 0xe8, 0x19, 0x28, 0x54, 0x93, 0x1f, 0x26, 0x81, 0x01, 0x5b, 0x5c, 0x81, 0xe9, 0xa7, 0xda, 0x50, 0xb6, 0x3e, 0x9d, 0x0d, 0xdf, 0x96, 0xa1, 0x37, 0xa0, 0x9a, 0x18, 0xf0, 0x12, 0x02,
0xc3, 0x39, 0x3b, 0x64, 0xbf, 0x4f, 0x2e, 0x67, 0x53, 0x39, 0x74, 0xa2, 0x15, 0x79, 0x2c, 0x0f, 0xcb, 0x36, 0xf4, 0x1c, 0x7a, 0x06, 0x0a, 0x95, 0xe4, 0x87, 0x71, 0x60, 0xc0, 0x16, 0x17, 0x60,
0xe8, 0xe7, 0xb0, 0x49, 0xdd, 0x3c, 0x5d, 0x1f, 0x5d, 0xec, 0x94, 0xdb, 0x8b, 0x4f, 0x11, 0x31, 0xfa, 0x81, 0x71, 0x4e, 0x0f, 0xd9, 0xaf, 0x98, 0xcb, 0xc9, 0x54, 0x0e, 0x9d, 0x68, 0x45, 0x1a,
0x43, 0x8d, 0x1b, 0x06, 0xa3, 0xab, 0x29, 0xf6, 0x29, 0x14, 0x39, 0xe4, 0x45, 0xbb, 0x73, 0x96, 0xcb, 0x1d, 0xfa, 0x39, 0x6c, 0x52, 0x33, 0x4f, 0xcf, 0x47, 0x17, 0x1b, 0xe5, 0xf6, 0xe2, 0x5b,
0x9d, 0x7e, 0xd5, 0x9a, 0xd3, 0x67, 0xfa, 0x09, 0x93, 0x99, 0xa5, 0x3a, 0x7d, 0x2f, 0xab, 0x4f, 0x84, 0xcf, 0x50, 0xe5, 0x86, 0xc1, 0xe8, 0x6a, 0x82, 0x7d, 0x0a, 0x45, 0x5e, 0x18, 0xa3, 0xdd,
0xcc, 0xe6, 0x9c, 0x08, 0xd9, 0xe7, 0xae, 0xdb, 0x8b, 0x9f, 0xee, 0xf5, 0x1c, 0x3a, 0xa4, 0x0d, 0x39, 0xcd, 0x4e, 0xbf, 0x7d, 0xcd, 0xc9, 0x33, 0xfd, 0xd0, 0xc9, 0xd4, 0x52, 0x9d, 0x4e, 0xd5,
0xd7, 0xec, 0xd9, 0x0d, 0xfd, 0xdf, 0x1c, 0xde, 0x9f, 0x7b, 0x91, 0xbb, 0x40, 0xa0, 0xcf, 0xa1, 0xea, 0x13, 0xb3, 0x39, 0xc7, 0x42, 0x76, 0x28, 0x76, 0x7b, 0xf1, 0x80, 0x5f, 0xcf, 0xa1, 0x43,
0xc8, 0xc1, 0x23, 0x5a, 0xfa, 0xe5, 0xe4, 0x76, 0x76, 0x26, 0xf5, 0x69, 0x82, 0xe5, 0xe1, 0xd6, 0xda, 0x96, 0xcd, 0x86, 0x73, 0xe8, 0xff, 0xe6, 0xba, 0x82, 0xb9, 0xb9, 0xdd, 0x05, 0x0c, 0x7d,
0xdc, 0x17, 0x1c, 0xf4, 0xfe, 0x02, 0x46, 0xd9, 0xef, 0x3b, 0x17, 0x72, 0x7c, 0x02, 0x72, 0x63, 0x0e, 0x45, 0x5e, 0x62, 0xa2, 0xa5, 0xdf, 0x57, 0x6e, 0x67, 0x77, 0x52, 0x1f, 0x30, 0x58, 0x1c,
0xe8, 0x2e, 0xa9, 0x0c, 0x73, 0x42, 0xa6, 0x5e, 0xe8, 0x73, 0xa8, 0x06, 0x30, 0x7b, 0x3e, 0x45, 0x6e, 0xcd, 0x7d, 0xe7, 0x41, 0xef, 0x2f, 0x20, 0x94, 0xfd, 0x0a, 0x74, 0x21, 0xc5, 0x27, 0x20,
0x59, 0x38, 0x3b, 0xf7, 0xae, 0xba, 0xcc, 0xb9, 0x07, 0xb0, 0x7d, 0x1c, 0x92, 0x41, 0xe0, 0xb8, 0x37, 0x86, 0xee, 0x92, 0xcc, 0x30, 0xc7, 0x64, 0x6a, 0x8e, 0x9f, 0x43, 0x35, 0x80, 0xd9, 0x90,
0x57, 0x2c, 0x03, 0x4f, 0x60, 0x83, 0xbd, 0x31, 0xcf, 0xa5, 0xdf, 0xec, 0xdd, 0x79, 0xd9, 0xc6, 0x15, 0x65, 0x8b, 0xde, 0xb9, 0xe9, 0xeb, 0x32, 0xe3, 0x1e, 0xc0, 0xf6, 0x71, 0x48, 0x06, 0x81,
0x67, 0xec, 0x69, 0x7e, 0xe4, 0xf4, 0x62, 0x74, 0xeb, 0xfc, 0x0b, 0x89, 0x78, 0x70, 0x5e, 0xb6, 0xe3, 0x5e, 0x31, 0x0d, 0x3c, 0x81, 0x0d, 0x36, 0x89, 0x9e, 0x0b, 0xbf, 0xd9, 0x74, 0x7a, 0x19,
0xb9, 0x0e, 0x65, 0xe1, 0xb7, 0x3a, 0xba, 0xbd, 0xcc, 0x9d, 0xc7, 0xf5, 0x8b, 0xcc, 0x5f, 0x2f, 0xe2, 0x33, 0x36, 0xc0, 0x1f, 0x39, 0xbd, 0x18, 0xdd, 0x3a, 0x3f, 0x47, 0x11, 0x63, 0xe9, 0x65,
0x7d, 0xbd, 0x31, 0x8c, 0xfa, 0xa3, 0xd3, 0xd3, 0x22, 0xfb, 0x7f, 0x9b, 0x8f, 0xff, 0x13, 0x00, 0xc8, 0x75, 0x28, 0x0b, 0xbb, 0xd5, 0xd1, 0xed, 0x65, 0xe6, 0x3c, 0xae, 0x5f, 0xa4, 0xfe, 0x7a,
0x00, 0xff, 0xff, 0xaf, 0xd6, 0x20, 0xc1, 0x80, 0x23, 0x00, 0x00, 0xe9, 0xeb, 0x8d, 0x61, 0xd4, 0x1f, 0x9d, 0x9e, 0x16, 0xd9, 0x7f, 0xe5, 0x7c, 0xfc, 0x9f, 0x00,
0x00, 0x00, 0xff, 0xff, 0x80, 0xe4, 0x76, 0xae, 0xa6, 0x23, 0x00, 0x00,
} }

4
proto/message.proto
View File

@ -691,11 +691,13 @@ message InsertOrDeleteMsg {
message SearchMsg { message SearchMsg {
string collection_name = 1; string collection_name = 1;
VectorRowRecord records = 2; VectorRowRecord records = 2;
string partition_tag = 3; repeated string partition_tag = 3;
int64 uid = 4; int64 uid = 4;
uint64 timestamp =5; uint64 timestamp =5;
int64 client_id = 6; int64 client_id = 6;
repeated KeyValuePair extra_params = 7; repeated KeyValuePair extra_params = 7;
repeated string json = 8;
string dsl = 9;
} }
enum SyncType { enum SyncType {

1093
proxy/src/grpc/gen-milvus/milvus.grpc.pb.cc
View File

File diff suppressed because it is too large Load Diff

4559
proxy/src/grpc/gen-milvus/milvus.grpc.pb.h
View File

File diff suppressed because it is too large Load Diff

16962
proxy/src/grpc/gen-milvus/milvus.pb.cc
View File

File diff suppressed because it is too large Load Diff

11538
proxy/src/grpc/gen-milvus/milvus.pb.h
View File

File diff suppressed because it is too large Load Diff

413
proxy/src/grpc/message.pb.cc
View File

@ -1290,6 +1290,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_message_2eproto::offsets[] PRO
PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, timestamp_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, timestamp_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, client_id_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, client_id_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, extra_params_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, extra_params_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, json_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchMsg, dsl_),
~0u, // no _has_bits_ ~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, _internal_metadata_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, _internal_metadata_),
~0u, // no _extensions_ ~0u, // no _extensions_
@ -1304,6 +1306,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_message_2eproto::offsets[] PRO
~0u, // no _oneof_case_ ~0u, // no _oneof_case_
~0u, // no _weak_field_map_ ~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, uid_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, uid_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, timestamp_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, segment_id_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, segment_id_),
}; };
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
@ -1352,8 +1355,8 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB
{ 324, -1, sizeof(::milvus::grpc::SearchParamPB)}, { 324, -1, sizeof(::milvus::grpc::SearchParamPB)},
{ 333, -1, sizeof(::milvus::grpc::InsertOrDeleteMsg)}, { 333, -1, sizeof(::milvus::grpc::InsertOrDeleteMsg)},
{ 348, -1, sizeof(::milvus::grpc::SearchMsg)}, { 348, -1, sizeof(::milvus::grpc::SearchMsg)},
{ 360, -1, sizeof(::milvus::grpc::TimeSyncMsg)}, { 362, -1, sizeof(::milvus::grpc::TimeSyncMsg)},
{ 368, -1, sizeof(::milvus::grpc::Key2SegMsg)}, { 370, -1, sizeof(::milvus::grpc::Key2SegMsg)},
}; };
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
@ -1520,82 +1523,83 @@ const char descriptor_table_protodef_message_2eproto[] PROTOBUF_SECTION_VARIABLE
"\nsegment_id\030\006 \001(\003\022\022\n\nchannel_id\030\007 \001(\003\022\037\n" "\nsegment_id\030\006 \001(\003\022\022\n\nchannel_id\030\007 \001(\003\022\037\n"
"\002op\030\010 \001(\0162\023.milvus.grpc.OpType\022\021\n\tclient" "\002op\030\010 \001(\0162\023.milvus.grpc.OpType\022\021\n\tclient"
"_id\030\t \001(\003\022/\n\014extra_params\030\n \003(\0132\031.milvus" "_id\030\t \001(\003\022/\n\014extra_params\030\n \003(\0132\031.milvus"
".grpc.KeyValuePair\"\316\001\n\tSearchMsg\022\027\n\017coll" ".grpc.KeyValuePair\"\351\001\n\tSearchMsg\022\027\n\017coll"
"ection_name\030\001 \001(\t\022-\n\007records\030\002 \001(\0132\034.mil" "ection_name\030\001 \001(\t\022-\n\007records\030\002 \001(\0132\034.mil"
"vus.grpc.VectorRowRecord\022\025\n\rpartition_ta" "vus.grpc.VectorRowRecord\022\025\n\rpartition_ta"
"g\030\003 \001(\t\022\013\n\003uid\030\004 \001(\003\022\021\n\ttimestamp\030\005 \001(\004\022" "g\030\003 \003(\t\022\013\n\003uid\030\004 \001(\003\022\021\n\ttimestamp\030\005 \001(\004\022"
"\021\n\tclient_id\030\006 \001(\003\022/\n\014extra_params\030\007 \003(\013" "\021\n\tclient_id\030\006 \001(\003\022/\n\014extra_params\030\007 \003(\013"
"2\031.milvus.grpc.KeyValuePair\"[\n\013TimeSyncM" "2\031.milvus.grpc.KeyValuePair\022\014\n\004json\030\010 \003("
"sg\022\017\n\007peer_Id\030\001 \001(\003\022\021\n\tTimestamp\030\002 \001(\004\022(" "\t\022\013\n\003dsl\030\t \001(\t\"[\n\013TimeSyncMsg\022\017\n\007peer_Id"
"\n\tsync_type\030\003 \001(\0162\025.milvus.grpc.SyncType" "\030\001 \001(\003\022\021\n\tTimestamp\030\002 \001(\004\022(\n\tsync_type\030\003"
"\"-\n\nKey2SegMsg\022\013\n\003uid\030\001 \001(\003\022\022\n\nsegment_i" " \001(\0162\025.milvus.grpc.SyncType\"@\n\nKey2SegMs"
"d\030\002 \003(\003*\242\004\n\tErrorCode\022\013\n\007SUCCESS\020\000\022\024\n\020UN" "g\022\013\n\003uid\030\001 \001(\003\022\021\n\ttimestamp\030\002 \001(\004\022\022\n\nseg"
"EXPECTED_ERROR\020\001\022\022\n\016CONNECT_FAILED\020\002\022\025\n\021" "ment_id\030\003 \003(\003*\242\004\n\tErrorCode\022\013\n\007SUCCESS\020\000"
"PERMISSION_DENIED\020\003\022\031\n\025COLLECTION_NOT_EX" "\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FAILED"
"ISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021ILLEGAL_" "\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\031\n\025COLLECTION_"
"DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020\010\022\033\n\027I" "NOT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021IL"
"LLEGAL_COLLECTION_NAME\020\t\022\020\n\014ILLEGAL_TOPK" "LEGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020"
"\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEGAL_VEC" "\010\022\033\n\027ILLEGAL_COLLECTION_NAME\020\t\022\020\n\014ILLEGA"
"TOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020\r\022\022\n\016F" "L_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEG"
"ILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020\n\014CACH" "AL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020"
"E_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER\020\021\022\026\n\022" "\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020"
"CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DELETE_FO" "\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER"
"LDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021BUILD_" "\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DEL"
"INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027\n\023ILLE" "ETE_FOLDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021"
"GAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY\020\030*\221\001\n" "BUILD_INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027"
"\010DataType\022\010\n\004NONE\020\000\022\010\n\004BOOL\020\001\022\010\n\004INT8\020\002\022" "\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY"
"\t\n\005INT16\020\003\022\t\n\005INT32\020\004\022\t\n\005INT64\020\005\022\t\n\005FLOA" "\020\030*\221\001\n\010DataType\022\010\n\004NONE\020\000\022\010\n\004BOOL\020\001\022\010\n\004I"
"T\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006STRING\020\024\022\021\n\rVECTOR_BI" "NT8\020\002\022\t\n\005INT16\020\003\022\t\n\005INT32\020\004\022\t\n\005INT64\020\005\022\t"
"NARY\020d\022\020\n\014VECTOR_FLOAT\020e*C\n\017CompareOpera" "\n\005FLOAT\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006STRING\020\024\022\021\n\rVEC"
"tor\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002GT\020\003\022\007\n\003" "TOR_BINARY\020d\022\020\n\014VECTOR_FLOAT\020e*C\n\017Compar"
"GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020\000\022\010\n\004M" "eOperator\022\006\n\002LT\020\000\022\007\n\003LTE\020\001\022\006\n\002EQ\020\002\022\006\n\002GT"
"UST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\003* \n\006OpTyp" "\020\003\022\007\n\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020"
"e\022\n\n\006INSERT\020\000\022\n\n\006DELETE\020\001*\037\n\010SyncType\022\010\n" "\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\003* \n"
"\004READ\020\000\022\t\n\005WRITE\020\0012\333\r\n\rMilvusService\022\?\n\020" "\006OpType\022\n\n\006INSERT\020\000\022\n\n\006DELETE\020\001*\037\n\010SyncT"
"CreateCollection\022\024.milvus.grpc.Mapping\032\023" "ype\022\010\n\004READ\020\000\022\t\n\005WRITE\020\0012\333\r\n\rMilvusServi"
".milvus.grpc.Status\"\000\022F\n\rHasCollection\022\033" "ce\022\?\n\020CreateCollection\022\024.milvus.grpc.Map"
".milvus.grpc.CollectionName\032\026.milvus.grp" "ping\032\023.milvus.grpc.Status\"\000\022F\n\rHasCollec"
"c.BoolReply\"\000\022I\n\022DescribeCollection\022\033.mi" "tion\022\033.milvus.grpc.CollectionName\032\026.milv"
"lvus.grpc.CollectionName\032\024.milvus.grpc.M" "us.grpc.BoolReply\"\000\022I\n\022DescribeCollectio"
"apping\"\000\022Q\n\017CountCollection\022\033.milvus.grp" "n\022\033.milvus.grpc.CollectionName\032\024.milvus."
"c.CollectionName\032\037.milvus.grpc.Collectio" "grpc.Mapping\"\000\022Q\n\017CountCollection\022\033.milv"
"nRowCount\"\000\022J\n\017ShowCollections\022\024.milvus." "us.grpc.CollectionName\032\037.milvus.grpc.Col"
"grpc.Command\032\037.milvus.grpc.CollectionNam" "lectionRowCount\"\000\022J\n\017ShowCollections\022\024.m"
"eList\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.g" "ilvus.grpc.Command\032\037.milvus.grpc.Collect"
"rpc.CollectionName\032\033.milvus.grpc.Collect" "ionNameList\"\000\022P\n\022ShowCollectionInfo\022\033.mi"
"ionInfo\"\000\022D\n\016DropCollection\022\033.milvus.grp" "lvus.grpc.CollectionName\032\033.milvus.grpc.C"
"c.CollectionName\032\023.milvus.grpc.Status\"\000\022" "ollectionInfo\"\000\022D\n\016DropCollection\022\033.milv"
"=\n\013CreateIndex\022\027.milvus.grpc.IndexParam\032" "us.grpc.CollectionName\032\023.milvus.grpc.Sta"
"\023.milvus.grpc.Status\"\000\022C\n\rDescribeIndex\022" "tus\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.Index"
"\027.milvus.grpc.IndexParam\032\027.milvus.grpc.I" "Param\032\023.milvus.grpc.Status\"\000\022C\n\rDescribe"
"ndexParam\"\000\022;\n\tDropIndex\022\027.milvus.grpc.I" "Index\022\027.milvus.grpc.IndexParam\032\027.milvus."
"ndexParam\032\023.milvus.grpc.Status\"\000\022E\n\017Crea" "grpc.IndexParam\"\000\022;\n\tDropIndex\022\027.milvus."
"tePartition\022\033.milvus.grpc.PartitionParam" "grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022E"
"\032\023.milvus.grpc.Status\"\000\022E\n\014HasPartition\022" "\n\017CreatePartition\022\033.milvus.grpc.Partitio"
"\033.milvus.grpc.PartitionParam\032\026.milvus.gr" "nParam\032\023.milvus.grpc.Status\"\000\022E\n\014HasPart"
"pc.BoolReply\"\000\022K\n\016ShowPartitions\022\033.milvu" "ition\022\033.milvus.grpc.PartitionParam\032\026.mil"
"s.grpc.CollectionName\032\032.milvus.grpc.Part" "vus.grpc.BoolReply\"\000\022K\n\016ShowPartitions\022\033"
"itionList\"\000\022C\n\rDropPartition\022\033.milvus.gr" ".milvus.grpc.CollectionName\032\032.milvus.grp"
"pc.PartitionParam\032\023.milvus.grpc.Status\"\000" "c.PartitionList\"\000\022C\n\rDropPartition\022\033.mil"
"\022<\n\006Insert\022\030.milvus.grpc.InsertParam\032\026.m" "vus.grpc.PartitionParam\032\023.milvus.grpc.St"
"ilvus.grpc.EntityIds\"\000\022E\n\rGetEntityByID\022" "atus\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertPar"
"\033.milvus.grpc.EntityIdentity\032\025.milvus.gr" "am\032\026.milvus.grpc.EntityIds\"\000\022E\n\rGetEntit"
"pc.Entities\"\000\022H\n\014GetEntityIDs\022\036.milvus.g" "yByID\022\033.milvus.grpc.EntityIdentity\032\025.mil"
"rpc.GetEntityIDsParam\032\026.milvus.grpc.Enti" "vus.grpc.Entities\"\000\022H\n\014GetEntityIDs\022\036.mi"
"tyIds\"\000\022>\n\006Search\022\030.milvus.grpc.SearchPa" "lvus.grpc.GetEntityIDsParam\032\026.milvus.grp"
"ram\032\030.milvus.grpc.QueryResult\"\000\022P\n\017Searc" "c.EntityIds\"\000\022>\n\006Search\022\030.milvus.grpc.Se"
"hInSegment\022!.milvus.grpc.SearchInSegment" "archParam\032\030.milvus.grpc.QueryResult\"\000\022P\n"
"Param\032\030.milvus.grpc.QueryResult\"\000\0227\n\003Cmd" "\017SearchInSegment\022!.milvus.grpc.SearchInS"
"\022\024.milvus.grpc.Command\032\030.milvus.grpc.Str" "egmentParam\032\030.milvus.grpc.QueryResult\"\000\022"
"ingReply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.D" "7\n\003Cmd\022\024.milvus.grpc.Command\032\030.milvus.gr"
"eleteByIDParam\032\023.milvus.grpc.Status\"\000\022G\n" "pc.StringReply\"\000\022A\n\nDeleteByID\022\034.milvus."
"\021PreloadCollection\022\033.milvus.grpc.Collect" "grpc.DeleteByIDParam\032\023.milvus.grpc.Statu"
"ionName\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022" "s\"\000\022G\n\021PreloadCollection\022\033.milvus.grpc.C"
"\027.milvus.grpc.FlushParam\032\023.milvus.grpc.S" "ollectionName\032\023.milvus.grpc.Status\"\000\0227\n\005"
"tatus\"\000\022;\n\007Compact\022\031.milvus.grpc.Compact" "Flush\022\027.milvus.grpc.FlushParam\032\023.milvus."
"Param\032\023.milvus.grpc.Status\"\000\022B\n\010SearchPB" "grpc.Status\"\000\022;\n\007Compact\022\031.milvus.grpc.C"
"\022\032.milvus.grpc.SearchParamPB\032\030.milvus.gr" "ompactParam\032\023.milvus.grpc.Status\"\000\022B\n\010Se"
"pc.QueryResult\"\000B\007Z\005msgpbb\006proto3" "archPB\022\032.milvus.grpc.SearchParamPB\032\030.mil"
"vus.grpc.QueryResult\"\000B\007Z\005msgpbb\006proto3"
; ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_message_2eproto_deps[1] = { static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_message_2eproto_deps[1] = {
}; };
@ -1650,7 +1654,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mes
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_message_2eproto_once; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_message_2eproto_once;
static bool descriptor_table_message_2eproto_initialized = false; static bool descriptor_table_message_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto = { const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_message_2eproto = {
&descriptor_table_message_2eproto_initialized, descriptor_table_protodef_message_2eproto, "message.proto", 7553, &descriptor_table_message_2eproto_initialized, descriptor_table_protodef_message_2eproto, "message.proto", 7599,
&descriptor_table_message_2eproto_once, descriptor_table_message_2eproto_sccs, descriptor_table_message_2eproto_deps, 46, 0, &descriptor_table_message_2eproto_once, descriptor_table_message_2eproto_sccs, descriptor_table_message_2eproto_deps, 46, 0,
schemas, file_default_instances, TableStruct_message_2eproto::offsets, schemas, file_default_instances, TableStruct_message_2eproto::offsets,
file_level_metadata_message_2eproto, 47, file_level_enum_descriptors_message_2eproto, file_level_service_descriptors_message_2eproto, file_level_metadata_message_2eproto, 47, file_level_enum_descriptors_message_2eproto, file_level_service_descriptors_message_2eproto,
@ -18199,15 +18203,17 @@ SearchMsg::SearchMsg()
SearchMsg::SearchMsg(const SearchMsg& from) SearchMsg::SearchMsg(const SearchMsg& from)
: ::PROTOBUF_NAMESPACE_ID::Message(), : ::PROTOBUF_NAMESPACE_ID::Message(),
_internal_metadata_(nullptr), _internal_metadata_(nullptr),
extra_params_(from.extra_params_) { partition_tag_(from.partition_tag_),
extra_params_(from.extra_params_),
json_(from.json_) {
_internal_metadata_.MergeFrom(from._internal_metadata_); _internal_metadata_.MergeFrom(from._internal_metadata_);
collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.collection_name().empty()) { if (!from.collection_name().empty()) {
collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_);
} }
partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.partition_tag().empty()) { if (!from.dsl().empty()) {
partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_);
} }
if (from.has_records()) { if (from.has_records()) {
records_ = new ::milvus::grpc::VectorRowRecord(*from.records_); records_ = new ::milvus::grpc::VectorRowRecord(*from.records_);
@ -18223,7 +18229,7 @@ SearchMsg::SearchMsg(const SearchMsg& from)
void SearchMsg::SharedCtor() { void SearchMsg::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchMsg_message_2eproto.base); ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchMsg_message_2eproto.base);
collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(&records_, 0, static_cast<size_t>( ::memset(&records_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&client_id_) - reinterpret_cast<char*>(&client_id_) -
reinterpret_cast<char*>(&records_)) + sizeof(client_id_)); reinterpret_cast<char*>(&records_)) + sizeof(client_id_));
@ -18236,7 +18242,7 @@ SearchMsg::~SearchMsg() {
void SearchMsg::SharedDtor() { void SearchMsg::SharedDtor() {
collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); dsl_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (this != internal_default_instance()) delete records_; if (this != internal_default_instance()) delete records_;
} }
@ -18255,9 +18261,11 @@ void SearchMsg::Clear() {
// Prevent compiler warnings about cached_has_bits being unused // Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits; (void) cached_has_bits;
partition_tag_.Clear();
extra_params_.Clear(); extra_params_.Clear();
json_.Clear();
collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (GetArenaNoVirtual() == nullptr && records_ != nullptr) { if (GetArenaNoVirtual() == nullptr && records_ != nullptr) {
delete records_; delete records_;
} }
@ -18290,11 +18298,16 @@ const char* SearchMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::
CHK_(ptr); CHK_(ptr);
} else goto handle_unusual; } else goto handle_unusual;
continue; continue;
// string partition_tag = 3; // repeated string partition_tag = 3;
case 3: case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_partition_tag(), ptr, ctx, "milvus.grpc.SearchMsg.partition_tag"); ptr -= 1;
CHK_(ptr); do {
ptr += 1;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_partition_tag(), ptr, ctx, "milvus.grpc.SearchMsg.partition_tag");
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
} else goto handle_unusual; } else goto handle_unusual;
continue; continue;
// int64 uid = 4; // int64 uid = 4;
@ -18330,6 +18343,25 @@ const char* SearchMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::
} while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58); } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 58);
} else goto handle_unusual; } else goto handle_unusual;
continue; continue;
// repeated string json = 8;
case 8:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
ptr -= 1;
do {
ptr += 1;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_json(), ptr, ctx, "milvus.grpc.SearchMsg.json");
CHK_(ptr);
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 66);
} else goto handle_unusual;
continue;
// string dsl = 9;
case 9:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_dsl(), ptr, ctx, "milvus.grpc.SearchMsg.dsl");
CHK_(ptr);
} else goto handle_unusual;
continue;
default: { default: {
handle_unusual: handle_unusual:
if ((tag & 7) == 4 || tag == 0) { if ((tag & 7) == 4 || tag == 0) {
@ -18386,13 +18418,14 @@ bool SearchMsg::MergePartialFromCodedStream(
break; break;
} }
// string partition_tag = 3; // repeated string partition_tag = 3;
case 3: { case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_partition_tag())); input, this->add_partition_tag()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->partition_tag().data(), static_cast<int>(this->partition_tag().length()), this->partition_tag(this->partition_tag_size() - 1).data(),
static_cast<int>(this->partition_tag(this->partition_tag_size() - 1).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.SearchMsg.partition_tag")); "milvus.grpc.SearchMsg.partition_tag"));
} else { } else {
@ -18451,6 +18484,37 @@ bool SearchMsg::MergePartialFromCodedStream(
break; break;
} }
// repeated string json = 8;
case 8: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (66 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->add_json()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->json(this->json_size() - 1).data(),
static_cast<int>(this->json(this->json_size() - 1).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.SearchMsg.json"));
} else {
goto handle_unusual;
}
break;
}
// string dsl = 9;
case 9: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (74 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_dsl()));
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->dsl().data(), static_cast<int>(this->dsl().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
"milvus.grpc.SearchMsg.dsl"));
} else {
goto handle_unusual;
}
break;
}
default: { default: {
handle_unusual: handle_unusual:
if (tag == 0) { if (tag == 0) {
@ -18494,14 +18558,14 @@ void SearchMsg::SerializeWithCachedSizes(
2, _Internal::records(this), output); 2, _Internal::records(this), output);
} }
// string partition_tag = 3; // repeated string partition_tag = 3;
if (this->partition_tag().size() > 0) { for (int i = 0, n = this->partition_tag_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->partition_tag().data(), static_cast<int>(this->partition_tag().length()), this->partition_tag(i).data(), static_cast<int>(this->partition_tag(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.partition_tag"); "milvus.grpc.SearchMsg.partition_tag");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
3, this->partition_tag(), output); 3, this->partition_tag(i), output);
} }
// int64 uid = 4; // int64 uid = 4;
@ -18528,6 +18592,26 @@ void SearchMsg::SerializeWithCachedSizes(
output); output);
} }
// repeated string json = 8;
for (int i = 0, n = this->json_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->json(i).data(), static_cast<int>(this->json(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.json");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
8, this->json(i), output);
}
// string dsl = 9;
if (this->dsl().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->dsl().data(), static_cast<int>(this->dsl().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.dsl");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
9, this->dsl(), output);
}
if (_internal_metadata_.have_unknown_fields()) { if (_internal_metadata_.have_unknown_fields()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
_internal_metadata_.unknown_fields(), output); _internal_metadata_.unknown_fields(), output);
@ -18559,15 +18643,14 @@ void SearchMsg::SerializeWithCachedSizes(
2, _Internal::records(this), target); 2, _Internal::records(this), target);
} }
// string partition_tag = 3; // repeated string partition_tag = 3;
if (this->partition_tag().size() > 0) { for (int i = 0, n = this->partition_tag_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->partition_tag().data(), static_cast<int>(this->partition_tag().length()), this->partition_tag(i).data(), static_cast<int>(this->partition_tag(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.partition_tag"); "milvus.grpc.SearchMsg.partition_tag");
target = target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( WriteStringToArray(3, this->partition_tag(i), target);
3, this->partition_tag(), target);
} }
// int64 uid = 4; // int64 uid = 4;
@ -18593,6 +18676,27 @@ void SearchMsg::SerializeWithCachedSizes(
7, this->extra_params(static_cast<int>(i)), target); 7, this->extra_params(static_cast<int>(i)), target);
} }
// repeated string json = 8;
for (int i = 0, n = this->json_size(); i < n; i++) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->json(i).data(), static_cast<int>(this->json(i).length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.json");
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
WriteStringToArray(8, this->json(i), target);
}
// string dsl = 9;
if (this->dsl().size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
this->dsl().data(), static_cast<int>(this->dsl().length()),
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
"milvus.grpc.SearchMsg.dsl");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
9, this->dsl(), target);
}
if (_internal_metadata_.have_unknown_fields()) { if (_internal_metadata_.have_unknown_fields()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields(), target); _internal_metadata_.unknown_fields(), target);
@ -18614,6 +18718,14 @@ size_t SearchMsg::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused // Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits; (void) cached_has_bits;
// repeated string partition_tag = 3;
total_size += 1 *
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->partition_tag_size());
for (int i = 0, n = this->partition_tag_size(); i < n; i++) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->partition_tag(i));
}
// repeated .milvus.grpc.KeyValuePair extra_params = 7; // repeated .milvus.grpc.KeyValuePair extra_params = 7;
{ {
unsigned int count = static_cast<unsigned int>(this->extra_params_size()); unsigned int count = static_cast<unsigned int>(this->extra_params_size());
@ -18625,6 +18737,14 @@ size_t SearchMsg::ByteSizeLong() const {
} }
} }
// repeated string json = 8;
total_size += 1 *
::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->json_size());
for (int i = 0, n = this->json_size(); i < n; i++) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->json(i));
}
// string collection_name = 1; // string collection_name = 1;
if (this->collection_name().size() > 0) { if (this->collection_name().size() > 0) {
total_size += 1 + total_size += 1 +
@ -18632,11 +18752,11 @@ size_t SearchMsg::ByteSizeLong() const {
this->collection_name()); this->collection_name());
} }
// string partition_tag = 3; // string dsl = 9;
if (this->partition_tag().size() > 0) { if (this->dsl().size() > 0) {
total_size += 1 + total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->partition_tag()); this->dsl());
} }
// .milvus.grpc.VectorRowRecord records = 2; // .milvus.grpc.VectorRowRecord records = 2;
@ -18694,14 +18814,16 @@ void SearchMsg::MergeFrom(const SearchMsg& from) {
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits; (void) cached_has_bits;
partition_tag_.MergeFrom(from.partition_tag_);
extra_params_.MergeFrom(from.extra_params_); extra_params_.MergeFrom(from.extra_params_);
json_.MergeFrom(from.json_);
if (from.collection_name().size() > 0) { if (from.collection_name().size() > 0) {
collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_);
} }
if (from.partition_tag().size() > 0) { if (from.dsl().size() > 0) {
partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_); dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_);
} }
if (from.has_records()) { if (from.has_records()) {
mutable_records()->::milvus::grpc::VectorRowRecord::MergeFrom(from.records()); mutable_records()->::milvus::grpc::VectorRowRecord::MergeFrom(from.records());
@ -18738,10 +18860,12 @@ bool SearchMsg::IsInitialized() const {
void SearchMsg::InternalSwap(SearchMsg* other) { void SearchMsg::InternalSwap(SearchMsg* other) {
using std::swap; using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_); _internal_metadata_.Swap(&other->_internal_metadata_);
partition_tag_.InternalSwap(CastToBase(&other->partition_tag_));
CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_));
json_.InternalSwap(CastToBase(&other->json_));
collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual()); GetArenaNoVirtual());
partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dsl_.Swap(&other->dsl_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual()); GetArenaNoVirtual());
swap(records_, other->records_); swap(records_, other->records_);
swap(uid_, other->uid_); swap(uid_, other->uid_);
@ -19112,12 +19236,16 @@ Key2SegMsg::Key2SegMsg(const Key2SegMsg& from)
_internal_metadata_(nullptr), _internal_metadata_(nullptr),
segment_id_(from.segment_id_) { segment_id_(from.segment_id_) {
_internal_metadata_.MergeFrom(from._internal_metadata_); _internal_metadata_.MergeFrom(from._internal_metadata_);
uid_ = from.uid_; ::memcpy(&uid_, &from.uid_,
static_cast<size_t>(reinterpret_cast<char*>(&timestamp_) -
reinterpret_cast<char*>(&uid_)) + sizeof(timestamp_));
// @@protoc_insertion_point(copy_constructor:milvus.grpc.Key2SegMsg) // @@protoc_insertion_point(copy_constructor:milvus.grpc.Key2SegMsg)
} }
void Key2SegMsg::SharedCtor() { void Key2SegMsg::SharedCtor() {
uid_ = PROTOBUF_LONGLONG(0); ::memset(&uid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&timestamp_) -
reinterpret_cast<char*>(&uid_)) + sizeof(timestamp_));
} }
Key2SegMsg::~Key2SegMsg() { Key2SegMsg::~Key2SegMsg() {
@ -19144,7 +19272,9 @@ void Key2SegMsg::Clear() {
(void) cached_has_bits; (void) cached_has_bits;
segment_id_.Clear(); segment_id_.Clear();
uid_ = PROTOBUF_LONGLONG(0); ::memset(&uid_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&timestamp_) -
reinterpret_cast<char*>(&uid_)) + sizeof(timestamp_));
_internal_metadata_.Clear(); _internal_metadata_.Clear();
} }
@ -19163,12 +19293,19 @@ const char* Key2SegMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:
CHK_(ptr); CHK_(ptr);
} else goto handle_unusual; } else goto handle_unusual;
continue; continue;
// repeated int64 segment_id = 2; // uint64 timestamp = 2;
case 2: case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
// repeated int64 segment_id = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_segment_id(), ptr, ctx); ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_segment_id(), ptr, ctx);
CHK_(ptr); CHK_(ptr);
} else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) { } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
add_segment_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr)); add_segment_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
CHK_(ptr); CHK_(ptr);
} else goto handle_unusual; } else goto handle_unusual;
@ -19216,16 +19353,29 @@ bool Key2SegMsg::MergePartialFromCodedStream(
break; break;
} }
// repeated int64 segment_id = 2; // uint64 timestamp = 2;
case 2: { case 2: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::uint64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT64>(
input, &timestamp_)));
} else {
goto handle_unusual;
}
break;
}
// repeated int64 segment_id = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive< DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, this->mutable_segment_id()))); input, this->mutable_segment_id())));
} else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
1, 18u, input, this->mutable_segment_id()))); 1, 26u, input, this->mutable_segment_id())));
} else { } else {
goto handle_unusual; goto handle_unusual;
} }
@ -19264,9 +19414,14 @@ void Key2SegMsg::SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->uid(), output); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->uid(), output);
} }
// repeated int64 segment_id = 2; // uint64 timestamp = 2;
if (this->timestamp() != 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64(2, this->timestamp(), output);
}
// repeated int64 segment_id = 3;
if (this->segment_id_size() > 0) { if (this->segment_id_size() > 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
output->WriteVarint32(_segment_id_cached_byte_size_.load( output->WriteVarint32(_segment_id_cached_byte_size_.load(
std::memory_order_relaxed)); std::memory_order_relaxed));
} }
@ -19293,10 +19448,15 @@ void Key2SegMsg::SerializeWithCachedSizes(
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->uid(), target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->uid(), target);
} }
// repeated int64 segment_id = 2; // uint64 timestamp = 2;
if (this->timestamp() != 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(2, this->timestamp(), target);
}
// repeated int64 segment_id = 3;
if (this->segment_id_size() > 0) { if (this->segment_id_size() > 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
2, 3,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
target); target);
target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray( target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
@ -19327,7 +19487,7 @@ size_t Key2SegMsg::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused // Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits; (void) cached_has_bits;
// repeated int64 segment_id = 2; // repeated int64 segment_id = 3;
{ {
size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
Int64Size(this->segment_id_); Int64Size(this->segment_id_);
@ -19349,6 +19509,13 @@ size_t Key2SegMsg::ByteSizeLong() const {
this->uid()); this->uid());
} }
// uint64 timestamp = 2;
if (this->timestamp() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
this->timestamp());
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
SetCachedSize(cached_size); SetCachedSize(cached_size);
return total_size; return total_size;
@ -19380,6 +19547,9 @@ void Key2SegMsg::MergeFrom(const Key2SegMsg& from) {
if (from.uid() != 0) { if (from.uid() != 0) {
set_uid(from.uid()); set_uid(from.uid());
} }
if (from.timestamp() != 0) {
set_timestamp(from.timestamp());
}
} }
void Key2SegMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { void Key2SegMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
@ -19405,6 +19575,7 @@ void Key2SegMsg::InternalSwap(Key2SegMsg* other) {
_internal_metadata_.Swap(&other->_internal_metadata_); _internal_metadata_.Swap(&other->_internal_metadata_);
segment_id_.InternalSwap(&other->segment_id_); segment_id_.InternalSwap(&other->segment_id_);
swap(uid_, other->uid_); swap(uid_, other->uid_);
swap(timestamp_, other->timestamp_);
} }
::PROTOBUF_NAMESPACE_ID::Metadata Key2SegMsg::GetMetadata() const { ::PROTOBUF_NAMESPACE_ID::Metadata Key2SegMsg::GetMetadata() const {

291
proxy/src/grpc/message.pb.h
View File

@ -7510,14 +7510,33 @@ class SearchMsg :
// accessors ------------------------------------------------------- // accessors -------------------------------------------------------
enum : int { enum : int {
kExtraParamsFieldNumber = 7,
kCollectionNameFieldNumber = 1,
kPartitionTagFieldNumber = 3, kPartitionTagFieldNumber = 3,
kExtraParamsFieldNumber = 7,
kJsonFieldNumber = 8,
kCollectionNameFieldNumber = 1,
kDslFieldNumber = 9,
kRecordsFieldNumber = 2, kRecordsFieldNumber = 2,
kUidFieldNumber = 4, kUidFieldNumber = 4,
kTimestampFieldNumber = 5, kTimestampFieldNumber = 5,
kClientIdFieldNumber = 6, kClientIdFieldNumber = 6,
}; };
// repeated string partition_tag = 3;
int partition_tag_size() const;
void clear_partition_tag();
const std::string& partition_tag(int index) const;
std::string* mutable_partition_tag(int index);
void set_partition_tag(int index, const std::string& value);
void set_partition_tag(int index, std::string&& value);
void set_partition_tag(int index, const char* value);
void set_partition_tag(int index, const char* value, size_t size);
std::string* add_partition_tag();
void add_partition_tag(const std::string& value);
void add_partition_tag(std::string&& value);
void add_partition_tag(const char* value);
void add_partition_tag(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tag() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tag();
// repeated .milvus.grpc.KeyValuePair extra_params = 7; // repeated .milvus.grpc.KeyValuePair extra_params = 7;
int extra_params_size() const; int extra_params_size() const;
void clear_extra_params(); void clear_extra_params();
@ -7529,6 +7548,23 @@ class SearchMsg :
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >&
extra_params() const; extra_params() const;
// repeated string json = 8;
int json_size() const;
void clear_json();
const std::string& json(int index) const;
std::string* mutable_json(int index);
void set_json(int index, const std::string& value);
void set_json(int index, std::string&& value);
void set_json(int index, const char* value);
void set_json(int index, const char* value, size_t size);
std::string* add_json();
void add_json(const std::string& value);
void add_json(std::string&& value);
void add_json(const char* value);
void add_json(const char* value, size_t size);
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& json() const;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_json();
// string collection_name = 1; // string collection_name = 1;
void clear_collection_name(); void clear_collection_name();
const std::string& collection_name() const; const std::string& collection_name() const;
@ -7540,16 +7576,16 @@ class SearchMsg :
std::string* release_collection_name(); std::string* release_collection_name();
void set_allocated_collection_name(std::string* collection_name); void set_allocated_collection_name(std::string* collection_name);
// string partition_tag = 3; // string dsl = 9;
void clear_partition_tag(); void clear_dsl();
const std::string& partition_tag() const; const std::string& dsl() const;
void set_partition_tag(const std::string& value); void set_dsl(const std::string& value);
void set_partition_tag(std::string&& value); void set_dsl(std::string&& value);
void set_partition_tag(const char* value); void set_dsl(const char* value);
void set_partition_tag(const char* value, size_t size); void set_dsl(const char* value, size_t size);
std::string* mutable_partition_tag(); std::string* mutable_dsl();
std::string* release_partition_tag(); std::string* release_dsl();
void set_allocated_partition_tag(std::string* partition_tag); void set_allocated_dsl(std::string* dsl);
// .milvus.grpc.VectorRowRecord records = 2; // .milvus.grpc.VectorRowRecord records = 2;
bool has_records() const; bool has_records() const;
@ -7579,9 +7615,11 @@ class SearchMsg :
class _Internal; class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tag_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> json_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_;
::milvus::grpc::VectorRowRecord* records_; ::milvus::grpc::VectorRowRecord* records_;
::PROTOBUF_NAMESPACE_ID::int64 uid_; ::PROTOBUF_NAMESPACE_ID::int64 uid_;
::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
@ -7849,10 +7887,11 @@ class Key2SegMsg :
// accessors ------------------------------------------------------- // accessors -------------------------------------------------------
enum : int { enum : int {
kSegmentIdFieldNumber = 2, kSegmentIdFieldNumber = 3,
kUidFieldNumber = 1, kUidFieldNumber = 1,
kTimestampFieldNumber = 2,
}; };
// repeated int64 segment_id = 2; // repeated int64 segment_id = 3;
int segment_id_size() const; int segment_id_size() const;
void clear_segment_id(); void clear_segment_id();
::PROTOBUF_NAMESPACE_ID::int64 segment_id(int index) const; ::PROTOBUF_NAMESPACE_ID::int64 segment_id(int index) const;
@ -7868,6 +7907,11 @@ class Key2SegMsg :
::PROTOBUF_NAMESPACE_ID::int64 uid() const; ::PROTOBUF_NAMESPACE_ID::int64 uid() const;
void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value); void set_uid(::PROTOBUF_NAMESPACE_ID::int64 value);
// uint64 timestamp = 2;
void clear_timestamp();
::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const;
void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value);
// @@protoc_insertion_point(class_scope:milvus.grpc.Key2SegMsg) // @@protoc_insertion_point(class_scope:milvus.grpc.Key2SegMsg)
private: private:
class _Internal; class _Internal;
@ -7876,6 +7920,7 @@ class Key2SegMsg :
::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > segment_id_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > segment_id_;
mutable std::atomic<int> _segment_id_cached_byte_size_; mutable std::atomic<int> _segment_id_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::int64 uid_; ::PROTOBUF_NAMESPACE_ID::int64 uid_;
::PROTOBUF_NAMESPACE_ID::uint64 timestamp_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_message_2eproto; friend struct ::TableStruct_message_2eproto;
}; };
@ -12983,55 +13028,69 @@ inline void SearchMsg::set_allocated_records(::milvus::grpc::VectorRowRecord* re
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.records) // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.records)
} }
// string partition_tag = 3; // repeated string partition_tag = 3;
inline int SearchMsg::partition_tag_size() const {
return partition_tag_.size();
}
inline void SearchMsg::clear_partition_tag() { inline void SearchMsg::clear_partition_tag() {
partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.Clear();
} }
inline const std::string& SearchMsg::partition_tag() const { inline const std::string& SearchMsg::partition_tag(int index) const {
// @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.partition_tag) // @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.partition_tag)
return partition_tag_.GetNoArena(); return partition_tag_.Get(index);
} }
inline void SearchMsg::set_partition_tag(const std::string& value) { inline std::string* SearchMsg::mutable_partition_tag(int index) {
// @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.partition_tag)
partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); return partition_tag_.Mutable(index);
}
inline void SearchMsg::set_partition_tag(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag) // @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag)
partition_tag_.Mutable(index)->assign(value);
} }
inline void SearchMsg::set_partition_tag(std::string&& value) { inline void SearchMsg::set_partition_tag(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.partition_tag)
partition_tag_.SetNoArena( partition_tag_.Mutable(index)->assign(std::move(value));
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.partition_tag)
} }
inline void SearchMsg::set_partition_tag(const char* value) { inline void SearchMsg::set_partition_tag(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr); GOOGLE_DCHECK(value != nullptr);
partition_tag_.Mutable(index)->assign(value);
partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.partition_tag) // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.partition_tag)
} }
inline void SearchMsg::set_partition_tag(const char* value, size_t size) { inline void SearchMsg::set_partition_tag(int index, const char* value, size_t size) {
partition_tag_.Mutable(index)->assign(
partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reinterpret_cast<const char*>(value), size);
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.partition_tag) // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.partition_tag)
} }
inline std::string* SearchMsg::mutable_partition_tag() { inline std::string* SearchMsg::add_partition_tag() {
// @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.partition_tag)
// @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.partition_tag) return partition_tag_.Add();
return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
} }
inline std::string* SearchMsg::release_partition_tag() { inline void SearchMsg::add_partition_tag(const std::string& value) {
// @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.partition_tag) partition_tag_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag)
return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
} }
inline void SearchMsg::set_allocated_partition_tag(std::string* partition_tag) { inline void SearchMsg::add_partition_tag(std::string&& value) {
if (partition_tag != nullptr) { partition_tag_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.partition_tag)
} else { }
inline void SearchMsg::add_partition_tag(const char* value) {
} GOOGLE_DCHECK(value != nullptr);
partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag); partition_tag_.Add()->assign(value);
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.partition_tag) // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.partition_tag)
}
inline void SearchMsg::add_partition_tag(const char* value, size_t size) {
partition_tag_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.partition_tag)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchMsg::partition_tag() const {
// @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.partition_tag)
return partition_tag_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchMsg::mutable_partition_tag() {
// @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.partition_tag)
return &partition_tag_;
} }
// int64 uid = 4; // int64 uid = 4;
@ -13106,6 +13165,122 @@ SearchMsg::extra_params() const {
return extra_params_; return extra_params_;
} }
// repeated string json = 8;
inline int SearchMsg::json_size() const {
return json_.size();
}
inline void SearchMsg::clear_json() {
json_.Clear();
}
inline const std::string& SearchMsg::json(int index) const {
// @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.json)
return json_.Get(index);
}
inline std::string* SearchMsg::mutable_json(int index) {
// @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.json)
return json_.Mutable(index);
}
inline void SearchMsg::set_json(int index, const std::string& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json)
json_.Mutable(index)->assign(value);
}
inline void SearchMsg::set_json(int index, std::string&& value) {
// @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.json)
json_.Mutable(index)->assign(std::move(value));
}
inline void SearchMsg::set_json(int index, const char* value) {
GOOGLE_DCHECK(value != nullptr);
json_.Mutable(index)->assign(value);
// @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::set_json(int index, const char* value, size_t size) {
json_.Mutable(index)->assign(
reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.json)
}
inline std::string* SearchMsg::add_json() {
// @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchMsg.json)
return json_.Add();
}
inline void SearchMsg::add_json(const std::string& value) {
json_.Add()->assign(value);
// @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(std::string&& value) {
json_.Add(std::move(value));
// @@protoc_insertion_point(field_add:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(const char* value) {
GOOGLE_DCHECK(value != nullptr);
json_.Add()->assign(value);
// @@protoc_insertion_point(field_add_char:milvus.grpc.SearchMsg.json)
}
inline void SearchMsg::add_json(const char* value, size_t size) {
json_.Add()->assign(reinterpret_cast<const char*>(value), size);
// @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchMsg.json)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchMsg::json() const {
// @@protoc_insertion_point(field_list:milvus.grpc.SearchMsg.json)
return json_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchMsg::mutable_json() {
// @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchMsg.json)
return &json_;
}
// string dsl = 9;
inline void SearchMsg::clear_dsl() {
dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SearchMsg::dsl() const {
// @@protoc_insertion_point(field_get:milvus.grpc.SearchMsg.dsl)
return dsl_.GetNoArena();
}
inline void SearchMsg::set_dsl(const std::string& value) {
dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.grpc.SearchMsg.dsl)
}
inline void SearchMsg::set_dsl(std::string&& value) {
dsl_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchMsg.dsl)
}
inline void SearchMsg::set_dsl(const char* value) {
GOOGLE_DCHECK(value != nullptr);
dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.grpc.SearchMsg.dsl)
}
inline void SearchMsg::set_dsl(const char* value, size_t size) {
dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchMsg.dsl)
}
inline std::string* SearchMsg::mutable_dsl() {
// @@protoc_insertion_point(field_mutable:milvus.grpc.SearchMsg.dsl)
return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SearchMsg::release_dsl() {
// @@protoc_insertion_point(field_release:milvus.grpc.SearchMsg.dsl)
return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SearchMsg::set_allocated_dsl(std::string* dsl) {
if (dsl != nullptr) {
} else {
}
dsl_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dsl);
// @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchMsg.dsl)
}
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// TimeSyncMsg // TimeSyncMsg
@ -13170,7 +13345,21 @@ inline void Key2SegMsg::set_uid(::PROTOBUF_NAMESPACE_ID::int64 value) {
// @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.uid) // @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.uid)
} }
// repeated int64 segment_id = 2; // uint64 timestamp = 2;
inline void Key2SegMsg::clear_timestamp() {
timestamp_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Key2SegMsg::timestamp() const {
// @@protoc_insertion_point(field_get:milvus.grpc.Key2SegMsg.timestamp)
return timestamp_;
}
inline void Key2SegMsg::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) {
timestamp_ = value;
// @@protoc_insertion_point(field_set:milvus.grpc.Key2SegMsg.timestamp)
}
// repeated int64 segment_id = 3;
inline int Key2SegMsg::segment_id_size() const { inline int Key2SegMsg::segment_id_size() const {
return segment_id_.size(); return segment_id_.size();
} }

132
proxy/src/message_client/ClientV2.cpp
View File

@ -5,7 +5,9 @@
namespace milvus::message_client { namespace milvus::message_client {
MsgClientV2::MsgClientV2(int64_t client_id, std::string &service_url, const pulsar::ClientConfiguration &config) std::map<int64_t, std::vector<std::shared_ptr<grpc::QueryResult>>> total_results;
MsgClientV2::MsgClientV2(int64_t client_id, const std::string &service_url, const pulsar::ClientConfiguration &config)
: client_id_(client_id), service_url_(service_url) {} : client_id_(client_id), service_url_(service_url) {}
Status MsgClientV2::Init(const std::string &insert_delete, Status MsgClientV2::Init(const std::string &insert_delete,
@ -21,7 +23,7 @@ Status MsgClientV2::Init(const std::string &insert_delete,
producerConfiguration.setMessageRouter(std::make_shared<PartitionPolicy>()); producerConfiguration.setMessageRouter(std::make_shared<PartitionPolicy>());
insert_delete_producer_ = std::make_shared<MsgProducer>(pulsar_client, insert_delete, producerConfiguration); insert_delete_producer_ = std::make_shared<MsgProducer>(pulsar_client, insert_delete, producerConfiguration);
search_producer_ = std::make_shared<MsgProducer>(pulsar_client, search, producerConfiguration); search_producer_ = std::make_shared<MsgProducer>(pulsar_client, search, producerConfiguration);
search_by_id_producer_ = std::make_shared<MsgProducer>(pulsar_client, search_by_id, producerConfiguration); search_by_id_producer_ = std::make_shared<MsgProducer>(pulsar_client, search_result, producerConfiguration);
time_sync_producer_ = std::make_shared<MsgProducer>(pulsar_client, time_sync); time_sync_producer_ = std::make_shared<MsgProducer>(pulsar_client, time_sync);
//create pulsar consumer //create pulsar consumer
std::string subscribe_name = std::to_string(CommonUtil::RandomUINT64()); std::string subscribe_name = std::to_string(CommonUtil::RandomUINT64());
@ -74,7 +76,7 @@ milvus::grpc::QueryResult Aggregation(std::vector<std::shared_ptr<grpc::QueryRes
} }
grpc::QueryResult result; grpc::QueryResult result;
// result_prt->set_allocated_status(const_cast<milvus::grpc::Status*>(&results[0]->status()));
result.mutable_status()->CopyFrom(results[0]->status()); result.mutable_status()->CopyFrom(results[0]->status());
result.mutable_entities()->CopyFrom(results[0]->entities()); result.mutable_entities()->CopyFrom(results[0]->entities());
result.set_row_num(results[0]->row_num()); result.set_row_num(results[0]->row_num());
@ -92,36 +94,31 @@ milvus::grpc::QueryResult Aggregation(std::vector<std::shared_ptr<grpc::QueryRes
return result; return result;
} }
milvus::grpc::QueryResult MsgClientV2::GetQueryResult(int64_t query_id) { Status MsgClientV2::GetQueryResult(int64_t query_id, milvus::grpc::QueryResult &result) {
// Result result = MsgProducer::createProducer("result-partition-0");
auto client = std::make_shared<MsgClient>("pulsar://localhost:6650");
MsgConsumer consumer(client, "my_consumer");
consumer.subscribe("result");
std::vector<std::shared_ptr<grpc::QueryResult>> results; std::vector<std::shared_ptr<grpc::QueryResult>> results;
int64_t query_node_num = GetQueryNodeNum(); int64_t query_node_num = GetQueryNodeNum();
std::map<int64_t, std::vector<std::shared_ptr<grpc::QueryResult>>> total_results;
while (true) { while (true) {
auto received_result = total_results[query_id]; auto received_result = total_results[query_id];
if (received_result.size() == query_node_num) { if (received_result.size() == query_node_num) {
break; break;
} }
Message msg; Message msg;
consumer.receive(msg); consumer_->receive(msg);
grpc::QueryResult search_res_msg; grpc::QueryResult search_res_msg;
auto status = search_res_msg.ParseFromString(msg.getDataAsString()); auto status = search_res_msg.ParseFromString(msg.getDataAsString());
if (status) { if (status) {
auto message = std::make_shared<grpc::QueryResult>(search_res_msg); auto message = std::make_shared<grpc::QueryResult>(search_res_msg);
total_results[message->query_id()].push_back(message); total_results[message->query_id()].push_back(message);
consumer.acknowledge(msg); consumer_->acknowledge(msg);
} }
} }
return Aggregation(total_results[query_id]); result = Aggregation(total_results[query_id]);
return Status::OK();
} }
Status MsgClientV2::SendMutMessage(const milvus::grpc::InsertParam &request, uint64_t timestamp) { Status MsgClientV2::SendMutMessage(const milvus::grpc::InsertParam &request, uint64_t timestamp) {
@ -169,6 +166,115 @@ Status MsgClientV2::SendMutMessage(const milvus::grpc::DeleteByIDParam &request,
return Status::OK(); return Status::OK();
} }
Status MsgClientV2::SendQueryMessage(const milvus::grpc::SearchParam &request, uint64_t timestamp, int64_t &query_id) {
milvus::grpc::SearchMsg search_msg;
query_id = GetUniqueQId();
search_msg.set_collection_name(request.collection_name());
search_msg.set_uid(query_id);
//TODO: get client id from master
search_msg.set_client_id(1);
search_msg.set_timestamp(timestamp);
search_msg.set_dsl(request.dsl());
//TODO: get data type from master
milvus::grpc::VectorRowRecord vector_row_recode;
std::vector<float> vectors_records;
for (int i = 0; i < request.vector_param_size(); ++i) {
search_msg.add_json(request.vector_param(i).json());
for (int j = 0; j < request.vector_param(i).row_record().records_size(); ++j) {
for (int k = 0; k < request.vector_param(i).row_record().records(j).float_data_size(); ++k) {
vector_row_recode.add_float_data(request.vector_param(i).row_record().records(j).float_data(k));
}
vector_row_recode.set_binary_data(request.vector_param(i).row_record().records(j).binary_data());
}
}
search_msg.mutable_records()->CopyFrom(vector_row_recode);
for (int m = 0; m < request.partition_tag_size(); ++m) {
search_msg.add_partition_tag(request.partition_tag(m));
}
for (int l = 0; l < request.extra_params_size(); ++l) {
search_msg.mutable_extra_params(l)->CopyFrom(request.extra_params(l));
}
auto result = search_by_id_producer_->send(search_msg);
if (result != pulsar::Result::ResultOk) {
return Status(DB_ERROR, pulsar::strResult(result));
}
return Status::OK();
// milvus::grpc::QueryResult fake_message;
// milvus::grpc::QueryResult fake_message2;
//
// milvus::grpc::Status fake_status;
// fake_status.set_error_code(milvus::grpc::ErrorCode::SUCCESS);
// std::string aaa = "hahaha";
// fake_status.set_reason(aaa);
//
// milvus::grpc::RowData fake_row_data;
// fake_row_data.set_blob("fake_row_data");
//
// milvus::grpc::Entities fake_entities;
//// fake_entities.set_allocated_status(&fake_status);
// fake_entities.mutable_status()->CopyFrom(fake_status);
// for (int i = 0; i < 10; i++){
// fake_entities.add_ids(i);
// fake_entities.add_valid_row(true);
// fake_entities.add_rows_data()->CopyFrom(fake_row_data);
// }
//
// int64_t fake_row_num = 10;
//
// float fake_scores[10] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0};
// float fake_distance[10] = {9.7, 9.6, 9.5, 9.8, 8.7, 8.8, 9.9, 8.8, 9.7, 8.9};
//
// std::vector<milvus::grpc::KeyValuePair> fake_extra_params;
// milvus::grpc::KeyValuePair keyValuePair;
// for (int i = 0; i < 10; ++i) {
// keyValuePair.set_key(std::to_string(i));
// keyValuePair.set_value(std::to_string(i + 10));
// fake_extra_params.push_back(keyValuePair);
// }
//
// int64_t fake_query_id = 10;
// int64_t fake_client_id = 1;
//
// fake_message.mutable_status()->CopyFrom(fake_status);
// fake_message.mutable_entities()->CopyFrom(fake_entities);
// fake_message.set_row_num(fake_row_num);
// for (int i = 0; i < 10; i++) {
// fake_message.add_scores(fake_scores[i]);
// fake_message.add_distances(fake_distance[i]);
// fake_message.add_extra_params()->CopyFrom(fake_extra_params[i]);
// }
//
// fake_message.set_query_id(fake_query_id);
// fake_message.set_client_id(fake_client_id);
//
// float fake_scores2[10] = {2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0, 1.1};
// float fake_distance2[10] = {9.8, 8.6, 9.6, 9.7, 8.9, 8.8, 9.0, 9.8, 9.7, 8.9};
//
// fake_message2.mutable_status()->CopyFrom(fake_status);
// fake_message2.mutable_entities()->CopyFrom(fake_entities);
// fake_message2.set_row_num(fake_row_num);
// for (int j = 0; j < 10; ++j) {
// fake_message2.add_scores(fake_scores2[j]);
// fake_message2.add_distances(fake_distance2[j]);
// fake_message2.add_extra_params()->CopyFrom(fake_extra_params[j]);
// }
//
// fake_message2.set_query_id(fake_query_id);
// fake_message2.set_client_id(fake_client_id);
//
// search_by_id_producer_->send(fake_message.SerializeAsString());
// search_by_id_producer_->send(fake_message2.SerializeAsString());
// return Status::OK();
}
MsgClientV2::~MsgClientV2() { MsgClientV2::~MsgClientV2() {
insert_delete_producer_->close(); insert_delete_producer_->close();
search_producer_->close(); search_producer_->close();

6
proxy/src/message_client/ClientV2.h
View File

@ -9,7 +9,7 @@ namespace milvus::message_client {
class MsgClientV2 { class MsgClientV2 {
public: public:
MsgClientV2(int64_t client_id, MsgClientV2(int64_t client_id,
std::string &service_url, const std::string &service_url,
const pulsar::ClientConfiguration &config = pulsar::ClientConfiguration()); const pulsar::ClientConfiguration &config = pulsar::ClientConfiguration());
~MsgClientV2(); ~MsgClientV2();
@ -26,9 +26,9 @@ class MsgClientV2 {
Status SendMutMessage(const milvus::grpc::DeleteByIDParam &request, uint64_t timestamp); Status SendMutMessage(const milvus::grpc::DeleteByIDParam &request, uint64_t timestamp);
// //
Status SendQueryMessage(const milvus::grpc::SearchParam &request); Status SendQueryMessage(const milvus::grpc::SearchParam &request, uint64_t timestamp, int64_t &query_id);
static milvus::grpc::QueryResult GetQueryResult(int64_t query_id); Status GetQueryResult(int64_t query_id, milvus::grpc::QueryResult &result);
private: private:
int64_t GetUniqueQId() { int64_t GetUniqueQId() {

7
proxy/src/server/delivery/ReqHandler.cpp
View File

@ -175,9 +175,10 @@ ReqHandler::DeleteEntityByID(const ContextPtr& context, const ::milvus::grpc::De
Status Status
ReqHandler::Search(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params, ReqHandler::Search(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params,
engine::QueryResultPtr& result) { engine::QueryResultPtr& result) {
BaseReqPtr req_ptr = SearchReq::Create(context, query_ptr, json_params, result); // BaseReqPtr req_ptr = SearchReq::Create(context, query_ptr, json_params, result);
ReqScheduler::ExecReq(req_ptr); // ReqScheduler::ExecReq(req_ptr);
return req_ptr->status(); // return req_ptr->status();
return Status::OK();
} }
Status Status

30
proxy/src/server/delivery/request/SearchReq.cpp
View File

@ -10,6 +10,7 @@
// or implied. See the License for the specific language governing permissions and limitations under the License. // or implied. See the License for the specific language governing permissions and limitations under the License.
#include "server/delivery/request/SearchReq.h" #include "server/delivery/request/SearchReq.h"
#include "server/MessageWrapper.h"
// #include "db/Utils.h" // #include "db/Utils.h"
#include "server/ValidationUtil.h" #include "server/ValidationUtil.h"
#include "utils/CommonUtil.h" #include "utils/CommonUtil.h"
@ -28,25 +29,38 @@
namespace milvus { namespace milvus {
namespace server { namespace server {
SearchReq::SearchReq(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params, SearchReq::SearchReq(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
engine::QueryResultPtr& result) ::milvus::grpc::QueryResult *result)
: BaseReq(context, ReqType::kSearch), : BaseReq(context, ReqType::kSearch),
query_ptr_(query_ptr), request_(request),
json_params_(json_params),
result_(result) { result_(result) {
} }
BaseReqPtr BaseReqPtr
SearchReq::Create(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params, SearchReq::Create(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
engine::QueryResultPtr& result) { ::milvus::grpc::QueryResult *response) {
return std::shared_ptr<BaseReq>(new SearchReq(context, query_ptr, json_params, result));
return std::shared_ptr<BaseReq>(new SearchReq(context, request, response));
} }
Status Status
SearchReq::OnExecute() { SearchReq::OnExecute() {
auto message_wrapper = milvus::server::MessageWrapper::GetInstance();
message_wrapper.Init();
auto client = message_wrapper.MessageClient();
int64_t query_id;
milvus::grpc::SearchParam request;
return Status::OK(); auto send_status = client->SendQueryMessage(*request_, timestamp_, query_id);
if (!send_status.ok()){
return send_status;
}
Status status = client->GetQueryResult(query_id, *result_);
return status;
} }
} // namespace server } // namespace server

13
proxy/src/server/delivery/request/SearchReq.h
View File

@ -25,20 +25,19 @@ namespace server {
class SearchReq : public BaseReq { class SearchReq : public BaseReq {
public: public:
static BaseReqPtr static BaseReqPtr
Create(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params, Create(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
engine::QueryResultPtr& result); ::milvus::grpc::QueryResult *response);
protected: protected:
SearchReq(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params, SearchReq(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
engine::QueryResultPtr& result); ::milvus::grpc::QueryResult *result);
Status Status
OnExecute() override; OnExecute() override;
private: private:
milvus::query::QueryPtr query_ptr_; const ::milvus::grpc::SearchParam *request_;
milvus::json json_params_; ::milvus::grpc::QueryResult* result_;
engine::QueryResultPtr& result_;
}; };
} // namespace server } // namespace server

5
proxy/src/server/grpc_impl/GrpcRequestHandler.cpp
View File

@ -17,6 +17,8 @@
#include <unordered_map> #include <unordered_map>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <src/server/delivery/request/SearchReq.h>
#include <src/server/delivery/ReqScheduler.h>
#include "query/BinaryQuery.h" #include "query/BinaryQuery.h"
#include "server/ValidationUtil.h" #include "server/ValidationUtil.h"
@ -849,6 +851,9 @@ GrpcRequestHandler::Search(::grpc::ServerContext *context, const ::milvus::grpc:
CHECK_NULLPTR_RETURN(request); CHECK_NULLPTR_RETURN(request);
LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->ReqID().c_str(), __func__); LOG_SERVER_INFO_ << LogOut("Request [%s] %s begin.", GetContext(context)->ReqID().c_str(), __func__);
//TODO: check if the request is legal
BaseReqPtr req_ptr = SearchReq::Create(GetContext(context), request, response);
ReqScheduler::ExecReq(req_ptr);
return ::grpc::Status::OK; return ::grpc::Status::OK;
} }

149
proxy/unittest/message_client/get_result_test.cpp
View File

@ -1,81 +1,88 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "message_client/ClientV2.h" #include "src/message_client/ClientV2.h"
TEST(CLIENT_CPP, GetResult) { TEST(CLIENT_CPP, GetResult) {
auto client= std::make_shared<milvus::message_client::MsgClient>("pulsar://localhost:6650"); // auto client= std::make_shared<milvus::message_client::MsgClient>("pulsar://localhost:6650");
milvus::message_client::MsgProducer producer(client,"test"); // milvus::message_client::MsgProducer producer(client,"test");
producer.createProducer("result"); // producer.createProducer("result");
producer.send("result"); // producer.send("result");
milvus::grpc::QueryResult fake_message; // milvus::grpc::QueryResult fake_message;
milvus::grpc::QueryResult fake_message2; // milvus::grpc::QueryResult fake_message2;
//
// milvus::grpc::Status fake_status;
// fake_status.set_error_code(milvus::grpc::ErrorCode::SUCCESS);
// std::string aaa = "hahaha";
// fake_status.set_reason(aaa);
//
// milvus::grpc::RowData fake_row_data;
// fake_row_data.set_blob("fake_row_data");
//
// milvus::grpc::Entities fake_entities;
//// fake_entities.set_allocated_status(&fake_status);
// fake_entities.mutable_status()->CopyFrom(fake_status);
// for (int i = 0; i < 10; i++){
// fake_entities.add_ids(i);
// fake_entities.add_valid_row(true);
// fake_entities.add_rows_data()->CopyFrom(fake_row_data);
// }
//
// int64_t fake_row_num = 10;
//
// float fake_scores[10] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0};
// float fake_distance[10] = {9.7, 9.6, 9.5, 9.8, 8.7, 8.8, 9.9, 8.8, 9.7, 8.9};
//
// std::vector<milvus::grpc::KeyValuePair> fake_extra_params;
// milvus::grpc::KeyValuePair keyValuePair;
// for (int i = 0; i < 10; ++i) {
// keyValuePair.set_key(std::to_string(i));
// keyValuePair.set_value(std::to_string(i + 10));
// fake_extra_params.push_back(keyValuePair);
// }
//
// int64_t fake_query_id = 10;
// int64_t fake_client_id = 1;
//
// fake_message.mutable_status()->CopyFrom(fake_status);
// fake_message.mutable_entities()->CopyFrom(fake_entities);
// fake_message.set_row_num(fake_row_num);
// for (int i = 0; i < 10; i++) {
// fake_message.add_scores(fake_scores[i]);
// fake_message.add_distances(fake_distance[i]);
// fake_message.add_extra_params()->CopyFrom(fake_extra_params[i]);
// }
//
// fake_message.set_query_id(fake_query_id);
// fake_message.set_client_id(fake_client_id);
//
// float fake_scores2[10] = {2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0, 1.1};
// float fake_distance2[10] = {9.8, 8.6, 9.6, 9.7, 8.9, 8.8, 9.0, 9.8, 9.7, 8.9};
//
// fake_message2.mutable_status()->CopyFrom(fake_status);
// fake_message2.mutable_entities()->CopyFrom(fake_entities);
// fake_message2.set_row_num(fake_row_num);
// for (int j = 0; j < 10; ++j) {
// fake_message2.add_scores(fake_scores2[j]);
// fake_message2.add_distances(fake_distance2[j]);
// fake_message2.add_extra_params()->CopyFrom(fake_extra_params[j]);
// }
//
// fake_message2.set_query_id(fake_query_id);
// fake_message2.set_client_id(fake_client_id);
//
// producer.send(fake_message.SerializeAsString());
// producer.send(fake_message2.SerializeAsString());
milvus::grpc::Status fake_status; int64_t query_id = 10;
fake_status.set_error_code(milvus::grpc::ErrorCode::SUCCESS); milvus::message_client::MsgClientV2 client_v2(1, "pulsar://localhost:6650");
std::string aaa = "hahaha"; auto init_status = client_v2.Init("insert_delete", "search", "time_sync", "result", "result");
fake_status.set_reason(aaa);
milvus::grpc::RowData fake_row_data; // client_v2.SendQueryMessage();
fake_row_data.set_blob("fake_row_data"); milvus::grpc::SearchParam request;
auto status_send = client_v2.SendQueryMessage(request, query_id);
milvus::grpc::Entities fake_entities; milvus::grpc::QueryResult result;
// fake_entities.set_allocated_status(&fake_status); auto status = client_v2.GetQueryResult(query_id, result);
fake_entities.mutable_status()->CopyFrom(fake_status);
for (int i = 0; i < 10; i++){
fake_entities.add_ids(i);
fake_entities.add_valid_row(true);
fake_entities.add_rows_data()->CopyFrom(fake_row_data);
}
int64_t fake_row_num = 10;
float fake_scores[10] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0};
float fake_distance[10] = {9.7, 9.6, 9.5, 9.8, 8.7, 8.8, 9.9, 8.8, 9.7, 8.9};
std::vector<milvus::grpc::KeyValuePair> fake_extra_params;
milvus::grpc::KeyValuePair keyValuePair;
for (int i = 0; i < 10; ++i) {
keyValuePair.set_key(std::to_string(i));
keyValuePair.set_value(std::to_string(i + 10));
fake_extra_params.push_back(keyValuePair);
}
int64_t fake_query_id = 10;
int64_t fake_client_id = 1;
fake_message.mutable_status()->CopyFrom(fake_status);
fake_message.mutable_entities()->CopyFrom(fake_entities);
fake_message.set_row_num(fake_row_num);
for (int i = 0; i < 10; i++) {
fake_message.add_scores(fake_scores[i]);
fake_message.add_distances(fake_distance[i]);
fake_message.add_extra_params()->CopyFrom(fake_extra_params[i]);
}
fake_message.set_query_id(fake_query_id);
fake_message.set_client_id(fake_client_id);
float fake_scores2[10] = {2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 0.0, 1.1};
float fake_distance2[10] = {9.8, 8.6, 9.6, 9.7, 8.9, 8.8, 9.0, 9.8, 9.7, 8.9};
fake_message2.mutable_status()->CopyFrom(fake_status);
fake_message2.mutable_entities()->CopyFrom(fake_entities);
fake_message2.set_row_num(fake_row_num);
for (int j = 0; j < 10; ++j) {
fake_message2.add_scores(fake_scores2[j]);
fake_message2.add_distances(fake_distance2[j]);
fake_message2.add_extra_params()->CopyFrom(fake_extra_params[j]);
}
fake_message2.set_query_id(fake_query_id);
fake_message2.set_client_id(fake_client_id);
producer.send(fake_message.SerializeAsString());
producer.send(fake_message2.SerializeAsString());
producer.close();
client->close();
auto result = milvus::message_client::MsgClientV2::GetQueryResult(fake_query_id);
std::cout << result.client_id() << std::endl; std::cout << result.client_id() << std::endl;
for (int k = 0; k < result.distances_size(); ++k) { for (int k = 0; k < result.distances_size(); ++k) {
std::cout << result.distances(k) << "\t"; std::cout << result.distances(k) << "\t";

5
timesync/readertimesync.go
View File

@ -197,8 +197,9 @@ func (r *readerTimeSyncCfg) alignTimeSync(ts []*pb.TimeSyncMsg) []*pb.TimeSyncMs
} }
} }
} else { } else {
ts = ts[len(ts)-1:] if len(ts) > 1 {
return ts ts = ts[len(ts)-1:]
}
} }
return ts return ts
} }

103
timesync/readertimesync_test.go
View File

@ -15,24 +15,32 @@ const (
pulsarAddr = "pulsar://localhost:6650" pulsarAddr = "pulsar://localhost:6650"
timeSyncTopic = "timesync" timeSyncTopic = "timesync"
timeSyncTopic2 = "timesync2" timeSyncTopic2 = "timesync2"
timeSyncTopic3 = "timesync3"
timeSyncSubName = "timesync-g" timeSyncSubName = "timesync-g"
timeSyncSubName1 = "timesync-g1" timeSyncSubName1 = "timesync-g1"
timeSyncSubName2 = "timesync-g2" timeSyncSubName2 = "timesync-g2"
timeSyncSubName3 = "timesync-g3"
readerTopic1 = "reader1" readerTopic1 = "reader1"
readerTopic12 = "reader12" readerTopic12 = "reader12"
readerTopic13 = "reader13"
readerTopic2 = "reader2" readerTopic2 = "reader2"
readerTopic22 = "reader22" readerTopic22 = "reader22"
readerTopic23 = "reader23"
readerTopic3 = "reader3" readerTopic3 = "reader3"
readerTopic32 = "reader32" readerTopic32 = "reader32"
readerTopic33 = "reader33"
readerTopic4 = "reader4" readerTopic4 = "reader4"
readerTopic42 = "reader42" readerTopic42 = "reader42"
readerTopic43 = "reader43"
readerSubName = "reader-g" readerSubName = "reader-g"
readerSubName1 = "reader-g1" readerSubName1 = "reader-g1"
readerSubName2 = "reader-g2" readerSubName2 = "reader-g2"
readerSubName3 = "reader-g3"
interval = 200 interval = 200
readStopFlag int64 = -1 readStopFlag int64 = -1
readStopFlag1 int64 = -1 readStopFlag1 int64 = -1
readStopFlag2 int64 = -2 readStopFlag2 int64 = -2
readStopFlag3 int64 = -3
) )
func TestAlignTimeSync(t *testing.T) { func TestAlignTimeSync(t *testing.T) {
@ -460,6 +468,101 @@ func TestReaderTimesync2(t *testing.T) {
pr4.Close() pr4.Close()
} }
func TestReaderTimesync3(t *testing.T) {
client, _ := pulsar.NewClient(pulsar.ClientOptions{URL: pulsarAddr})
pt, _ := client.CreateProducer(pulsar.ProducerOptions{Topic: timeSyncTopic3})
pr1, _ := client.CreateProducer(pulsar.ProducerOptions{Topic: readerTopic13})
pr2, _ := client.CreateProducer(pulsar.ProducerOptions{Topic: readerTopic23})
pr3, _ := client.CreateProducer(pulsar.ProducerOptions{Topic: readerTopic33})
pr4, _ := client.CreateProducer(pulsar.ProducerOptions{Topic: readerTopic43})
defer func() {
pr1.Close()
pr2.Close()
pr3.Close()
pr4.Close()
pt.Close()
client.Close()
}()
go func() {
total := 2 * 1000 / 10
ticker := time.Tick(10 * time.Millisecond)
var timestamp uint64 = 0
prlist := []pulsar.Producer{pr1, pr2, pr3, pr4}
for i := 1; i <= total; i++ {
<-ticker
timestamp += 10
for idx, pr := range prlist {
msg := pb.InsertOrDeleteMsg{ClientId: int64(idx + 1), Timestamp: toTimestamp(timestamp)}
mb, err := proto.Marshal(&msg)
if err != nil {
t.Fatal(err)
}
if _, err := pr.Send(context.Background(), &pulsar.ProducerMessage{Payload: mb}); err != nil {
t.Fatal(err)
}
}
if i%20 == 0 {
tm := pb.TimeSyncMsg{Peer_Id: 1, Timestamp: toTimestamp(timestamp)}
tb, err := proto.Marshal(&tm)
if err != nil {
t.Fatal(err)
}
if _, err := pt.Send(context.Background(), &pulsar.ProducerMessage{Payload: tb}); err != nil {
t.Fatal(err)
}
}
}
}()
r, err := NewReaderTimeSync(pulsarAddr,
timeSyncTopic3,
timeSyncSubName3,
[]string{readerTopic13, readerTopic23, readerTopic33, readerTopic43},
readerSubName3,
[]int64{1},
interval,
readStopFlag3,
WithReaderQueueSize(1024))
if err != nil {
t.Fatal(err)
}
defer r.Close()
ctx, _ := context.WithTimeout(context.Background(), 3*time.Second)
if err := r.Start(); err != nil {
t.Fatal(err)
}
var tsm1, tsm2 TimeSyncMsg
var totalRecords int64 = 0
for {
if ctx.Err() != nil {
break
}
select {
case <-ctx.Done():
tsm1.NumRecorders = 0
break
case tsm1 = <-r.TimeSync():
}
if tsm1.NumRecorders > 0 {
totalRecords += tsm1.NumRecorders
for i := int64(0); i < tsm1.NumRecorders; i++ {
im := <-r.InsertOrDelete()
if im.Timestamp < tsm2.Timestamp {
t.Fatalf("time sync error , im.Timestamp = %d, tsm2.Timestamp = %d", im.Timestamp, tsm2.Timestamp)
}
}
tsm2 = tsm1
}
}
log.Printf("total records = %d", totalRecords)
if totalRecords != 800 {
t.Fatalf("total records should be 800")
}
}
func getMillisecond(ts uint64) uint64 { func getMillisecond(ts uint64) uint64 {
return ts >> 18 return ts >> 18
} }