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"`
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"`
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_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -2923,6 +2925,20 @@ func (m *SearchMsg) GetExtraParams() []*KeyValuePair {
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 {
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"`
@ -3092,184 +3108,185 @@ func init() {
func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) }
var fileDescriptor_33c57e4bae7b9afd = []byte{
// 2859 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xdd, 0x72, 0xdb, 0xc6,
0xf5, 0x27, 0x08, 0x8a, 0x24, 0x0e, 0x48, 0x09, 0x5a, 0xcb, 0xb6, 0x6c, 0xc7, 0x7f, 0x3b, 0xf8,
0xcf, 0xb4, 0x8e, 0x3b, 0xe3, 0x49, 0x94, 0xd4, 0x76, 0xeb, 0x24, 0x0d, 0x3f, 0x20, 0x09, 0x35,
0x45, 0xca, 0x4b, 0xc8, 0xce, 0xc7, 0x74, 0x50, 0x88, 0x58, 0xd3, 0x68, 0x48, 0x80, 0x05, 0x40,
0xcb, 0xbc, 0xed, 0x7d, 0x3b, 0xd3, 0xcb, 0xce, 0xf4, 0xa6, 0x7d, 0x84, 0xf6, 0x2d, 0xfa, 0x02,
0xb9, 0xc8, 0x4c, 0x2f, 0x3b, 0x7d, 0x8c, 0xce, 0x7e, 0x80, 0x04, 0x28, 0x52, 0x22, 0xa3, 0xf6,
0x4a, 0xcb, 0xb3, 0xbb, 0x67, 0xcf, 0xf7, 0xfe, 0xce, 0x42, 0x50, 0x1d, 0x92, 0x28, 0x72, 0xfa,
0xe4, 0xd1, 0x28, 0x0c, 0xe2, 0x00, 0xa9, 0x43, 0x6f, 0xf0, 0x76, 0x1c, 0x3d, 0xea, 0x87, 0xa3,
0x9e, 0xfe, 0x0a, 0x8a, 0xdd, 0xd8, 0x89, 0xc7, 0x11, 0xfa, 0x29, 0x00, 0x09, 0xc3, 0x20, 0xb4,
0x7b, 0x81, 0x4b, 0x76, 0xa5, 0xfb, 0xd2, 0x83, 0xcd, 0xbd, 0x1b, 0x8f, 0x52, 0x6b, 0x1f, 0x19,
0x74, 0xba, 0x11, 0xb8, 0x04, 0x2b, 0x24, 0x19, 0xa2, 0x1b, 0x50, 0x0c, 0x89, 0x13, 0x05, 0xfe,
0x6e, 0xfe, 0xbe, 0xf4, 0x40, 0xc1, 0xe2, 0x97, 0xfe, 0x18, 0x2a, 0xcf, 0xc9, 0xe4, 0xa5, 0x33,
0x18, 0x93, 0x63, 0xc7, 0x0b, 0x91, 0x06, 0xf2, 0xb7, 0x64, 0xc2, 0xf8, 0x2a, 0x98, 0x0e, 0xd1,
0x0e, 0x6c, 0xbc, 0xa5, 0xd3, 0x62, 0x23, 0xff, 0xa1, 0xff, 0x0c, 0x36, 0x1b, 0xc1, 0x60, 0x40,
0x7a, 0xb1, 0x17, 0xf8, 0x6d, 0x67, 0x48, 0xd0, 0x8f, 0x61, 0xab, 0x37, 0xa5, 0xd8, 0xbe, 0x33,
0x24, 0x82, 0xcb, 0x66, 0x2f, 0xb3, 0x50, 0x1f, 0x00, 0xca, 0x6e, 0x6d, 0x79, 0x51, 0x8c, 0x7e,
0x02, 0xc5, 0x88, 0x69, 0xc8, 0x76, 0xa9, 0x7b, 0xd7, 0x32, 0x3a, 0x71, 0xe5, 0xb1, 0x58, 0x82,
0x3e, 0x00, 0x6d, 0xee, 0xac, 0x68, 0x37, 0x7f, 0x5f, 0x7e, 0xa0, 0xe0, 0xad, 0xec, 0x61, 0x91,
0xde, 0x05, 0x65, 0xdf, 0x23, 0x03, 0x77, 0x2d, 0x19, 0xd1, 0x5d, 0x80, 0xd7, 0x74, 0x17, 0x5f,
0xc3, 0x35, 0x57, 0x5e, 0x27, 0x7c, 0xf4, 0x7f, 0x48, 0x50, 0x3a, 0x72, 0x46, 0x23, 0xcf, 0xef,
0xaf, 0x27, 0xf8, 0x02, 0x01, 0xf2, 0x0b, 0x05, 0xa0, 0x5c, 0x7b, 0x6f, 0xc8, 0xd0, 0xd9, 0x95,
0x17, 0x71, 0x65, 0x53, 0x58, 0x2c, 0x41, 0x9f, 0x42, 0x85, 0xbc, 0x8b, 0x43, 0xc7, 0x1e, 0x39,
0xa1, 0x33, 0x8c, 0x76, 0x0b, 0xf7, 0xe5, 0x07, 0xea, 0xde, 0xad, 0xcc, 0x96, 0xb4, 0x97, 0xb1,
0xca, 0x96, 0x1f, 0xb3, 0xd5, 0x7a, 0x04, 0xaa, 0xd0, 0x65, 0x7d, 0x47, 0x3c, 0x81, 0xca, 0x90,
0xef, 0xb5, 0x07, 0x5e, 0x14, 0x33, 0x27, 0xa8, 0x7b, 0x3b, 0x99, 0x2d, 0x82, 0x39, 0x56, 0x87,
0xb3, 0x53, 0xf4, 0xe7, 0xb0, 0x79, 0xec, 0x84, 0xb1, 0x47, 0x15, 0x66, 0x72, 0xac, 0xee, 0x1b,
0x0d, 0xe4, 0xd8, 0xe9, 0x0b, 0xbb, 0xd1, 0xa1, 0x3e, 0x80, 0xea, 0x94, 0xd9, 0xfa, 0x3a, 0x3c,
0x82, 0x6b, 0xa3, 0x64, 0xb7, 0x1d, 0x3b, 0x7d, 0xdb, 0x09, 0x43, 0x67, 0x22, 0xe2, 0x69, 0x7b,
0x3a, 0x65, 0x39, 0xfd, 0x1a, 0x9d, 0xd0, 0x5f, 0xc0, 0xd6, 0x4b, 0xd2, 0x8b, 0x83, 0x10, 0x07,
0x67, 0x98, 0xf4, 0x82, 0xd0, 0x65, 0xe1, 0x32, 0x08, 0x9c, 0xd8, 0x76, 0x9d, 0xd8, 0xd9, 0x95,
0xee, 0xcb, 0x0f, 0xf2, 0x58, 0x61, 0x94, 0xa6, 0x13, 0x3b, 0xe8, 0x1e, 0xa8, 0xa7, 0x9e, 0xef,
0x84, 0x13, 0x3e, 0x4f, 0x25, 0xaf, 0x60, 0xe0, 0x24, 0xba, 0x40, 0xff, 0x35, 0x28, 0x86, 0x1f,
0x7b, 0xf1, 0xc4, 0x74, 0xa3, 0xf5, 0x84, 0xff, 0x11, 0x6c, 0x11, 0xb6, 0xd3, 0xf6, 0xdc, 0x94,
0xe0, 0x32, 0xae, 0x12, 0xc1, 0x90, 0x0b, 0xbd, 0x0f, 0x15, 0x21, 0x34, 0x97, 0xf8, 0x31, 0x94,
0x42, 0x36, 0x8a, 0x98, 0xb8, 0xea, 0xde, 0x7b, 0x99, 0x53, 0xe6, 0x14, 0xc4, 0xc9, 0x62, 0xfd,
0x1b, 0x50, 0xf9, 0x1c, 0x77, 0x1a, 0x82, 0xc2, 0x6f, 0x68, 0x51, 0xe1, 0x9e, 0x62, 0x63, 0xf4,
0x14, 0x20, 0x0c, 0xce, 0x6c, 0xbe, 0x83, 0x29, 0x3b, 0x1f, 0x8b, 0x69, 0x49, 0xb0, 0x12, 0x26,
0xa7, 0xe8, 0x7d, 0x91, 0xab, 0x47, 0x24, 0x76, 0xe6, 0x52, 0x50, 0x9a, 0x4b, 0x41, 0xf4, 0x01,
0x14, 0xe2, 0xc9, 0x88, 0xa7, 0xcf, 0xe6, 0xde, 0xf5, 0x0c, 0x7f, 0x6a, 0x53, 0x6b, 0x32, 0x22,
0x98, 0x2d, 0xa1, 0x01, 0xe3, 0x7a, 0x43, 0x96, 0x48, 0x32, 0xa6, 0x43, 0xbd, 0x06, 0x45, 0x9e,
0x42, 0xe8, 0x09, 0xa8, 0xfc, 0x94, 0x21, 0x89, 0x9d, 0xc4, 0x16, 0xd9, 0x7a, 0x3a, 0x15, 0x09,
0x73, 0x81, 0xe8, 0x30, 0xd2, 0xef, 0x42, 0x09, 0x07, 0x67, 0xcc, 0xbd, 0x08, 0x0a, 0xa7, 0x83,
0xe0, 0x94, 0xc9, 0x58, 0xc1, 0x6c, 0xac, 0xff, 0x25, 0x0f, 0xaa, 0xe9, 0x47, 0x24, 0x8c, 0xd7,
0x8c, 0xee, 0x59, 0xe2, 0xe7, 0x2f, 0x4f, 0xfc, 0x8f, 0x80, 0x5a, 0x2f, 0xe2, 0x61, 0x25, 0x2f,
0xc8, 0x3d, 0x21, 0x22, 0x2e, 0xd3, 0x65, 0x4c, 0xd8, 0x05, 0x01, 0x53, 0x58, 0x10, 0x30, 0xe8,
0xff, 0xa1, 0x9a, 0xc9, 0x8a, 0xdd, 0x0d, 0x26, 0x6e, 0x25, 0x9d, 0x0f, 0xe7, 0x0a, 0x4f, 0x71,
0xad, 0xc2, 0xf3, 0x6f, 0x09, 0xd4, 0x2e, 0x71, 0xc2, 0xde, 0x9b, 0x35, 0x6d, 0xf4, 0x0c, 0x2a,
0x6f, 0x59, 0x08, 0xf1, 0x73, 0x45, 0xd5, 0xd9, 0x5d, 0x10, 0x63, 0x8c, 0x31, 0x56, 0xdf, 0xa6,
0x42, 0x96, 0x46, 0x43, 0x34, 0x60, 0xd1, 0xa0, 0x60, 0x3a, 0x3c, 0xaf, 0x6a, 0x81, 0xa5, 0xfe,
0xc5, 0xaa, 0x6e, 0xac, 0xa5, 0xea, 0x19, 0xec, 0x70, 0x4d, 0x4d, 0xbf, 0x4b, 0xfa, 0x43, 0xe2,
0x8b, 0xb0, 0xd0, 0xa1, 0xfa, 0xda, 0x1b, 0x90, 0x99, 0x2f, 0x24, 0x76, 0xb4, 0x4a, 0x89, 0x89,
0x27, 0x9e, 0x41, 0x25, 0x62, 0x7b, 0xa7, 0xda, 0x4a, 0xe7, 0xb4, 0x4d, 0x99, 0x11, 0xab, 0xd1,
0xec, 0x87, 0xfe, 0x27, 0x09, 0xca, 0xac, 0xb4, 0x78, 0x64, 0xcd, 0xca, 0xa2, 0x81, 0xec, 0xb9,
0x91, 0xa8, 0x26, 0x74, 0x88, 0xee, 0x80, 0xf2, 0xd6, 0x19, 0x78, 0xae, 0x1d, 0x06, 0x67, 0x2c,
0xda, 0xca, 0xb8, 0xcc, 0x08, 0x38, 0x38, 0xcb, 0x86, 0x62, 0x61, 0x95, 0x50, 0xd4, 0xff, 0x96,
0x07, 0xf5, 0xc5, 0x98, 0x84, 0x13, 0x4c, 0xa2, 0xf1, 0x60, 0xcd, 0xaa, 0xfd, 0x11, 0x94, 0x89,
0xd0, 0x4b, 0x58, 0x24, 0x5b, 0x03, 0x12, 0xa5, 0xf1, 0x74, 0x19, 0xba, 0x09, 0x25, 0x5a, 0x98,
0xfc, 0x71, 0x52, 0x0b, 0x8a, 0x61, 0x70, 0xd6, 0x1e, 0x0f, 0x29, 0x38, 0x8a, 0x7a, 0x41, 0x48,
0xf8, 0xcd, 0x99, 0xc7, 0xe2, 0x17, 0x7a, 0x0f, 0x14, 0xd7, 0x8b, 0x62, 0xc7, 0xef, 0x11, 0xee,
0xf0, 0x3c, 0x9e, 0x11, 0xae, 0x16, 0xfc, 0xe8, 0x16, 0x94, 0x7f, 0x4b, 0x75, 0xb7, 0x3d, 0x77,
0xb7, 0xc4, 0xa4, 0x29, 0xb1, 0xdf, 0xa6, 0x4b, 0xed, 0xdc, 0x1b, 0x78, 0xc4, 0x8f, 0xe9, 0x5c,
0x99, 0xcd, 0x95, 0x39, 0xc1, 0x74, 0xf5, 0x5f, 0x81, 0xda, 0x8d, 0x43, 0x7a, 0x9f, 0x92, 0xd1,
0x60, 0xb2, 0x9e, 0xcd, 0xde, 0x87, 0x4a, 0xc4, 0xf6, 0xda, 0x21, 0xdd, 0x2c, 0xae, 0x50, 0x35,
0x9a, 0xf1, 0xd3, 0x5f, 0x81, 0x52, 0x0f, 0x82, 0xc1, 0x0f, 0x60, 0x7e, 0x17, 0xe0, 0x34, 0x08,
0x06, 0x29, 0xd6, 0x65, 0xac, 0x9c, 0x26, 0xbc, 0xf4, 0x28, 0x8d, 0xfa, 0x70, 0x70, 0xd6, 0x08,
0xc6, 0xfe, 0x9a, 0x2e, 0xff, 0x10, 0x76, 0x52, 0xf5, 0x81, 0xba, 0xb2, 0x47, 0x99, 0xb0, 0xb3,
0x64, 0x8c, 0x7a, 0xe7, 0xd8, 0xeb, 0x77, 0xa0, 0xd4, 0x08, 0x86, 0x43, 0xc7, 0x77, 0x69, 0x38,
0xf7, 0x86, 0x6e, 0x02, 0x6c, 0x7b, 0x43, 0x57, 0xff, 0xa7, 0x04, 0x60, 0xfa, 0x2e, 0x79, 0xc7,
0x53, 0xf1, 0x7f, 0x83, 0xe3, 0xb2, 0xb7, 0x98, 0x3c, 0x7f, 0x8b, 0xdd, 0x05, 0xf0, 0xa8, 0x08,
0x7c, 0xba, 0xc0, 0xa7, 0x19, 0x85, 0x4d, 0x5f, 0xad, 0xe8, 0x7c, 0x01, 0xb0, 0x3f, 0x18, 0x47,
0xa2, 0xba, 0xee, 0xc1, 0xf5, 0x39, 0x91, 0x33, 0x25, 0xe7, 0x5a, 0x56, 0x70, 0x8e, 0x1a, 0x4e,
0xa0, 0xd2, 0x08, 0x86, 0x23, 0xa7, 0xb7, 0xee, 0x2d, 0xf6, 0x1e, 0x28, 0xf1, 0x9b, 0x90, 0x44,
0x6f, 0x82, 0x01, 0x87, 0x00, 0x12, 0x9e, 0x11, 0xf4, 0x13, 0xd8, 0x6a, 0x92, 0x01, 0x89, 0x49,
0x7d, 0x62, 0x36, 0xd7, 0xe4, 0x7c, 0x0b, 0xca, 0x73, 0x48, 0xa7, 0xe4, 0x09, 0x8c, 0xf3, 0x75,
0xba, 0x27, 0x31, 0xfd, 0xd7, 0xc1, 0x7a, 0x3e, 0xbd, 0x03, 0x0a, 0xc5, 0x2f, 0xb6, 0xe7, 0xbf,
0x0e, 0x84, 0x37, 0xcb, 0x94, 0x40, 0x39, 0xe9, 0xdf, 0xc0, 0xf6, 0x01, 0x89, 0x05, 0x48, 0x6b,
0x46, 0x6b, 0x0a, 0x7d, 0x17, 0x20, 0xe2, 0x65, 0x9f, 0xa6, 0x34, 0x8f, 0x57, 0x45, 0x50, 0x4c,
0x57, 0x1f, 0xc3, 0x66, 0x02, 0xff, 0xf8, 0x25, 0xfc, 0xdf, 0x30, 0x07, 0x45, 0x9d, 0xb3, 0xd0,
0x8b, 0x58, 0xc1, 0x56, 0x04, 0x84, 0xe1, 0xad, 0xd1, 0x87, 0xa0, 0xf1, 0x5b, 0x92, 0x21, 0x1c,
0xae, 0x12, 0x2b, 0x79, 0x43, 0xe2, 0x47, 0x9e, 0x40, 0x75, 0x32, 0x9e, 0x11, 0xf4, 0x3f, 0x48,
0x02, 0xa1, 0x51, 0x74, 0x85, 0x3e, 0x01, 0x85, 0x56, 0x7b, 0x9b, 0xe1, 0x30, 0xe9, 0x02, 0x1c,
0x76, 0x98, 0xc3, 0x65, 0x57, 0x8c, 0x51, 0xfd, 0xdc, 0xe5, 0x4d, 0x3d, 0x73, 0x77, 0xc1, 0xe5,
0x3d, 0x13, 0xeb, 0x30, 0x97, 0xb9, 0xc3, 0xeb, 0x25, 0xd1, 0x93, 0xea, 0xdf, 0x49, 0x00, 0x29,
0xe9, 0x37, 0x21, 0xef, 0xf1, 0x1c, 0x2f, 0xe0, 0xbc, 0xe7, 0x52, 0x64, 0x96, 0xca, 0x4d, 0x36,
0x9e, 0x02, 0x47, 0xf9, 0x72, 0xe0, 0xf8, 0x29, 0x54, 0x78, 0x76, 0xae, 0xdc, 0x57, 0x79, 0xd3,
0x7a, 0x12, 0x5d, 0x31, 0x79, 0x0f, 0x60, 0x3b, 0x65, 0x05, 0x81, 0xda, 0xf7, 0x92, 0x5e, 0x7c,
0x15, 0xcc, 0x2e, 0x4c, 0xf4, 0xbd, 0x04, 0x8a, 0x45, 0xc2, 0x21, 0xbb, 0x69, 0x2f, 0x43, 0xd5,
0x77, 0x40, 0xf1, 0xfc, 0xd8, 0x4e, 0x1a, 0x7e, 0x1a, 0x4f, 0x65, 0xcf, 0x8f, 0x99, 0x8c, 0xf4,
0xfa, 0x70, 0x83, 0xf1, 0xe9, 0x80, 0x88, 0x79, 0x1a, 0x51, 0x12, 0x56, 0x39, 0x8d, 0x2f, 0xe1,
0x10, 0x61, 0x4c, 0xd8, 0x25, 0x5b, 0xe0, 0x57, 0x17, 0x23, 0xd0, 0x6b, 0x76, 0x07, 0x36, 0x4e,
0x83, 0x20, 0x8a, 0x19, 0x94, 0xcc, 0x63, 0xfe, 0xe3, 0x8a, 0x18, 0xd2, 0x01, 0x95, 0x55, 0xa8,
0x90, 0x18, 0xef, 0x46, 0x21, 0x7a, 0x0a, 0xe5, 0x60, 0x44, 0x42, 0x27, 0x0e, 0x42, 0x11, 0x91,
0x59, 0x1b, 0x89, 0xb5, 0x1d, 0xb1, 0x06, 0x4f, 0x57, 0xa3, 0x5d, 0x28, 0xb1, 0xb1, 0xef, 0x8a,
0x68, 0x49, 0x7e, 0xea, 0x7f, 0x97, 0x00, 0xb0, 0xe3, 0xf7, 0xc9, 0x4a, 0x16, 0xdc, 0x4b, 0xf3,
0x39, 0x0f, 0x4b, 0x53, 0xc2, 0x4e, 0x4f, 0x98, 0x19, 0x46, 0xbe, 0xc8, 0x30, 0xeb, 0x75, 0xf5,
0xdf, 0x49, 0x49, 0xa7, 0xb6, 0x92, 0xd8, 0xf7, 0x40, 0xe5, 0x70, 0x84, 0x0b, 0x92, 0x67, 0x82,
0x00, 0x23, 0xd5, 0x99, 0x34, 0xa9, 0x86, 0x51, 0x5e, 0xa3, 0x61, 0xa4, 0x29, 0x18, 0x07, 0xa3,
0x6f, 0x45, 0x30, 0xb0, 0xf1, 0x15, 0x33, 0xe3, 0x1d, 0x54, 0x28, 0x44, 0x21, 0x8e, 0xcf, 0x35,
0x7b, 0x00, 0x1b, 0x41, 0xaf, 0x37, 0x4e, 0x1c, 0x8e, 0x32, 0x6c, 0x3a, 0x74, 0x06, 0xf3, 0x05,
0xe8, 0x73, 0xa8, 0xf6, 0x89, 0x4f, 0x42, 0x67, 0x60, 0x33, 0xcd, 0x84, 0x87, 0xb2, 0x07, 0x1f,
0xf0, 0x15, 0x1c, 0x98, 0x56, 0xfa, 0xa9, 0x5f, 0xfa, 0xef, 0xf3, 0x50, 0x49, 0x4f, 0xa3, 0x2f,
0xa0, 0x7a, 0xca, 0x45, 0x11, 0x0c, 0xa5, 0x05, 0xdd, 0x6e, 0x5a, 0xd8, 0xc3, 0x1c, 0xae, 0x9c,
0xa6, 0x85, 0x7f, 0x02, 0x10, 0x93, 0x70, 0x38, 0x95, 0x47, 0x3a, 0xd7, 0x7e, 0x4e, 0x73, 0xf7,
0x30, 0x87, 0x95, 0x78, 0x9a, 0xc8, 0x3f, 0x07, 0x35, 0xa4, 0x41, 0x29, 0x76, 0xf2, 0x57, 0xa2,
0x9b, 0x59, 0xc4, 0x3d, 0x0d, 0xda, 0xc3, 0x1c, 0x86, 0x70, 0x16, 0xc2, 0x9f, 0x4d, 0x4b, 0x30,
0xdf, 0x5c, 0x58, 0xd0, 0x51, 0xa4, 0x62, 0x67, 0x56, 0x7d, 0xd9, 0x4f, 0x5a, 0x7d, 0xd9, 0x3e,
0xfd, 0x5f, 0x12, 0x54, 0x53, 0x9d, 0xc7, 0x71, 0x7d, 0xf5, 0x7b, 0x6b, 0xcd, 0x47, 0x97, 0xf3,
0xae, 0x93, 0x17, 0x58, 0x7a, 0xb9, 0xeb, 0xae, 0x98, 0x4c, 0xbf, 0x93, 0x61, 0x9b, 0x77, 0xf3,
0x9d, 0x90, 0x23, 0x97, 0xa3, 0xa8, 0xbf, 0xba, 0xb2, 0x99, 0xde, 0x88, 0xfb, 0xf8, 0xb2, 0x36,
0x5d, 0x03, 0x79, 0xec, 0xb9, 0xc9, 0x9b, 0xc5, 0xd8, 0x73, 0x17, 0x75, 0xa9, 0xe7, 0x1b, 0x72,
0x8a, 0xbb, 0xbc, 0x21, 0x89, 0x62, 0x67, 0x38, 0x62, 0x65, 0xb6, 0x80, 0x67, 0x84, 0x39, 0x18,
0x52, 0x9c, 0x83, 0x21, 0x74, 0xba, 0xf7, 0xc6, 0xf1, 0x7d, 0x32, 0x98, 0x35, 0x25, 0x8a, 0xa0,
0x98, 0x54, 0x80, 0x7c, 0x30, 0x62, 0xfd, 0xc8, 0xe6, 0x1c, 0x90, 0xea, 0x8c, 0xd8, 0xa5, 0x99,
0x0f, 0x46, 0xd9, 0xde, 0x45, 0xc9, 0xf6, 0x2e, 0xe7, 0x9c, 0x00, 0x6b, 0x39, 0xe1, 0xcf, 0x79,
0x50, 0x78, 0xb4, 0xad, 0x65, 0xfc, 0x54, 0xe1, 0xe2, 0xa6, 0x5f, 0xb1, 0x70, 0x9d, 0xb3, 0xb7,
0xbc, 0xc0, 0xde, 0xc2, 0x4d, 0x85, 0x99, 0x9b, 0x2e, 0xf6, 0x40, 0xc6, 0x3c, 0xc5, 0x4b, 0xcc,
0x53, 0x5a, 0xb3, 0x2c, 0xaa, 0x96, 0x37, 0x24, 0xdd, 0x89, 0xdf, 0xa3, 0xf6, 0xb9, 0x09, 0xa5,
0x11, 0x21, 0xa1, 0x6d, 0xba, 0x02, 0xc6, 0x15, 0xe9, 0x4f, 0x93, 0x09, 0x68, 0x4d, 0x05, 0xcc,
0xcf, 0x0b, 0xb8, 0x07, 0x4a, 0x34, 0xf1, 0x7b, 0xf6, 0x52, 0x88, 0x44, 0xf9, 0x33, 0x6f, 0x97,
0x23, 0x31, 0xd2, 0xbf, 0x01, 0x78, 0x4e, 0x26, 0x7b, 0x5d, 0xd2, 0xa7, 0x07, 0x0b, 0x93, 0x48,
0x4b, 0x4c, 0x92, 0xbf, 0x38, 0x28, 0x65, 0x86, 0x39, 0x66, 0x41, 0xf9, 0xf0, 0xaf, 0x05, 0x50,
0xa6, 0x5f, 0x34, 0x90, 0x0a, 0xa5, 0xee, 0x49, 0xa3, 0x61, 0x74, 0xbb, 0x5a, 0x0e, 0xed, 0x80,
0x76, 0xd2, 0x36, 0xbe, 0x3c, 0x36, 0x1a, 0x96, 0xd1, 0xb4, 0x0d, 0x8c, 0x3b, 0x58, 0x93, 0x10,
0x82, 0xcd, 0x46, 0xa7, 0xdd, 0x36, 0x1a, 0x96, 0xbd, 0x5f, 0x33, 0x5b, 0x46, 0x53, 0xcb, 0xa3,
0xeb, 0xb0, 0x7d, 0x6c, 0xe0, 0x23, 0xb3, 0xdb, 0x35, 0x3b, 0x6d, 0xbb, 0x69, 0xb4, 0x4d, 0xa3,
0xa9, 0xc9, 0xe8, 0x16, 0x5c, 0x6f, 0x74, 0x5a, 0x2d, 0xa3, 0x61, 0x51, 0x72, 0xbb, 0x63, 0xd9,
0xc6, 0x97, 0x66, 0xd7, 0xea, 0x6a, 0x05, 0xca, 0xdb, 0x6c, 0xb5, 0x8c, 0x83, 0x5a, 0xcb, 0xae,
0xe1, 0x83, 0x93, 0x23, 0xa3, 0x6d, 0x69, 0x1b, 0x94, 0x4f, 0x42, 0x6d, 0x9a, 0x47, 0x46, 0x9b,
0xb2, 0xd3, 0x4a, 0xe8, 0x06, 0xa0, 0x84, 0x6c, 0xb6, 0x9b, 0xc6, 0x97, 0xb6, 0xf5, 0xd5, 0xb1,
0xa1, 0x95, 0xd1, 0x1d, 0xb8, 0x99, 0xd0, 0xd3, 0xe7, 0xd4, 0x8e, 0x0c, 0x4d, 0x41, 0x1a, 0x54,
0x92, 0x49, 0xab, 0x73, 0xfc, 0x5c, 0x83, 0x34, 0x77, 0xdc, 0x79, 0x85, 0x8d, 0x46, 0x07, 0x37,
0x35, 0x35, 0x4d, 0x7e, 0x69, 0x34, 0xac, 0x0e, 0xb6, 0xcd, 0xa6, 0x56, 0xa1, 0xc2, 0x27, 0xe4,
0xae, 0x51, 0xc3, 0x8d, 0x43, 0x1b, 0x1b, 0xdd, 0x93, 0x96, 0xa5, 0x55, 0xa9, 0x09, 0xf6, 0xcd,
0x96, 0xc1, 0x34, 0xda, 0xef, 0x9c, 0xb4, 0x9b, 0xda, 0x26, 0xda, 0x02, 0xf5, 0xc8, 0xb0, 0x6a,
0x89, 0x4d, 0xb6, 0xe8, 0xf9, 0x8d, 0x5a, 0xe3, 0xd0, 0x48, 0x28, 0x1a, 0xda, 0x85, 0x9d, 0x46,
0xad, 0x4d, 0x37, 0x35, 0xb0, 0x51, 0xb3, 0x0c, 0x7b, 0xbf, 0xd3, 0x6a, 0x1a, 0x58, 0xdb, 0xa6,
0x0a, 0xce, 0xcd, 0x98, 0x2d, 0x43, 0x43, 0xa9, 0x1d, 0x4d, 0xa3, 0x65, 0xcc, 0x76, 0x5c, 0x4b,
0xed, 0x48, 0x66, 0xe8, 0x8e, 0x1d, 0xaa, 0x4c, 0xfd, 0xc4, 0x6c, 0x35, 0x85, 0xa1, 0xb8, 0xd3,
0xae, 0xa3, 0x6d, 0xa8, 0x26, 0xca, 0xb4, 0x5b, 0x66, 0xd7, 0xd2, 0x6e, 0xa0, 0x9b, 0x70, 0x2d,
0x21, 0x1d, 0x19, 0x16, 0x36, 0x1b, 0xdc, 0xaa, 0x37, 0xe9, 0xda, 0xce, 0x89, 0x65, 0x77, 0xf6,
0xed, 0x23, 0xe3, 0xa8, 0x83, 0xbf, 0xd2, 0x76, 0x1f, 0xfe, 0x51, 0x82, 0x72, 0x82, 0xdd, 0x51,
0x19, 0x0a, 0xed, 0x4e, 0xdb, 0xd0, 0x72, 0x74, 0x54, 0xef, 0x74, 0x5a, 0x9a, 0x44, 0x47, 0x66,
0xdb, 0x7a, 0xaa, 0xe5, 0x91, 0x02, 0x1b, 0x66, 0xdb, 0xfa, 0xe8, 0xb1, 0x26, 0x8b, 0xe1, 0xc7,
0x7b, 0x5a, 0x41, 0x0c, 0x1f, 0x7f, 0xa2, 0x6d, 0xd0, 0xe1, 0x7e, 0xab, 0x53, 0xb3, 0x34, 0x40,
0x00, 0xc5, 0x66, 0xe7, 0xa4, 0xde, 0x32, 0x34, 0x95, 0x8e, 0xbb, 0x16, 0x36, 0xdb, 0x07, 0xda,
0x0e, 0x95, 0x40, 0x78, 0xa2, 0x6e, 0xb6, 0x6b, 0xf8, 0x2b, 0xcd, 0xa5, 0xd6, 0x14, 0x24, 0xbe,
0x99, 0x3c, 0x6c, 0xc0, 0xd6, 0x1c, 0xda, 0x44, 0x45, 0xc8, 0xb7, 0x2c, 0x2d, 0x87, 0x4a, 0x20,
0xb7, 0x2c, 0x43, 0x93, 0x28, 0xc1, 0x78, 0xa1, 0xe5, 0xe9, 0xdf, 0x03, 0x4b, 0x93, 0xe9, 0xc4,
0x81, 0x65, 0x68, 0x05, 0x4a, 0x68, 0x1b, 0xda, 0xc6, 0xc3, 0xa7, 0xb0, 0xc1, 0x10, 0x0c, 0x0d,
0x7c, 0xb3, 0xfd, 0xb2, 0xd6, 0x32, 0x9b, 0x5c, 0xaf, 0xa3, 0x93, 0xae, 0xa5, 0x49, 0x4c, 0xaa,
0xc3, 0xce, 0x49, 0x8b, 0x06, 0x79, 0x05, 0xca, 0x94, 0x4a, 0xbd, 0xae, 0xc9, 0x0f, 0xef, 0x43,
0x91, 0x97, 0x65, 0xba, 0xc6, 0x6c, 0x77, 0x0d, 0x4c, 0x4f, 0xa6, 0x1a, 0x31, 0x7f, 0x68, 0xd2,
0xc3, 0x7b, 0x50, 0x4e, 0x92, 0x99, 0x72, 0xc4, 0x46, 0x8d, 0xf2, 0x56, 0x60, 0xe3, 0x15, 0x36,
0xe9, 0x82, 0xbd, 0xef, 0xab, 0x50, 0x3d, 0x62, 0xa9, 0xdf, 0x25, 0xe1, 0x5b, 0xaf, 0x47, 0xd0,
0x2f, 0x40, 0x6b, 0x84, 0xc4, 0x89, 0xc9, 0xac, 0xcf, 0x46, 0x0b, 0x3f, 0xf6, 0xdc, 0x5e, 0xd4,
0x69, 0xeb, 0x39, 0xb4, 0x0f, 0xd5, 0x43, 0x27, 0x4a, 0xed, 0xbe, 0x33, 0x87, 0x8e, 0xd3, 0xa5,
0xfb, 0xf6, 0x8d, 0x73, 0x38, 0x8a, 0xbf, 0x25, 0xe5, 0x90, 0x09, 0xa8, 0x49, 0xa2, 0x5e, 0xe8,
0x9d, 0x92, 0x55, 0x99, 0x2d, 0x94, 0x53, 0xcf, 0xa1, 0x17, 0xd4, 0x4f, 0x63, 0x3f, 0x5e, 0x95,
0xcf, 0xbd, 0x25, 0x93, 0xd3, 0x47, 0xa7, 0x1c, 0xfa, 0x25, 0x6c, 0x75, 0xdf, 0xd0, 0x9f, 0xc9,
0x5c, 0x34, 0x67, 0x25, 0xf1, 0x28, 0xb5, 0x94, 0x57, 0xf2, 0x55, 0x54, 0xcf, 0xa1, 0x63, 0x40,
0x59, 0x5e, 0xec, 0x61, 0xe3, 0x42, 0x09, 0x97, 0x4d, 0xb2, 0x87, 0x8c, 0x1c, 0x6a, 0xc2, 0x66,
0x33, 0x0c, 0x46, 0xab, 0xea, 0xbb, 0xc4, 0x93, 0x9f, 0x81, 0xca, 0x43, 0x81, 0x3d, 0xa1, 0xa1,
0x2c, 0xf2, 0x9c, 0x3d, 0xab, 0x2d, 0xdb, 0xde, 0x80, 0x6a, 0xe2, 0xc0, 0x4b, 0x18, 0x2c, 0x9b,
0xd0, 0x73, 0xe8, 0x19, 0x28, 0x54, 0x93, 0x1f, 0x26, 0x81, 0x01, 0x5b, 0x5c, 0x81, 0xe9, 0xa7,
0xc3, 0x39, 0x3b, 0x64, 0xbf, 0x4f, 0x2e, 0x67, 0x53, 0x39, 0x74, 0xa2, 0x15, 0x79, 0x2c, 0x0f,
0xe8, 0xe7, 0xb0, 0x49, 0xdd, 0x3c, 0x5d, 0x1f, 0x5d, 0xec, 0x94, 0xdb, 0x8b, 0x4f, 0x11, 0x31,
0x43, 0x8d, 0x1b, 0x06, 0xa3, 0xab, 0x29, 0xf6, 0x29, 0x14, 0x39, 0xe4, 0x45, 0xbb, 0x73, 0x96,
0x9d, 0x7e, 0xd5, 0x9a, 0xd3, 0x67, 0xfa, 0x09, 0x93, 0x99, 0xa5, 0x3a, 0x7d, 0x2f, 0xab, 0x4f,
0xcc, 0xe6, 0x9c, 0x08, 0xd9, 0xe7, 0xae, 0xdb, 0x8b, 0x9f, 0xee, 0xf5, 0x1c, 0x3a, 0xa4, 0x0d,
0xd7, 0xec, 0xd9, 0x0d, 0xfd, 0xdf, 0x1c, 0xde, 0x9f, 0x7b, 0x91, 0xbb, 0x40, 0xa0, 0xcf, 0xa1,
0xc8, 0xc1, 0x23, 0x5a, 0xfa, 0xe5, 0xe4, 0x76, 0x76, 0x26, 0xf5, 0x69, 0x82, 0xe5, 0xe1, 0xd6,
0xdc, 0x17, 0x1c, 0xf4, 0xfe, 0x02, 0x46, 0xd9, 0xef, 0x3b, 0x17, 0x72, 0x7c, 0x02, 0x72, 0x63,
0xe8, 0x2e, 0xa9, 0x0c, 0x73, 0x42, 0xa6, 0x5e, 0xe8, 0x73, 0xa8, 0x06, 0x30, 0x7b, 0x3e, 0x45,
0x59, 0x38, 0x3b, 0xf7, 0xae, 0xba, 0xcc, 0xb9, 0x07, 0xb0, 0x7d, 0x1c, 0x92, 0x41, 0xe0, 0xb8,
0x57, 0x2c, 0x03, 0x4f, 0x60, 0x83, 0xbd, 0x31, 0xcf, 0xa5, 0xdf, 0xec, 0xdd, 0x79, 0xd9, 0xc6,
0x67, 0xec, 0x69, 0x7e, 0xe4, 0xf4, 0x62, 0x74, 0xeb, 0xfc, 0x0b, 0x89, 0x78, 0x70, 0x5e, 0xb6,
0xb9, 0x0e, 0x65, 0xe1, 0xb7, 0x3a, 0xba, 0xbd, 0xcc, 0x9d, 0xc7, 0xf5, 0x8b, 0xcc, 0x5f, 0x2f,
0x7d, 0xbd, 0x31, 0x8c, 0xfa, 0xa3, 0xd3, 0xd3, 0x22, 0xfb, 0x7f, 0x9b, 0x8f, 0xff, 0x13, 0x00,
0x00, 0xff, 0xff, 0xaf, 0xd6, 0x20, 0xc1, 0x80, 0x23, 0x00, 0x00,
// 2876 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x3a, 0xdd, 0x72, 0xdb, 0xc6,
0xd5, 0x04, 0x41, 0x91, 0xc4, 0x01, 0x29, 0x41, 0x6b, 0xd9, 0x96, 0xed, 0xf8, 0xb3, 0x83, 0x6f,
0xa6, 0x75, 0xdc, 0x19, 0x4f, 0xa2, 0xa4, 0xb6, 0x5b, 0x27, 0x69, 0xf8, 0x03, 0x49, 0xa8, 0x29,
0x52, 0x5e, 0x42, 0x76, 0x7e, 0xa6, 0x83, 0x42, 0xc4, 0x9a, 0x46, 0x43, 0x02, 0x2c, 0x00, 0x5a,
0xe6, 0x6d, 0xef, 0xdb, 0x99, 0x5e, 0xf6, 0xb2, 0x7d, 0x84, 0xf6, 0x0d, 0x7a, 0xd9, 0x17, 0xc8,
0x45, 0x66, 0x7a, 0xd9, 0xe9, 0x63, 0x74, 0xf6, 0x07, 0x24, 0x40, 0x91, 0x12, 0x19, 0xb5, 0x57,
0x5a, 0x9e, 0xdd, 0x73, 0xf6, 0xfc, 0xef, 0x39, 0x07, 0x82, 0xea, 0x90, 0x44, 0x91, 0xd3, 0x27,
0x8f, 0x46, 0x61, 0x10, 0x07, 0x48, 0x1d, 0x7a, 0x83, 0xb7, 0xe3, 0xe8, 0x51, 0x3f, 0x1c, 0xf5,
0xf4, 0x57, 0x50, 0xec, 0xc6, 0x4e, 0x3c, 0x8e, 0xd0, 0x4f, 0x01, 0x48, 0x18, 0x06, 0xa1, 0xdd,
0x0b, 0x5c, 0xb2, 0x2b, 0xdd, 0x97, 0x1e, 0x6c, 0xee, 0xdd, 0x78, 0x94, 0x3a, 0xfb, 0xc8, 0xa0,
0xdb, 0x8d, 0xc0, 0x25, 0x58, 0x21, 0xc9, 0x12, 0xdd, 0x80, 0x62, 0x48, 0x9c, 0x28, 0xf0, 0x77,
0xf3, 0xf7, 0xa5, 0x07, 0x0a, 0x16, 0xbf, 0xf4, 0xc7, 0x50, 0x79, 0x4e, 0x26, 0x2f, 0x9d, 0xc1,
0x98, 0x1c, 0x3b, 0x5e, 0x88, 0x34, 0x90, 0xbf, 0x25, 0x13, 0x46, 0x57, 0xc1, 0x74, 0x89, 0x76,
0x60, 0xe3, 0x2d, 0xdd, 0x16, 0x88, 0xfc, 0x87, 0xfe, 0x33, 0xd8, 0x6c, 0x04, 0x83, 0x01, 0xe9,
0xc5, 0x5e, 0xe0, 0xb7, 0x9d, 0x21, 0x41, 0x3f, 0x86, 0xad, 0xde, 0x14, 0x62, 0xfb, 0xce, 0x90,
0x08, 0x2a, 0x9b, 0xbd, 0xcc, 0x41, 0x7d, 0x00, 0x28, 0x8b, 0xda, 0xf2, 0xa2, 0x18, 0xfd, 0x04,
0x8a, 0x11, 0x93, 0x90, 0x61, 0xa9, 0x7b, 0xd7, 0x32, 0x32, 0x71, 0xe1, 0xb1, 0x38, 0x82, 0x3e,
0x00, 0x6d, 0xee, 0xae, 0x68, 0x37, 0x7f, 0x5f, 0x7e, 0xa0, 0xe0, 0xad, 0xec, 0x65, 0x91, 0xde,
0x05, 0x65, 0xdf, 0x23, 0x03, 0x77, 0x2d, 0x1e, 0xd1, 0x5d, 0x80, 0xd7, 0x14, 0x8b, 0x9f, 0xe1,
0x92, 0x2b, 0xaf, 0x13, 0x3a, 0xfa, 0x3f, 0x24, 0x28, 0x1d, 0x39, 0xa3, 0x91, 0xe7, 0xf7, 0xd7,
0x63, 0x7c, 0x01, 0x03, 0xf9, 0x85, 0x0c, 0x50, 0xaa, 0xbd, 0x37, 0x64, 0xe8, 0xec, 0xca, 0x8b,
0xa8, 0xb2, 0x2d, 0x2c, 0x8e, 0xa0, 0x4f, 0xa1, 0x42, 0xde, 0xc5, 0xa1, 0x63, 0x8f, 0x9c, 0xd0,
0x19, 0x46, 0xbb, 0x85, 0xfb, 0xf2, 0x03, 0x75, 0xef, 0x56, 0x06, 0x25, 0x6d, 0x65, 0xac, 0xb2,
0xe3, 0xc7, 0xec, 0xb4, 0x1e, 0x81, 0x2a, 0x64, 0x59, 0xdf, 0x10, 0x4f, 0xa0, 0x32, 0xe4, 0xb8,
0xf6, 0xc0, 0x8b, 0x62, 0x66, 0x04, 0x75, 0x6f, 0x27, 0x83, 0x22, 0x88, 0x63, 0x75, 0x38, 0xbb,
0x45, 0x7f, 0x0e, 0x9b, 0xc7, 0x4e, 0x18, 0x7b, 0x54, 0x60, 0xc6, 0xc7, 0xea, 0xb6, 0xd1, 0x40,
0x8e, 0x9d, 0xbe, 0xd0, 0x1b, 0x5d, 0xea, 0x03, 0xa8, 0x4e, 0x89, 0xad, 0x2f, 0xc3, 0x23, 0xb8,
0x36, 0x4a, 0xb0, 0xed, 0xd8, 0xe9, 0xdb, 0x4e, 0x18, 0x3a, 0x13, 0xe1, 0x4f, 0xdb, 0xd3, 0x2d,
0xcb, 0xe9, 0xd7, 0xe8, 0x86, 0xfe, 0x02, 0xb6, 0x5e, 0x92, 0x5e, 0x1c, 0x84, 0x38, 0x38, 0xc3,
0xa4, 0x17, 0x84, 0x2e, 0x73, 0x97, 0x41, 0xe0, 0xc4, 0xb6, 0xeb, 0xc4, 0xce, 0xae, 0x74, 0x5f,
0x7e, 0x90, 0xc7, 0x0a, 0x83, 0x34, 0x9d, 0xd8, 0x41, 0xf7, 0x40, 0x3d, 0xf5, 0x7c, 0x27, 0x9c,
0xf0, 0x7d, 0xca, 0x79, 0x05, 0x03, 0x07, 0xd1, 0x03, 0xfa, 0xaf, 0x41, 0x31, 0xfc, 0xd8, 0x8b,
0x27, 0xa6, 0x1b, 0xad, 0xc7, 0xfc, 0x8f, 0x60, 0x8b, 0x30, 0x4c, 0xdb, 0x73, 0x53, 0x8c, 0xcb,
0xb8, 0x4a, 0x04, 0x41, 0xce, 0xf4, 0x3e, 0x54, 0x04, 0xd3, 0x9c, 0xe3, 0xc7, 0x50, 0x0a, 0xd9,
0x2a, 0x62, 0xec, 0xaa, 0x7b, 0xef, 0x65, 0x6e, 0x99, 0x13, 0x10, 0x27, 0x87, 0xf5, 0x6f, 0x40,
0xe5, 0x7b, 0xdc, 0x68, 0x08, 0x0a, 0xbf, 0xa1, 0x49, 0x85, 0x5b, 0x8a, 0xad, 0xd1, 0x53, 0x80,
0x30, 0x38, 0xb3, 0x39, 0x06, 0x13, 0x76, 0xde, 0x17, 0xd3, 0x9c, 0x60, 0x25, 0x4c, 0x6e, 0xd1,
0xfb, 0x22, 0x56, 0x8f, 0x48, 0xec, 0xcc, 0x85, 0xa0, 0x34, 0x17, 0x82, 0xe8, 0x03, 0x28, 0xc4,
0x93, 0x11, 0x0f, 0x9f, 0xcd, 0xbd, 0xeb, 0x19, 0xfa, 0x54, 0xa7, 0xd6, 0x64, 0x44, 0x30, 0x3b,
0x42, 0x1d, 0xc6, 0xf5, 0x86, 0x2c, 0x90, 0x64, 0x4c, 0x97, 0x7a, 0x0d, 0x8a, 0x3c, 0x84, 0xd0,
0x13, 0x50, 0xf9, 0x2d, 0x43, 0x12, 0x3b, 0x89, 0x2e, 0xb2, 0xf9, 0x74, 0xca, 0x12, 0xe6, 0x0c,
0xd1, 0x65, 0xa4, 0xdf, 0x85, 0x12, 0x0e, 0xce, 0x98, 0x79, 0x11, 0x14, 0x4e, 0x07, 0xc1, 0x29,
0xe3, 0xb1, 0x82, 0xd9, 0x5a, 0xff, 0x73, 0x1e, 0x54, 0xd3, 0x8f, 0x48, 0x18, 0xaf, 0xe9, 0xdd,
0xb3, 0xc0, 0xcf, 0x5f, 0x1e, 0xf8, 0x1f, 0x01, 0xd5, 0x5e, 0xc4, 0xdd, 0x4a, 0x5e, 0x10, 0x7b,
0x82, 0x45, 0x5c, 0xa6, 0xc7, 0x18, 0xb3, 0x0b, 0x1c, 0xa6, 0xb0, 0xc0, 0x61, 0xd0, 0xff, 0x43,
0x35, 0x13, 0x15, 0xbb, 0x1b, 0x8c, 0xdd, 0x4a, 0x3a, 0x1e, 0xce, 0x25, 0x9e, 0xe2, 0x5a, 0x89,
0xe7, 0xdf, 0x12, 0xa8, 0x5d, 0xe2, 0x84, 0xbd, 0x37, 0x6b, 0xea, 0xe8, 0x19, 0x54, 0xde, 0x32,
0x17, 0xe2, 0xf7, 0x8a, 0xac, 0xb3, 0xbb, 0xc0, 0xc7, 0x18, 0x61, 0xac, 0xbe, 0x4d, 0xb9, 0x2c,
0xf5, 0x86, 0x68, 0xc0, 0xbc, 0x41, 0xc1, 0x74, 0x79, 0x5e, 0xd4, 0x02, 0x0b, 0xfd, 0x8b, 0x45,
0xdd, 0x58, 0x4b, 0xd4, 0x33, 0xd8, 0xe1, 0x92, 0x9a, 0x7e, 0x97, 0xf4, 0x87, 0xc4, 0x17, 0x6e,
0xa1, 0x43, 0xf5, 0xb5, 0x37, 0x20, 0x33, 0x5b, 0x48, 0xec, 0x6a, 0x95, 0x02, 0x13, 0x4b, 0x3c,
0x83, 0x4a, 0xc4, 0x70, 0xa7, 0xd2, 0x4a, 0xe7, 0xa4, 0x4d, 0xa9, 0x11, 0xab, 0xd1, 0xec, 0x87,
0xfe, 0x27, 0x09, 0xca, 0x2c, 0xb5, 0x78, 0x64, 0xcd, 0xcc, 0xa2, 0x81, 0xec, 0xb9, 0x91, 0xc8,
0x26, 0x74, 0x89, 0xee, 0x80, 0xf2, 0xd6, 0x19, 0x78, 0xae, 0x1d, 0x06, 0x67, 0xcc, 0xdb, 0xca,
0xb8, 0xcc, 0x00, 0x38, 0x38, 0xcb, 0xba, 0x62, 0x61, 0x15, 0x57, 0xd4, 0xff, 0x9a, 0x07, 0xf5,
0xc5, 0x98, 0x84, 0x13, 0x4c, 0xa2, 0xf1, 0x60, 0xcd, 0xac, 0xfd, 0x11, 0x94, 0x89, 0x90, 0x4b,
0x68, 0x24, 0x9b, 0x03, 0x12, 0xa1, 0xf1, 0xf4, 0x18, 0xba, 0x09, 0x25, 0x9a, 0x98, 0xfc, 0x71,
0x92, 0x0b, 0x8a, 0x61, 0x70, 0xd6, 0x1e, 0x0f, 0x69, 0x71, 0x14, 0xf5, 0x82, 0x90, 0xf0, 0x97,
0x33, 0x8f, 0xc5, 0x2f, 0xf4, 0x1e, 0x28, 0xae, 0x17, 0xc5, 0x8e, 0xdf, 0x23, 0xdc, 0xe0, 0x79,
0x3c, 0x03, 0x5c, 0xcd, 0xf9, 0xd1, 0x2d, 0x28, 0xff, 0x96, 0xca, 0x6e, 0x7b, 0xee, 0x6e, 0x89,
0x71, 0x53, 0x62, 0xbf, 0x4d, 0x97, 0xea, 0xb9, 0x37, 0xf0, 0x88, 0x1f, 0xd3, 0xbd, 0x32, 0xdb,
0x2b, 0x73, 0x80, 0xe9, 0xea, 0xbf, 0x02, 0xb5, 0x1b, 0x87, 0xf4, 0x3d, 0x25, 0xa3, 0xc1, 0x64,
0x3d, 0x9d, 0xbd, 0x0f, 0x95, 0x88, 0xe1, 0xda, 0x21, 0x45, 0x16, 0x4f, 0xa8, 0x1a, 0xcd, 0xe8,
0xe9, 0xaf, 0x40, 0xa9, 0x07, 0xc1, 0xe0, 0x07, 0x10, 0xbf, 0x0b, 0x70, 0x1a, 0x04, 0x83, 0x14,
0xe9, 0x32, 0x56, 0x4e, 0x13, 0x5a, 0x7a, 0x94, 0xae, 0xfa, 0x70, 0x70, 0xd6, 0x08, 0xc6, 0xfe,
0x9a, 0x26, 0xff, 0x10, 0x76, 0x52, 0xf9, 0x81, 0x9a, 0xb2, 0x47, 0x89, 0xb0, 0xbb, 0x64, 0x8c,
0x7a, 0xe7, 0xc8, 0xeb, 0x77, 0xa0, 0xd4, 0x08, 0x86, 0x43, 0xc7, 0x77, 0xa9, 0x3b, 0xf7, 0x86,
0x6e, 0x52, 0xd8, 0xf6, 0x86, 0xae, 0xfe, 0x4f, 0x09, 0xc0, 0xf4, 0x5d, 0xf2, 0x8e, 0x87, 0xe2,
0xff, 0xa6, 0x8e, 0xcb, 0xbe, 0x62, 0xf2, 0xfc, 0x2b, 0x76, 0x17, 0xc0, 0xa3, 0x2c, 0xf0, 0xed,
0x02, 0xdf, 0x66, 0x10, 0xb6, 0x7d, 0xb5, 0xa4, 0xf3, 0x05, 0xc0, 0xfe, 0x60, 0x1c, 0x89, 0xec,
0xba, 0x07, 0xd7, 0xe7, 0x58, 0xce, 0xa4, 0x9c, 0x6b, 0x59, 0xc6, 0x79, 0xd5, 0x70, 0x02, 0x95,
0x46, 0x30, 0x1c, 0x39, 0xbd, 0x75, 0x5f, 0xb1, 0xf7, 0x40, 0x89, 0xdf, 0x84, 0x24, 0x7a, 0x13,
0x0c, 0x78, 0x09, 0x20, 0xe1, 0x19, 0x40, 0x3f, 0x81, 0xad, 0x26, 0x19, 0x90, 0x98, 0xd4, 0x27,
0x66, 0x73, 0x4d, 0xca, 0xb7, 0xa0, 0x3c, 0x57, 0xe9, 0x94, 0x3c, 0x51, 0xe3, 0x7c, 0x9d, 0xee,
0x49, 0x4c, 0xff, 0x75, 0xb0, 0x9e, 0x4d, 0xef, 0x80, 0x42, 0xeb, 0x17, 0xdb, 0xf3, 0x5f, 0x07,
0xc2, 0x9a, 0x65, 0x0a, 0xa0, 0x94, 0xf4, 0x6f, 0x60, 0xfb, 0x80, 0xc4, 0xa2, 0x48, 0x6b, 0x46,
0x6b, 0x32, 0x7d, 0x17, 0x20, 0xe2, 0x69, 0x9f, 0x86, 0x34, 0xf7, 0x57, 0x45, 0x40, 0x4c, 0x57,
0x1f, 0xc3, 0x66, 0x52, 0xfe, 0xf1, 0x47, 0xf8, 0xbf, 0xa1, 0x0e, 0x5a, 0x75, 0xce, 0x5c, 0x2f,
0x62, 0x09, 0x5b, 0x11, 0x25, 0x0c, 0x6f, 0x8d, 0x3e, 0x04, 0x8d, 0xbf, 0x92, 0xac, 0xc2, 0xe1,
0x22, 0xb1, 0x94, 0x37, 0x24, 0x7e, 0xe4, 0x89, 0xaa, 0x4e, 0xc6, 0x33, 0x80, 0xfe, 0x07, 0x49,
0x54, 0x68, 0xb4, 0xba, 0x42, 0x9f, 0x80, 0x42, 0xb3, 0xbd, 0xcd, 0xea, 0x30, 0xe9, 0x82, 0x3a,
0xec, 0x30, 0x87, 0xcb, 0xae, 0x58, 0xa3, 0xfa, 0xb9, 0xc7, 0x9b, 0x5a, 0xe6, 0xee, 0x82, 0xc7,
0x7b, 0xc6, 0xd6, 0x61, 0x2e, 0xf3, 0x86, 0xd7, 0x4b, 0xa2, 0x27, 0xd5, 0xbf, 0x93, 0x00, 0x52,
0xdc, 0x6f, 0x42, 0xde, 0xe3, 0x31, 0x5e, 0xc0, 0x79, 0xcf, 0xa5, 0x95, 0x59, 0x2a, 0x36, 0xd9,
0x7a, 0x5a, 0x38, 0xca, 0x97, 0x17, 0x8e, 0x9f, 0x42, 0x85, 0x47, 0xe7, 0xca, 0x7d, 0x95, 0x37,
0xcd, 0x27, 0xd1, 0x15, 0x83, 0xf7, 0x00, 0xb6, 0x53, 0x5a, 0x10, 0x55, 0xfb, 0x5e, 0xd2, 0x8b,
0xaf, 0x52, 0xb3, 0x0b, 0x15, 0x7d, 0x2f, 0x81, 0x62, 0x91, 0x70, 0xc8, 0x5e, 0xda, 0xcb, 0xaa,
0xea, 0x3b, 0xa0, 0x78, 0x7e, 0x6c, 0x27, 0x0d, 0x3f, 0xf5, 0xa7, 0xb2, 0xe7, 0xc7, 0x8c, 0x47,
0xfa, 0x7c, 0xb8, 0xc1, 0xf8, 0x74, 0x40, 0xc4, 0x3e, 0xf5, 0x28, 0x09, 0xab, 0x1c, 0xc6, 0x8f,
0xf0, 0x12, 0x61, 0x4c, 0xd8, 0x23, 0x5b, 0xe0, 0x4f, 0x17, 0x03, 0xd0, 0x67, 0x76, 0x07, 0x36,
0x4e, 0x83, 0x20, 0x8a, 0x59, 0x29, 0x99, 0xc7, 0xfc, 0xc7, 0x15, 0x6b, 0x48, 0x07, 0x54, 0x96,
0xa1, 0x42, 0x62, 0xbc, 0x1b, 0x85, 0xe8, 0x29, 0x94, 0x83, 0x11, 0x09, 0x9d, 0x38, 0x08, 0x85,
0x47, 0x66, 0x75, 0x24, 0xce, 0x76, 0xc4, 0x19, 0x3c, 0x3d, 0x8d, 0x76, 0xa1, 0xc4, 0xd6, 0xbe,
0x2b, 0xbc, 0x25, 0xf9, 0xa9, 0xff, 0x4d, 0x02, 0xc0, 0x8e, 0xdf, 0x27, 0x2b, 0x69, 0x70, 0x2f,
0x4d, 0xe7, 0x7c, 0x59, 0x9a, 0x62, 0x76, 0x7a, 0xc3, 0x4c, 0x31, 0xf2, 0x45, 0x8a, 0x59, 0xaf,
0xab, 0xff, 0x4e, 0x4a, 0x3a, 0xb5, 0x95, 0xd8, 0xbe, 0x07, 0x2a, 0x2f, 0x47, 0x38, 0x23, 0x79,
0xc6, 0x08, 0x30, 0x50, 0x9d, 0x71, 0x93, 0x6a, 0x18, 0xe5, 0x35, 0x1a, 0x46, 0x1a, 0x82, 0x71,
0x30, 0xfa, 0x56, 0x38, 0x03, 0x5b, 0x5f, 0x31, 0x32, 0xde, 0x41, 0x85, 0x96, 0x28, 0xc4, 0xf1,
0xb9, 0x64, 0x0f, 0x60, 0x23, 0xe8, 0xf5, 0xc6, 0x89, 0xc1, 0x51, 0x86, 0x4c, 0x87, 0xee, 0x60,
0x7e, 0x00, 0x7d, 0x0e, 0xd5, 0x3e, 0xf1, 0x49, 0xe8, 0x0c, 0x6c, 0x26, 0x99, 0xb0, 0x50, 0xf6,
0xe2, 0x03, 0x7e, 0x82, 0x17, 0xa6, 0x95, 0x7e, 0xea, 0x97, 0xfe, 0xfb, 0x3c, 0x54, 0xd2, 0xdb,
0xe8, 0x0b, 0xa8, 0x9e, 0x72, 0x56, 0x04, 0x41, 0x69, 0x41, 0xb7, 0x9b, 0x66, 0xf6, 0x30, 0x87,
0x2b, 0xa7, 0x69, 0xe6, 0x9f, 0x00, 0xc4, 0x24, 0x1c, 0x4e, 0xf9, 0x91, 0xce, 0xb5, 0x9f, 0xd3,
0xd8, 0x3d, 0xcc, 0x61, 0x25, 0x9e, 0x06, 0xf2, 0xcf, 0x41, 0x0d, 0xa9, 0x53, 0x0a, 0x4c, 0x3e,
0x25, 0xba, 0x99, 0xad, 0xb8, 0xa7, 0x4e, 0x7b, 0x98, 0xc3, 0x10, 0xce, 0x5c, 0xf8, 0xb3, 0x69,
0x0a, 0xe6, 0xc8, 0x85, 0x05, 0x1d, 0x45, 0xca, 0x77, 0x66, 0xd9, 0x97, 0xfd, 0xa4, 0xd9, 0x97,
0xe1, 0xe9, 0xff, 0x92, 0xa0, 0x9a, 0xea, 0x3c, 0x8e, 0xeb, 0xab, 0xbf, 0x5b, 0x6b, 0x0e, 0x5d,
0xce, 0x9b, 0x4e, 0x5e, 0xa0, 0xe9, 0xe5, 0xa6, 0xbb, 0x62, 0x30, 0xfd, 0x4e, 0x86, 0x6d, 0xde,
0xcd, 0x77, 0x42, 0x5e, 0xb9, 0x1c, 0x45, 0xfd, 0xd5, 0x85, 0xcd, 0xf4, 0x46, 0xdc, 0xc6, 0x97,
0xb5, 0xe9, 0x1a, 0xc8, 0x63, 0xcf, 0x4d, 0x66, 0x16, 0x63, 0xcf, 0x5d, 0xd4, 0xa5, 0x9e, 0x6f,
0xc8, 0x69, 0xdd, 0xe5, 0x0d, 0x49, 0x14, 0x3b, 0xc3, 0x11, 0x4b, 0xb3, 0x05, 0x3c, 0x03, 0xcc,
0x95, 0x21, 0xc5, 0xb9, 0x32, 0x84, 0x6e, 0xf7, 0xde, 0x38, 0xbe, 0x4f, 0x06, 0xb3, 0xa6, 0x44,
0x11, 0x10, 0x93, 0x32, 0x90, 0x0f, 0x46, 0xac, 0x1f, 0xd9, 0x9c, 0x2b, 0xa4, 0x3a, 0x23, 0xf6,
0x68, 0xe6, 0x83, 0x51, 0xb6, 0x77, 0x51, 0xb2, 0xbd, 0xcb, 0x39, 0x23, 0xc0, 0x5a, 0x46, 0xf8,
0x7b, 0x1e, 0x14, 0xee, 0x6d, 0x6b, 0x29, 0x3f, 0x95, 0xb8, 0xb8, 0xea, 0x57, 0x4c, 0x5c, 0xe7,
0xf4, 0x2d, 0x2f, 0xd0, 0xb7, 0x30, 0x53, 0x61, 0x66, 0xa6, 0x8b, 0x2d, 0x90, 0x51, 0x4f, 0xf1,
0x12, 0xf5, 0x94, 0xd6, 0x6a, 0x28, 0x93, 0x51, 0x5c, 0x99, 0x85, 0x10, 0x1f, 0xc5, 0x89, 0x59,
0x87, 0x32, 0x9d, 0x75, 0xe8, 0xef, 0x40, 0xb5, 0xbc, 0x21, 0xe9, 0x4e, 0xfc, 0x1e, 0xd5, 0xe2,
0x4d, 0x28, 0x8d, 0x08, 0x09, 0x6d, 0xd3, 0x15, 0xc5, 0x5e, 0x91, 0xfe, 0x34, 0x99, 0x18, 0xd6,
0x54, 0x8c, 0xfc, 0xbc, 0x18, 0x7b, 0xa0, 0x44, 0x13, 0xbf, 0x67, 0x2f, 0x2d, 0xa4, 0x28, 0x7d,
0xe6, 0x13, 0xe5, 0x48, 0xac, 0xf4, 0x6f, 0x00, 0x9e, 0x93, 0xc9, 0x5e, 0x97, 0xf4, 0xe9, 0xc5,
0x42, 0x71, 0xd2, 0x12, 0xc5, 0xe5, 0x2f, 0x76, 0x5d, 0x99, 0x55, 0x26, 0x33, 0xd7, 0x7d, 0xf8,
0x97, 0x02, 0x28, 0xd3, 0xef, 0x1e, 0x48, 0x85, 0x52, 0xf7, 0xa4, 0xd1, 0x30, 0xba, 0x5d, 0x2d,
0x87, 0x76, 0x40, 0x3b, 0x69, 0x1b, 0x5f, 0x1e, 0x1b, 0x0d, 0xcb, 0x68, 0xda, 0x06, 0xc6, 0x1d,
0xac, 0x49, 0x08, 0xc1, 0x66, 0xa3, 0xd3, 0x6e, 0x1b, 0x0d, 0xcb, 0xde, 0xaf, 0x99, 0x2d, 0xa3,
0xa9, 0xe5, 0xd1, 0x75, 0xd8, 0x3e, 0x36, 0xf0, 0x91, 0xd9, 0xed, 0x9a, 0x9d, 0xb6, 0xdd, 0x34,
0xda, 0xa6, 0xd1, 0xd4, 0x64, 0x74, 0x0b, 0xae, 0x37, 0x3a, 0xad, 0x96, 0xd1, 0xb0, 0x28, 0xb8,
0xdd, 0xb1, 0x6c, 0xe3, 0x4b, 0xb3, 0x6b, 0x75, 0xb5, 0x02, 0xa5, 0x6d, 0xb6, 0x5a, 0xc6, 0x41,
0xad, 0x65, 0xd7, 0xf0, 0xc1, 0xc9, 0x91, 0xd1, 0xb6, 0xb4, 0x0d, 0x4a, 0x27, 0x81, 0x36, 0xcd,
0x23, 0xa3, 0x4d, 0xc9, 0x69, 0x25, 0x74, 0x03, 0x50, 0x02, 0x36, 0xdb, 0x4d, 0xe3, 0x4b, 0xdb,
0xfa, 0xea, 0xd8, 0xd0, 0xca, 0xe8, 0x0e, 0xdc, 0x4c, 0xe0, 0xe9, 0x7b, 0x6a, 0x47, 0x86, 0xa6,
0x20, 0x0d, 0x2a, 0xc9, 0xa6, 0xd5, 0x39, 0x7e, 0xae, 0x41, 0x9a, 0x3a, 0xee, 0xbc, 0xc2, 0x46,
0xa3, 0x83, 0x9b, 0x9a, 0x9a, 0x06, 0xbf, 0x34, 0x1a, 0x56, 0x07, 0xdb, 0x66, 0x53, 0xab, 0x50,
0xe6, 0x13, 0x70, 0xd7, 0xa8, 0xe1, 0xc6, 0xa1, 0x8d, 0x8d, 0xee, 0x49, 0xcb, 0xd2, 0xaa, 0x54,
0x05, 0xfb, 0x66, 0xcb, 0x60, 0x12, 0xed, 0x77, 0x4e, 0xda, 0x4d, 0x6d, 0x13, 0x6d, 0x81, 0x7a,
0x64, 0x58, 0xb5, 0x44, 0x27, 0x5b, 0xf4, 0xfe, 0x46, 0xad, 0x71, 0x68, 0x24, 0x10, 0x0d, 0xed,
0xc2, 0x4e, 0xa3, 0xd6, 0xa6, 0x48, 0x0d, 0x6c, 0xd4, 0x2c, 0xc3, 0xde, 0xef, 0xb4, 0x9a, 0x06,
0xd6, 0xb6, 0xa9, 0x80, 0x73, 0x3b, 0x66, 0xcb, 0xd0, 0x50, 0x0a, 0xa3, 0x69, 0xb4, 0x8c, 0x19,
0xc6, 0xb5, 0x14, 0x46, 0xb2, 0x43, 0x31, 0x76, 0xa8, 0x30, 0xf5, 0x13, 0xb3, 0xd5, 0x14, 0x8a,
0xe2, 0x46, 0xbb, 0x8e, 0xb6, 0xa1, 0x9a, 0x08, 0xd3, 0x6e, 0x99, 0x5d, 0x4b, 0xbb, 0x81, 0x6e,
0xc2, 0xb5, 0x04, 0x74, 0x64, 0x58, 0xd8, 0x6c, 0x70, 0xad, 0xde, 0xa4, 0x67, 0x3b, 0x27, 0x96,
0xdd, 0xd9, 0xb7, 0x8f, 0x8c, 0xa3, 0x0e, 0xfe, 0x4a, 0xdb, 0x7d, 0xf8, 0x47, 0x09, 0xca, 0x49,
0x85, 0x8f, 0xca, 0x50, 0x68, 0x77, 0xda, 0x86, 0x96, 0xa3, 0xab, 0x7a, 0xa7, 0xd3, 0xd2, 0x24,
0xba, 0x32, 0xdb, 0xd6, 0x53, 0x2d, 0x8f, 0x14, 0xd8, 0x30, 0xdb, 0xd6, 0x47, 0x8f, 0x35, 0x59,
0x2c, 0x3f, 0xde, 0xd3, 0x0a, 0x62, 0xf9, 0xf8, 0x13, 0x6d, 0x83, 0x2e, 0xf7, 0x5b, 0x9d, 0x9a,
0xa5, 0x01, 0x02, 0x28, 0x36, 0x3b, 0x27, 0xf5, 0x96, 0xa1, 0xa9, 0x74, 0xdd, 0xb5, 0xb0, 0xd9,
0x3e, 0xd0, 0x76, 0x28, 0x07, 0xc2, 0x12, 0x75, 0xb3, 0x5d, 0xc3, 0x5f, 0x69, 0x2e, 0xd5, 0xa6,
0x00, 0x71, 0x64, 0xf2, 0xb0, 0x01, 0x5b, 0x73, 0x35, 0x29, 0x2a, 0x42, 0xbe, 0x65, 0x69, 0x39,
0x54, 0x02, 0xb9, 0x65, 0x19, 0x9a, 0x44, 0x01, 0xc6, 0x0b, 0x2d, 0x4f, 0xff, 0x1e, 0x58, 0x9a,
0x4c, 0x37, 0x0e, 0x2c, 0x43, 0x2b, 0x50, 0x40, 0xdb, 0xd0, 0x36, 0x1e, 0x3e, 0x85, 0x0d, 0x56,
0xe7, 0x50, 0xc7, 0x37, 0xdb, 0x2f, 0x6b, 0x2d, 0xb3, 0xc9, 0xe5, 0x3a, 0x3a, 0xe9, 0x5a, 0x9a,
0xc4, 0xb8, 0x3a, 0xec, 0x9c, 0xb4, 0xa8, 0x93, 0x57, 0xa0, 0x4c, 0xa1, 0xd4, 0xea, 0x9a, 0xfc,
0xf0, 0x3e, 0x14, 0x79, 0xf2, 0xa6, 0x67, 0xcc, 0x76, 0xd7, 0xc0, 0xf4, 0x66, 0x2a, 0x11, 0xb3,
0x87, 0x26, 0x3d, 0xbc, 0x07, 0xe5, 0x24, 0x98, 0x29, 0x45, 0x6c, 0xd4, 0x28, 0x6d, 0x05, 0x36,
0x5e, 0x61, 0x93, 0x1e, 0xd8, 0xfb, 0xbe, 0x0a, 0xd5, 0x23, 0x16, 0xfa, 0x5d, 0x12, 0xbe, 0xf5,
0x7a, 0x04, 0xfd, 0x02, 0xb4, 0x46, 0x48, 0x9c, 0x98, 0xcc, 0xba, 0x71, 0xb4, 0xf0, 0x93, 0xd0,
0xed, 0x45, 0xfd, 0xb8, 0x9e, 0x43, 0xfb, 0x50, 0x3d, 0x74, 0xa2, 0x14, 0xf6, 0x9d, 0xb9, 0x1a,
0x3a, 0x9d, 0xe0, 0x6f, 0xdf, 0x38, 0x57, 0x6d, 0xf1, 0x89, 0x53, 0x0e, 0x99, 0x80, 0x9a, 0x24,
0xea, 0x85, 0xde, 0x29, 0x59, 0x95, 0xd8, 0x42, 0x3e, 0xf5, 0x1c, 0x7a, 0x41, 0xed, 0x34, 0xf6,
0xe3, 0x55, 0xe9, 0xdc, 0x5b, 0xb2, 0x39, 0x1d, 0x4d, 0xe5, 0xd0, 0x2f, 0x61, 0xab, 0xfb, 0x86,
0xfe, 0x4c, 0xf6, 0xa2, 0x39, 0x2d, 0x89, 0xd1, 0xd5, 0x52, 0x5a, 0xc9, 0xb7, 0x53, 0x3d, 0x87,
0x8e, 0x01, 0x65, 0x69, 0xb1, 0xf1, 0xc7, 0x85, 0x1c, 0x2e, 0xdb, 0x64, 0xe3, 0x8e, 0x1c, 0x6a,
0xc2, 0x66, 0x33, 0x0c, 0x46, 0xab, 0xca, 0xbb, 0xc4, 0x92, 0x9f, 0x81, 0xca, 0x5d, 0x81, 0x0d,
0xda, 0x50, 0xb6, 0x3e, 0x9d, 0x0d, 0xdf, 0x96, 0xa1, 0x37, 0xa0, 0x9a, 0x18, 0xf0, 0x12, 0x02,
0xcb, 0x36, 0xf4, 0x1c, 0x7a, 0x06, 0x0a, 0x95, 0xe4, 0x87, 0x71, 0x60, 0xc0, 0x16, 0x17, 0x60,
0xfa, 0x81, 0x71, 0x4e, 0x0f, 0xd9, 0xaf, 0x98, 0xcb, 0xc9, 0x54, 0x0e, 0x9d, 0x68, 0x45, 0x1a,
0xcb, 0x1d, 0xfa, 0x39, 0x6c, 0x52, 0x33, 0x4f, 0xcf, 0x47, 0x17, 0x1b, 0xe5, 0xf6, 0xe2, 0x5b,
0x84, 0xcf, 0x50, 0xe5, 0x86, 0xc1, 0xe8, 0x6a, 0x82, 0x7d, 0x0a, 0x45, 0x5e, 0x18, 0xa3, 0xdd,
0x39, 0xcd, 0x4e, 0xbf, 0x7d, 0xcd, 0xc9, 0x33, 0xfd, 0xd0, 0xc9, 0xd4, 0x52, 0x9d, 0x4e, 0xd5,
0xea, 0x13, 0xb3, 0x39, 0xc7, 0x42, 0x76, 0x28, 0x76, 0x7b, 0xf1, 0x80, 0x5f, 0xcf, 0xa1, 0x43,
0xda, 0x96, 0xcd, 0x86, 0x73, 0xe8, 0xff, 0xe6, 0xba, 0x82, 0xb9, 0xb9, 0xdd, 0x05, 0x0c, 0x7d,
0x0e, 0x45, 0x5e, 0x62, 0xa2, 0xa5, 0xdf, 0x57, 0x6e, 0x67, 0x77, 0x52, 0x1f, 0x30, 0x58, 0x1c,
0x6e, 0xcd, 0x7d, 0xe7, 0x41, 0xef, 0x2f, 0x20, 0x94, 0xfd, 0x0a, 0x74, 0x21, 0xc5, 0x27, 0x20,
0x37, 0x86, 0xee, 0x92, 0xcc, 0x30, 0xc7, 0x64, 0x6a, 0x8e, 0x9f, 0x43, 0x35, 0x80, 0xd9, 0x90,
0x15, 0x65, 0x8b, 0xde, 0xb9, 0xe9, 0xeb, 0x32, 0xe3, 0x1e, 0xc0, 0xf6, 0x71, 0x48, 0x06, 0x81,
0xe3, 0x5e, 0x31, 0x0d, 0x3c, 0x81, 0x0d, 0x36, 0x89, 0x9e, 0x0b, 0xbf, 0xd9, 0x74, 0x7a, 0x19,
0xe2, 0x33, 0x36, 0xc0, 0x1f, 0x39, 0xbd, 0x18, 0xdd, 0x3a, 0x3f, 0x47, 0x11, 0x63, 0xe9, 0x65,
0xc8, 0x75, 0x28, 0x0b, 0xbb, 0xd5, 0xd1, 0xed, 0x65, 0xe6, 0x3c, 0xae, 0x5f, 0xa4, 0xfe, 0x7a,
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 {
string collection_name = 1;
VectorRowRecord records = 2;
string partition_tag = 3;
repeated string partition_tag = 3;
int64 uid = 4;
uint64 timestamp =5;
int64 client_id = 6;
repeated KeyValuePair extra_params = 7;
repeated string json = 8;
string dsl = 9;
}
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, client_id_),
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_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::TimeSyncMsg, _internal_metadata_),
~0u, // no _extensions_
@ -1304,6 +1306,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_message_2eproto::offsets[] PRO
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, uid_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, timestamp_),
PROTOBUF_FIELD_OFFSET(::milvus::grpc::Key2SegMsg, segment_id_),
};
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)},
{ 333, -1, sizeof(::milvus::grpc::InsertOrDeleteMsg)},
{ 348, -1, sizeof(::milvus::grpc::SearchMsg)},
{ 360, -1, sizeof(::milvus::grpc::TimeSyncMsg)},
{ 368, -1, sizeof(::milvus::grpc::Key2SegMsg)},
{ 362, -1, sizeof(::milvus::grpc::TimeSyncMsg)},
{ 370, -1, sizeof(::milvus::grpc::Key2SegMsg)},
};
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"
"\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"
".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"
"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"
"2\031.milvus.grpc.KeyValuePair\"[\n\013TimeSyncM"
"sg\022\017\n\007peer_Id\030\001 \001(\003\022\021\n\tTimestamp\030\002 \001(\004\022("
"\n\tsync_type\030\003 \001(\0162\025.milvus.grpc.SyncType"
"\"-\n\nKey2SegMsg\022\013\n\003uid\030\001 \001(\003\022\022\n\nsegment_i"
"d\030\002 \003(\003*\242\004\n\tErrorCode\022\013\n\007SUCCESS\020\000\022\024\n\020UN"
"EXPECTED_ERROR\020\001\022\022\n\016CONNECT_FAILED\020\002\022\025\n\021"
"PERMISSION_DENIED\020\003\022\031\n\025COLLECTION_NOT_EX"
"ISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021ILLEGAL_"
"DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020\010\022\033\n\027I"
"LLEGAL_COLLECTION_NAME\020\t\022\020\n\014ILLEGAL_TOPK"
"\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEGAL_VEC"
"TOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020\r\022\022\n\016F"
"ILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020\n\014CACH"
"E_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER\020\021\022\026\n\022"
"CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DELETE_FO"
"LDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021BUILD_"
"INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027\n\023ILLE"
"GAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY\020\030*\221\001\n"
"\010DataType\022\010\n\004NONE\020\000\022\010\n\004BOOL\020\001\022\010\n\004INT8\020\002\022"
"\t\n\005INT16\020\003\022\t\n\005INT32\020\004\022\t\n\005INT64\020\005\022\t\n\005FLOA"
"T\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006STRING\020\024\022\021\n\rVECTOR_BI"
"NARY\020d\022\020\n\014VECTOR_FLOAT\020e*C\n\017CompareOpera"
"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"
"GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020\000\022\010\n\004M"
"UST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\003* \n\006OpTyp"
"e\022\n\n\006INSERT\020\000\022\n\n\006DELETE\020\001*\037\n\010SyncType\022\010\n"
"\004READ\020\000\022\t\n\005WRITE\020\0012\333\r\n\rMilvusService\022\?\n\020"
"CreateCollection\022\024.milvus.grpc.Mapping\032\023"
".milvus.grpc.Status\"\000\022F\n\rHasCollection\022\033"
".milvus.grpc.CollectionName\032\026.milvus.grp"
"c.BoolReply\"\000\022I\n\022DescribeCollection\022\033.mi"
"lvus.grpc.CollectionName\032\024.milvus.grpc.M"
"apping\"\000\022Q\n\017CountCollection\022\033.milvus.grp"
"c.CollectionName\032\037.milvus.grpc.Collectio"
"nRowCount\"\000\022J\n\017ShowCollections\022\024.milvus."
"grpc.Command\032\037.milvus.grpc.CollectionNam"
"eList\"\000\022P\n\022ShowCollectionInfo\022\033.milvus.g"
"rpc.CollectionName\032\033.milvus.grpc.Collect"
"ionInfo\"\000\022D\n\016DropCollection\022\033.milvus.grp"
"c.CollectionName\032\023.milvus.grpc.Status\"\000\022"
"=\n\013CreateIndex\022\027.milvus.grpc.IndexParam\032"
"\023.milvus.grpc.Status\"\000\022C\n\rDescribeIndex\022"
"\027.milvus.grpc.IndexParam\032\027.milvus.grpc.I"
"ndexParam\"\000\022;\n\tDropIndex\022\027.milvus.grpc.I"
"ndexParam\032\023.milvus.grpc.Status\"\000\022E\n\017Crea"
"tePartition\022\033.milvus.grpc.PartitionParam"
"\032\023.milvus.grpc.Status\"\000\022E\n\014HasPartition\022"
"\033.milvus.grpc.PartitionParam\032\026.milvus.gr"
"pc.BoolReply\"\000\022K\n\016ShowPartitions\022\033.milvu"
"s.grpc.CollectionName\032\032.milvus.grpc.Part"
"itionList\"\000\022C\n\rDropPartition\022\033.milvus.gr"
"pc.PartitionParam\032\023.milvus.grpc.Status\"\000"
"\022<\n\006Insert\022\030.milvus.grpc.InsertParam\032\026.m"
"ilvus.grpc.EntityIds\"\000\022E\n\rGetEntityByID\022"
"\033.milvus.grpc.EntityIdentity\032\025.milvus.gr"
"pc.Entities\"\000\022H\n\014GetEntityIDs\022\036.milvus.g"
"rpc.GetEntityIDsParam\032\026.milvus.grpc.Enti"
"tyIds\"\000\022>\n\006Search\022\030.milvus.grpc.SearchPa"
"ram\032\030.milvus.grpc.QueryResult\"\000\022P\n\017Searc"
"hInSegment\022!.milvus.grpc.SearchInSegment"
"Param\032\030.milvus.grpc.QueryResult\"\000\0227\n\003Cmd"
"\022\024.milvus.grpc.Command\032\030.milvus.grpc.Str"
"ingReply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.D"
"eleteByIDParam\032\023.milvus.grpc.Status\"\000\022G\n"
"\021PreloadCollection\022\033.milvus.grpc.Collect"
"ionName\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022"
"\027.milvus.grpc.FlushParam\032\023.milvus.grpc.S"
"tatus\"\000\022;\n\007Compact\022\031.milvus.grpc.Compact"
"Param\032\023.milvus.grpc.Status\"\000\022B\n\010SearchPB"
"\022\032.milvus.grpc.SearchParamPB\032\030.milvus.gr"
"pc.QueryResult\"\000B\007Z\005msgpbb\006proto3"
"2\031.milvus.grpc.KeyValuePair\022\014\n\004json\030\010 \003("
"\t\022\013\n\003dsl\030\t \001(\t\"[\n\013TimeSyncMsg\022\017\n\007peer_Id"
"\030\001 \001(\003\022\021\n\tTimestamp\030\002 \001(\004\022(\n\tsync_type\030\003"
" \001(\0162\025.milvus.grpc.SyncType\"@\n\nKey2SegMs"
"g\022\013\n\003uid\030\001 \001(\003\022\021\n\ttimestamp\030\002 \001(\004\022\022\n\nseg"
"ment_id\030\003 \003(\003*\242\004\n\tErrorCode\022\013\n\007SUCCESS\020\000"
"\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FAILED"
"\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\031\n\025COLLECTION_"
"NOT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021IL"
"LEGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020"
"\010\022\033\n\027ILLEGAL_COLLECTION_NAME\020\t\022\020\n\014ILLEGA"
"L_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEG"
"AL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020"
"\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020"
"\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER"
"\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DEL"
"ETE_FOLDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021"
"BUILD_INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027"
"\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY"
"\020\030*\221\001\n\010DataType\022\010\n\004NONE\020\000\022\010\n\004BOOL\020\001\022\010\n\004I"
"NT8\020\002\022\t\n\005INT16\020\003\022\t\n\005INT32\020\004\022\t\n\005INT64\020\005\022\t"
"\n\005FLOAT\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006STRING\020\024\022\021\n\rVEC"
"TOR_BINARY\020d\022\020\n\014VECTOR_FLOAT\020e*C\n\017Compar"
"eOperator\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\003GTE\020\004\022\006\n\002NE\020\005*8\n\005Occur\022\013\n\007INVALID\020"
"\000\022\010\n\004MUST\020\001\022\n\n\006SHOULD\020\002\022\014\n\010MUST_NOT\020\003* \n"
"\006OpType\022\n\n\006INSERT\020\000\022\n\n\006DELETE\020\001*\037\n\010SyncT"
"ype\022\010\n\004READ\020\000\022\t\n\005WRITE\020\0012\333\r\n\rMilvusServi"
"ce\022\?\n\020CreateCollection\022\024.milvus.grpc.Map"
"ping\032\023.milvus.grpc.Status\"\000\022F\n\rHasCollec"
"tion\022\033.milvus.grpc.CollectionName\032\026.milv"
"us.grpc.BoolReply\"\000\022I\n\022DescribeCollectio"
"n\022\033.milvus.grpc.CollectionName\032\024.milvus."
"grpc.Mapping\"\000\022Q\n\017CountCollection\022\033.milv"
"us.grpc.CollectionName\032\037.milvus.grpc.Col"
"lectionRowCount\"\000\022J\n\017ShowCollections\022\024.m"
"ilvus.grpc.Command\032\037.milvus.grpc.Collect"
"ionNameList\"\000\022P\n\022ShowCollectionInfo\022\033.mi"
"lvus.grpc.CollectionName\032\033.milvus.grpc.C"
"ollectionInfo\"\000\022D\n\016DropCollection\022\033.milv"
"us.grpc.CollectionName\032\023.milvus.grpc.Sta"
"tus\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.Index"
"Param\032\023.milvus.grpc.Status\"\000\022C\n\rDescribe"
"Index\022\027.milvus.grpc.IndexParam\032\027.milvus."
"grpc.IndexParam\"\000\022;\n\tDropIndex\022\027.milvus."
"grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022E"
"\n\017CreatePartition\022\033.milvus.grpc.Partitio"
"nParam\032\023.milvus.grpc.Status\"\000\022E\n\014HasPart"
"ition\022\033.milvus.grpc.PartitionParam\032\026.mil"
"vus.grpc.BoolReply\"\000\022K\n\016ShowPartitions\022\033"
".milvus.grpc.CollectionName\032\032.milvus.grp"
"c.PartitionList\"\000\022C\n\rDropPartition\022\033.mil"
"vus.grpc.PartitionParam\032\023.milvus.grpc.St"
"atus\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertPar"
"am\032\026.milvus.grpc.EntityIds\"\000\022E\n\rGetEntit"
"yByID\022\033.milvus.grpc.EntityIdentity\032\025.mil"
"vus.grpc.Entities\"\000\022H\n\014GetEntityIDs\022\036.mi"
"lvus.grpc.GetEntityIDsParam\032\026.milvus.grp"
"c.EntityIds\"\000\022>\n\006Search\022\030.milvus.grpc.Se"
"archParam\032\030.milvus.grpc.QueryResult\"\000\022P\n"
"\017SearchInSegment\022!.milvus.grpc.SearchInS"
"egmentParam\032\030.milvus.grpc.QueryResult\"\000\022"
"7\n\003Cmd\022\024.milvus.grpc.Command\032\030.milvus.gr"
"pc.StringReply\"\000\022A\n\nDeleteByID\022\034.milvus."
"grpc.DeleteByIDParam\032\023.milvus.grpc.Statu"
"s\"\000\022G\n\021PreloadCollection\022\033.milvus.grpc.C"
"ollectionName\032\023.milvus.grpc.Status\"\000\0227\n\005"
"Flush\022\027.milvus.grpc.FlushParam\032\023.milvus."
"grpc.Status\"\000\022;\n\007Compact\022\031.milvus.grpc.C"
"ompactParam\032\023.milvus.grpc.Status\"\000\022B\n\010Se"
"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] = {
};
@ -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 bool descriptor_table_message_2eproto_initialized = false;
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,
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,
@ -18199,15 +18203,17 @@ SearchMsg::SearchMsg()
SearchMsg::SearchMsg(const SearchMsg& from)
: ::PROTOBUF_NAMESPACE_ID::Message(),
_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_);
collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.collection_name().empty()) {
collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_);
}
partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.partition_tag().empty()) {
partition_tag_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.partition_tag_);
dsl_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
if (!from.dsl().empty()) {
dsl_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.dsl_);
}
if (from.has_records()) {
records_ = new ::milvus::grpc::VectorRowRecord(*from.records_);
@ -18223,7 +18229,7 @@ SearchMsg::SearchMsg(const SearchMsg& from)
void SearchMsg::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchMsg_message_2eproto.base);
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>(
reinterpret_cast<char*>(&client_id_) -
reinterpret_cast<char*>(&records_)) + sizeof(client_id_));
@ -18236,7 +18242,7 @@ SearchMsg::~SearchMsg() {
void SearchMsg::SharedDtor() {
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_;
}
@ -18255,9 +18261,11 @@ void SearchMsg::Clear() {
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
partition_tag_.Clear();
extra_params_.Clear();
json_.Clear();
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) {
delete records_;
}
@ -18290,11 +18298,16 @@ const char* SearchMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::
CHK_(ptr);
} else goto handle_unusual;
continue;
// string partition_tag = 3;
// repeated string partition_tag = 3;
case 3:
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");
CHK_(ptr);
ptr -= 1;
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;
continue;
// 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);
} else goto handle_unusual;
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: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
@ -18386,13 +18418,14 @@ bool SearchMsg::MergePartialFromCodedStream(
break;
}
// string partition_tag = 3;
// repeated string partition_tag = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
input, this->mutable_partition_tag()));
input, this->add_partition_tag()));
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,
"milvus.grpc.SearchMsg.partition_tag"));
} else {
@ -18451,6 +18484,37 @@ bool SearchMsg::MergePartialFromCodedStream(
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: {
handle_unusual:
if (tag == 0) {
@ -18494,14 +18558,14 @@ void SearchMsg::SerializeWithCachedSizes(
2, _Internal::records(this), output);
}
// string partition_tag = 3;
if (this->partition_tag().size() > 0) {
// repeated string partition_tag = 3;
for (int i = 0, n = this->partition_tag_size(); i < n; i++) {
::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,
"milvus.grpc.SearchMsg.partition_tag");
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
3, this->partition_tag(), output);
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
3, this->partition_tag(i), output);
}
// int64 uid = 4;
@ -18528,6 +18592,26 @@ void SearchMsg::SerializeWithCachedSizes(
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()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
_internal_metadata_.unknown_fields(), output);
@ -18559,15 +18643,14 @@ void SearchMsg::SerializeWithCachedSizes(
2, _Internal::records(this), target);
}
// string partition_tag = 3;
if (this->partition_tag().size() > 0) {
// repeated string partition_tag = 3;
for (int i = 0, n = this->partition_tag_size(); i < n; i++) {
::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,
"milvus.grpc.SearchMsg.partition_tag");
target =
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
3, this->partition_tag(), target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
WriteStringToArray(3, this->partition_tag(i), target);
}
// int64 uid = 4;
@ -18593,6 +18676,27 @@ void SearchMsg::SerializeWithCachedSizes(
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()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields(), target);
@ -18614,6 +18718,14 @@ size_t SearchMsg::ByteSizeLong() const {
// Prevent compiler warnings about cached_has_bits being unused
(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;
{
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;
if (this->collection_name().size() > 0) {
total_size += 1 +
@ -18632,11 +18752,11 @@ size_t SearchMsg::ByteSizeLong() const {
this->collection_name());
}
// string partition_tag = 3;
if (this->partition_tag().size() > 0) {
// string dsl = 9;
if (this->dsl().size() > 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->partition_tag());
this->dsl());
}
// .milvus.grpc.VectorRowRecord records = 2;
@ -18694,14 +18814,16 @@ void SearchMsg::MergeFrom(const SearchMsg& from) {
::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
(void) cached_has_bits;
partition_tag_.MergeFrom(from.partition_tag_);
extra_params_.MergeFrom(from.extra_params_);
json_.MergeFrom(from.json_);
if (from.collection_name().size() > 0) {
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()) {
mutable_records()->::milvus::grpc::VectorRowRecord::MergeFrom(from.records());
@ -18738,10 +18860,12 @@ bool SearchMsg::IsInitialized() const {
void SearchMsg::InternalSwap(SearchMsg* other) {
using std::swap;
_internal_metadata_.Swap(&other->_internal_metadata_);
partition_tag_.InternalSwap(CastToBase(&other->partition_tag_));
CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_));
json_.InternalSwap(CastToBase(&other->json_));
collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
dsl_.Swap(&other->dsl_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
GetArenaNoVirtual());
swap(records_, other->records_);
swap(uid_, other->uid_);
@ -19112,12 +19236,16 @@ Key2SegMsg::Key2SegMsg(const Key2SegMsg& from)
_internal_metadata_(nullptr),
segment_id_(from.segment_id_) {
_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)
}
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() {
@ -19144,7 +19272,9 @@ void Key2SegMsg::Clear() {
(void) cached_has_bits;
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();
}
@ -19163,12 +19293,19 @@ const char* Key2SegMsg::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:
CHK_(ptr);
} else goto handle_unusual;
continue;
// repeated int64 segment_id = 2;
// uint64 timestamp = 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);
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));
CHK_(ptr);
} else goto handle_unusual;
@ -19216,16 +19353,29 @@ bool Key2SegMsg::MergePartialFromCodedStream(
break;
}
// repeated int64 segment_id = 2;
// uint64 timestamp = 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<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
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<
::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 {
goto handle_unusual;
}
@ -19264,9 +19414,14 @@ void Key2SegMsg::SerializeWithCachedSizes(
::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) {
::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(
std::memory_order_relaxed));
}
@ -19293,10 +19448,15 @@ void Key2SegMsg::SerializeWithCachedSizes(
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) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
2,
3,
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
target);
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
(void) cached_has_bits;
// repeated int64 segment_id = 2;
// repeated int64 segment_id = 3;
{
size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
Int64Size(this->segment_id_);
@ -19349,6 +19509,13 @@ size_t Key2SegMsg::ByteSizeLong() const {
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);
SetCachedSize(cached_size);
return total_size;
@ -19380,6 +19547,9 @@ void Key2SegMsg::MergeFrom(const Key2SegMsg& from) {
if (from.uid() != 0) {
set_uid(from.uid());
}
if (from.timestamp() != 0) {
set_timestamp(from.timestamp());
}
}
void Key2SegMsg::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
@ -19405,6 +19575,7 @@ void Key2SegMsg::InternalSwap(Key2SegMsg* other) {
_internal_metadata_.Swap(&other->_internal_metadata_);
segment_id_.InternalSwap(&other->segment_id_);
swap(uid_, other->uid_);
swap(timestamp_, other->timestamp_);
}
::PROTOBUF_NAMESPACE_ID::Metadata Key2SegMsg::GetMetadata() const {

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

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

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

@ -5,7 +5,9 @@
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) {}
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>());
insert_delete_producer_ = std::make_shared<MsgProducer>(pulsar_client, insert_delete, 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);
//create pulsar consumer
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;
// result_prt->set_allocated_status(const_cast<milvus::grpc::Status*>(&results[0]->status()));
result.mutable_status()->CopyFrom(results[0]->status());
result.mutable_entities()->CopyFrom(results[0]->entities());
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;
}
milvus::grpc::QueryResult MsgClientV2::GetQueryResult(int64_t query_id) {
// Result result = MsgProducer::createProducer("result-partition-0");
auto client = std::make_shared<MsgClient>("pulsar://localhost:6650");
MsgConsumer consumer(client, "my_consumer");
consumer.subscribe("result");
Status MsgClientV2::GetQueryResult(int64_t query_id, milvus::grpc::QueryResult &result) {
std::vector<std::shared_ptr<grpc::QueryResult>> results;
int64_t query_node_num = GetQueryNodeNum();
std::map<int64_t, std::vector<std::shared_ptr<grpc::QueryResult>>> total_results;
while (true) {
auto received_result = total_results[query_id];
if (received_result.size() == query_node_num) {
break;
}
Message msg;
consumer.receive(msg);
consumer_->receive(msg);
grpc::QueryResult search_res_msg;
auto status = search_res_msg.ParseFromString(msg.getDataAsString());
if (status) {
auto message = std::make_shared<grpc::QueryResult>(search_res_msg);
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) {
@ -169,6 +166,115 @@ Status MsgClientV2::SendMutMessage(const milvus::grpc::DeleteByIDParam &request,
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() {
insert_delete_producer_->close();
search_producer_->close();

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

@ -9,7 +9,7 @@ namespace milvus::message_client {
class MsgClientV2 {
public:
MsgClientV2(int64_t client_id,
std::string &service_url,
const std::string &service_url,
const pulsar::ClientConfiguration &config = pulsar::ClientConfiguration());
~MsgClientV2();
@ -26,9 +26,9 @@ class MsgClientV2 {
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:
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
ReqHandler::Search(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params,
engine::QueryResultPtr& result) {
BaseReqPtr req_ptr = SearchReq::Create(context, query_ptr, json_params, result);
ReqScheduler::ExecReq(req_ptr);
return req_ptr->status();
// BaseReqPtr req_ptr = SearchReq::Create(context, query_ptr, json_params, result);
// ReqScheduler::ExecReq(req_ptr);
// return req_ptr->status();
return Status::OK();
}
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.
#include "server/delivery/request/SearchReq.h"
#include "server/MessageWrapper.h"
// #include "db/Utils.h"
#include "server/ValidationUtil.h"
#include "utils/CommonUtil.h"
@ -28,25 +29,38 @@
namespace milvus {
namespace server {
SearchReq::SearchReq(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params,
engine::QueryResultPtr& result)
SearchReq::SearchReq(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
::milvus::grpc::QueryResult *result)
: BaseReq(context, ReqType::kSearch),
query_ptr_(query_ptr),
json_params_(json_params),
request_(request),
result_(result) {
}
BaseReqPtr
SearchReq::Create(const ContextPtr& context, const query::QueryPtr& query_ptr, const milvus::json& json_params,
engine::QueryResultPtr& result) {
return std::shared_ptr<BaseReq>(new SearchReq(context, query_ptr, json_params, result));
SearchReq::Create(const ContextPtr& context, const ::milvus::grpc::SearchParam *request,
::milvus::grpc::QueryResult *response) {
return std::shared_ptr<BaseReq>(new SearchReq(context, request, response));
}
Status
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

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

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

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

@ -17,6 +17,8 @@
#include <unordered_map>
#include <utility>
#include <vector>
#include <src/server/delivery/request/SearchReq.h>
#include <src/server/delivery/ReqScheduler.h>
#include "query/BinaryQuery.h"
#include "server/ValidationUtil.h"
@ -849,6 +851,9 @@ GrpcRequestHandler::Search(::grpc::ServerContext *context, const ::milvus::grpc:
CHECK_NULLPTR_RETURN(request);
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;
}

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

@ -1,81 +1,88 @@
#include <gtest/gtest.h>
#include "message_client/ClientV2.h"
#include "src/message_client/ClientV2.h"
TEST(CLIENT_CPP, GetResult) {
auto client= std::make_shared<milvus::message_client::MsgClient>("pulsar://localhost:6650");
milvus::message_client::MsgProducer producer(client,"test");
producer.createProducer("result");
producer.send("result");
milvus::grpc::QueryResult fake_message;
milvus::grpc::QueryResult fake_message2;
// auto client= std::make_shared<milvus::message_client::MsgClient>("pulsar://localhost:6650");
// milvus::message_client::MsgProducer producer(client,"test");
// producer.createProducer("result");
// producer.send("result");
// 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);
//
// producer.send(fake_message.SerializeAsString());
// producer.send(fake_message2.SerializeAsString());
milvus::grpc::Status fake_status;
fake_status.set_error_code(milvus::grpc::ErrorCode::SUCCESS);
std::string aaa = "hahaha";
fake_status.set_reason(aaa);
int64_t query_id = 10;
milvus::message_client::MsgClientV2 client_v2(1, "pulsar://localhost:6650");
auto init_status = client_v2.Init("insert_delete", "search", "time_sync", "result", "result");
milvus::grpc::RowData fake_row_data;
fake_row_data.set_blob("fake_row_data");
// client_v2.SendQueryMessage();
milvus::grpc::SearchParam request;
auto status_send = client_v2.SendQueryMessage(request, query_id);
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);
}
milvus::grpc::QueryResult result;
auto status = client_v2.GetQueryResult(query_id, result);
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;
for (int k = 0; k < result.distances_size(); ++k) {
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 {
ts = ts[len(ts)-1:]
return ts
if len(ts) > 1 {
ts = ts[len(ts)-1:]
}
}
return ts
}

103
timesync/readertimesync_test.go
View File

@ -15,24 +15,32 @@ const (
pulsarAddr = "pulsar://localhost:6650"
timeSyncTopic = "timesync"
timeSyncTopic2 = "timesync2"
timeSyncTopic3 = "timesync3"
timeSyncSubName = "timesync-g"
timeSyncSubName1 = "timesync-g1"
timeSyncSubName2 = "timesync-g2"
timeSyncSubName3 = "timesync-g3"
readerTopic1 = "reader1"
readerTopic12 = "reader12"
readerTopic13 = "reader13"
readerTopic2 = "reader2"
readerTopic22 = "reader22"
readerTopic23 = "reader23"
readerTopic3 = "reader3"
readerTopic32 = "reader32"
readerTopic33 = "reader33"
readerTopic4 = "reader4"
readerTopic42 = "reader42"
readerTopic43 = "reader43"
readerSubName = "reader-g"
readerSubName1 = "reader-g1"
readerSubName2 = "reader-g2"
readerSubName3 = "reader-g3"
interval = 200
readStopFlag int64 = -1
readStopFlag1 int64 = -1
readStopFlag2 int64 = -2
readStopFlag3 int64 = -3
)
func TestAlignTimeSync(t *testing.T) {
@ -460,6 +468,101 @@ func TestReaderTimesync2(t *testing.T) {
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 {
return ts >> 18
}