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

Add wasm in milvus (#19489) 

1. Add function storage in rootcoord

2. Parse udf expression

3. Execute wasm in core

Signed-off-by: Ziyu Wang <15871035978@163.com>

Signed-off-by: Ziyu Wang <15871035978@163.com>
revert-19489-summer/udf
mumon 2022-10-13 09:35:23 +08:00 committed by GitHub
parent 09255e5507
commit c346f29a4d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
77 changed files with 9331 additions and 1252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

331
api/commonpb/common.pb.go
View File

@ -370,6 +370,10 @@ const (
MsgType_SystemInfo MsgType = 601
MsgType_GetRecoveryInfo MsgType = 602
MsgType_GetSegmentState MsgType = 603
// FUNCTION
MsgType_CreateFunction MsgType = 700
MsgType_DropFunction MsgType = 701
MsgType_GetFunctionInfo MsgType = 702
// SYSTEM CONTROL
MsgType_TimeTick MsgType = 1200
MsgType_QueryNodeStats MsgType = 1201
@ -456,6 +460,9 @@ var MsgType_name = map[int32]string{
601: "SystemInfo",
602: "GetRecoveryInfo",
603: "GetSegmentState",
700: "CreateFunction",
701: "DropFunction",
702: "GetFunctionInfo",
1200: "TimeTick",
1201: "QueryNodeStats",
1202: "LoadIndex",
@ -539,6 +546,9 @@ var MsgType_value = map[string]int32{
"SystemInfo": 601,
"GetRecoveryInfo": 602,
"GetSegmentState": 603,
"CreateFunction": 700,
"DropFunction": 701,
"GetFunctionInfo": 702,
"TimeTick": 1200,
"QueryNodeStats": 1201,
"LoadIndex": 1202,
@ -1393,164 +1403,165 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 2531 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xc9, 0x73, 0x24, 0x47,
0xd5, 0x57, 0xa9, 0x5b, 0x4b, 0x67, 0xb7, 0x5a, 0x4f, 0x29, 0x8d, 0xa6, 0x3d, 0x8b, 0x47, 0xd6,
0x67, 0x7f, 0x9f, 0xbe, 0xfe, 0x6c, 0x8d, 0x3d, 0x8e, 0xf8, 0x20, 0x88, 0x30, 0x81, 0xd4, 0x2d,
0x69, 0x14, 0xd6, 0x46, 0x49, 0x63, 0x08, 0x22, 0x60, 0x22, 0xbb, 0xea, 0xa9, 0x95, 0x33, 0xd5,
0x95, 0x45, 0x65, 0xb6, 0x46, 0xcd, 0xc9, 0x18, 0xf0, 0x85, 0x0b, 0x98, 0x7f, 0x80, 0x3f, 0x00,
0x08, 0x76, 0x38, 0xb2, 0x63, 0xb3, 0x9d, 0xd9, 0xe1, 0x08, 0x77, 0x16, 0xe3, 0x95, 0x78, 0x59,
0xd5, 0x55, 0xd5, 0x9a, 0x31, 0x1c, 0xb8, 0x75, 0xfe, 0xde, 0xcb, 0xb7, 0xe5, 0xdb, 0xaa, 0x59,
0xcd, 0x53, 0xbd, 0x9e, 0x0a, 0x57, 0xa3, 0x58, 0x19, 0xc5, 0xe7, 0x7b, 0x32, 0x38, 0xed, 0xeb,
0xe4, 0xb4, 0x9a, 0x90, 0x2e, 0x2d, 0x75, 0x95, 0xea, 0x06, 0x78, 0xdd, 0x82, 0x9d, 0xfe, 0xf1,
0x75, 0x1f, 0xb5, 0x17, 0xcb, 0xc8, 0xa8, 0x38, 0x61, 0x5c, 0xbe, 0xcd, 0x26, 0x0f, 0x8d, 0x30,
0x7d, 0xcd, 0x9f, 0x61, 0x0c, 0xe3, 0x58, 0xc5, 0xb7, 0x3d, 0xe5, 0x63, 0xc3, 0x59, 0x72, 0x56,
0xea, 0x37, 0x1e, 0x5e, 0x7d, 0x80, 0xd4, 0xd5, 0x0d, 0x62, 0x6b, 0x29, 0x1f, 0xdd, 0x0a, 0x0e,
0x7f, 0xf2, 0x45, 0x36, 0x19, 0xa3, 0xd0, 0x2a, 0x6c, 0x8c, 0x2f, 0x39, 0x2b, 0x15, 0x37, 0x3d,
0x2d, 0xff, 0x3f, 0xab, 0x3d, 0x8b, 0x83, 0xe7, 0x44, 0xd0, 0xc7, 0x03, 0x21, 0x63, 0x0e, 0xac,
0x74, 0x17, 0x07, 0x56, 0x7e, 0xc5, 0xa5, 0x9f, 0x7c, 0x81, 0x4d, 0x9c, 0x12, 0x39, 0xbd, 0x98,
0x1c, 0x96, 0x9f, 0x66, 0xd5, 0x67, 0x71, 0xd0, 0x16, 0x46, 0xbc, 0xc3, 0x35, 0xce, 0xca, 0xbe,
0x30, 0xc2, 0xde, 0xaa, 0xb9, 0xf6, 0xf7, 0xf2, 0x15, 0x56, 0x5e, 0x0f, 0x54, 0x27, 0x17, 0xe9,
0x58, 0x62, 0x2a, 0xf2, 0x94, 0xc1, 0x41, 0x20, 0x3c, 0x3c, 0x51, 0x81, 0x8f, 0xb1, 0x35, 0x89,
0xe4, 0x1a, 0xd1, 0x1d, 0xca, 0x35, 0xa2, 0xcb, 0xdf, 0xcd, 0xca, 0x66, 0x10, 0x25, 0xd6, 0xd4,
0x6f, 0x3c, 0xfa, 0xc0, 0x08, 0x14, 0xc4, 0x1c, 0x0d, 0x22, 0x74, 0xed, 0x0d, 0x0a, 0x81, 0x55,
0xa4, 0x1b, 0xa5, 0xa5, 0xd2, 0x4a, 0xcd, 0x4d, 0x4f, 0xcb, 0x1f, 0x1e, 0xd1, 0xbb, 0x15, 0xab,
0x7e, 0xc4, 0xb7, 0x59, 0x2d, 0xca, 0x31, 0xdd, 0x70, 0x96, 0x4a, 0x2b, 0xd5, 0x1b, 0x8f, 0xfd,
0x3b, 0x6d, 0xd6, 0x68, 0x77, 0xe4, 0xea, 0xf2, 0x13, 0x6c, 0x6a, 0xcd, 0xf7, 0x63, 0xd4, 0x9a,
0xd7, 0xd9, 0xb8, 0x8c, 0x52, 0x67, 0xc6, 0x65, 0x44, 0x31, 0x8a, 0x54, 0x6c, 0xac, 0x2f, 0x25,
0xd7, 0xfe, 0x5e, 0x7e, 0xc9, 0x61, 0x53, 0xbb, 0xba, 0xbb, 0x2e, 0x34, 0xf2, 0x77, 0xb1, 0xe9,
0x9e, 0xee, 0xde, 0xb6, 0xfe, 0x26, 0x2f, 0x7e, 0xe5, 0x81, 0x16, 0xec, 0xea, 0xae, 0xf5, 0x73,
0xaa, 0x97, 0xfc, 0xa0, 0x00, 0xf7, 0x74, 0x77, 0xbb, 0x9d, 0x4a, 0x4e, 0x0e, 0xfc, 0x0a, 0xab,
0x18, 0xd9, 0x43, 0x6d, 0x44, 0x2f, 0x6a, 0x94, 0x96, 0x9c, 0x95, 0xb2, 0x9b, 0x03, 0xfc, 0x12,
0x9b, 0xd6, 0xaa, 0x1f, 0x7b, 0xb8, 0xdd, 0x6e, 0x94, 0xed, 0xb5, 0xec, 0xbc, 0xfc, 0x0c, 0xab,
0xec, 0xea, 0xee, 0x4d, 0x14, 0x3e, 0xc6, 0xfc, 0x49, 0x56, 0xee, 0x08, 0x9d, 0x58, 0x54, 0x7d,
0x67, 0x8b, 0xc8, 0x03, 0xd7, 0x72, 0x2e, 0x7f, 0x84, 0xd5, 0xda, 0xbb, 0x3b, 0xff, 0x81, 0x04,
0x32, 0x5d, 0x9f, 0x88, 0xd8, 0xdf, 0x13, 0xbd, 0x61, 0x22, 0xe6, 0xc0, 0xf2, 0xeb, 0x0e, 0xab,
0x1d, 0xc4, 0xf2, 0x54, 0x06, 0xd8, 0xc5, 0x8d, 0x33, 0xc3, 0xdf, 0xc7, 0xaa, 0xaa, 0x73, 0x07,
0x3d, 0x53, 0x8c, 0xdd, 0xb5, 0x07, 0xea, 0xd9, 0xb7, 0x7c, 0x36, 0x7c, 0x4c, 0x65, 0xbf, 0xf9,
0x3e, 0x83, 0x54, 0x42, 0x34, 0x14, 0xfc, 0x2f, 0x53, 0x2e, 0x11, 0x93, 0x19, 0xe1, 0xce, 0xaa,
0x51, 0x80, 0x37, 0xd9, 0x5c, 0x2a, 0x30, 0x14, 0x3d, 0xbc, 0x2d, 0x43, 0x1f, 0xcf, 0xec, 0x23,
0x4c, 0x0c, 0x79, 0xc9, 0x95, 0x6d, 0x82, 0xf9, 0xe3, 0x8c, 0xdf, 0xc7, 0xab, 0xed, 0xa3, 0x4c,
0xb8, 0x70, 0x8e, 0x59, 0x37, 0x5f, 0xa8, 0xb0, 0x4a, 0x56, 0xf3, 0xbc, 0xca, 0xa6, 0x0e, 0xfb,
0x9e, 0x87, 0x5a, 0xc3, 0x18, 0x9f, 0x67, 0xb3, 0xb7, 0x42, 0x3c, 0x8b, 0xd0, 0x33, 0xe8, 0x5b,
0x1e, 0x70, 0xf8, 0x1c, 0x9b, 0x69, 0xa9, 0x30, 0x44, 0xcf, 0x6c, 0x0a, 0x19, 0xa0, 0x0f, 0xe3,
0x7c, 0x81, 0xc1, 0x01, 0xc6, 0x3d, 0xa9, 0xb5, 0x54, 0x61, 0x1b, 0x43, 0x89, 0x3e, 0x94, 0xf8,
0x45, 0x36, 0xdf, 0x52, 0x41, 0x80, 0x9e, 0x91, 0x2a, 0xdc, 0x53, 0x66, 0xe3, 0x4c, 0x6a, 0xa3,
0xa1, 0x4c, 0x62, 0xb7, 0x83, 0x00, 0xbb, 0x22, 0x58, 0x8b, 0xbb, 0xfd, 0x1e, 0x86, 0x06, 0x26,
0x48, 0x46, 0x0a, 0xb6, 0x65, 0x0f, 0x43, 0x92, 0x04, 0x53, 0x05, 0xd4, 0x5a, 0x4b, 0xb1, 0x85,
0x69, 0xfe, 0x10, 0xbb, 0x90, 0xa2, 0x05, 0x05, 0xa2, 0x87, 0x50, 0xe1, 0xb3, 0xac, 0x9a, 0x92,
0x8e, 0xf6, 0x0f, 0x9e, 0x05, 0x56, 0x90, 0xe0, 0xaa, 0x7b, 0x2e, 0x7a, 0x2a, 0xf6, 0xa1, 0x5a,
0x30, 0xe1, 0x39, 0xf4, 0x8c, 0x8a, 0xb7, 0xdb, 0x50, 0x23, 0x83, 0x53, 0xf0, 0x10, 0x45, 0xec,
0x9d, 0xb8, 0xa8, 0xfb, 0x81, 0x81, 0x19, 0x0e, 0xac, 0xb6, 0x29, 0x03, 0xdc, 0x53, 0x66, 0x53,
0xf5, 0x43, 0x1f, 0xea, 0xbc, 0xce, 0xd8, 0x2e, 0x1a, 0x91, 0x46, 0x60, 0x96, 0xd4, 0xb6, 0x84,
0x77, 0x82, 0x29, 0x00, 0x7c, 0x91, 0xf1, 0x96, 0x08, 0x43, 0x65, 0x5a, 0x31, 0x0a, 0x83, 0x9b,
0xb6, 0x9a, 0x61, 0x8e, 0xcc, 0x19, 0xc1, 0x65, 0x80, 0xc0, 0x73, 0xee, 0x36, 0x06, 0x98, 0x71,
0xcf, 0xe7, 0xdc, 0x29, 0x4e, 0xdc, 0x0b, 0x64, 0xfc, 0x7a, 0x5f, 0x06, 0xbe, 0x0d, 0x49, 0xf2,
0x2c, 0x17, 0xc8, 0xc6, 0xd4, 0xf8, 0xbd, 0x9d, 0xed, 0xc3, 0x23, 0x58, 0xe4, 0x17, 0xd8, 0x5c,
0x8a, 0xec, 0xa2, 0x89, 0xa5, 0x67, 0x83, 0x77, 0x91, 0x4c, 0xdd, 0xef, 0x9b, 0xfd, 0xe3, 0x5d,
0xec, 0xa9, 0x78, 0x00, 0x0d, 0x7a, 0x50, 0x2b, 0x69, 0xf8, 0x44, 0xf0, 0x10, 0x69, 0xd8, 0xe8,
0x45, 0x66, 0x90, 0x87, 0x17, 0x2e, 0xf1, 0xcb, 0xec, 0xe2, 0xad, 0xc8, 0x17, 0x06, 0xb7, 0x7b,
0xd4, 0x6a, 0x8e, 0x84, 0xbe, 0x4b, 0xee, 0xf6, 0x63, 0x84, 0xcb, 0xfc, 0x12, 0x5b, 0x1c, 0x7d,
0x8b, 0x2c, 0x58, 0x57, 0xe8, 0x62, 0xe2, 0x6d, 0x2b, 0x46, 0x1f, 0x43, 0x23, 0x45, 0x30, 0xbc,
0x78, 0x35, 0x97, 0x7a, 0x3f, 0xf1, 0x61, 0x22, 0x26, 0x9e, 0xdf, 0x4f, 0xbc, 0xc6, 0x1b, 0x6c,
0x61, 0x0b, 0xcd, 0xfd, 0x94, 0x25, 0xa2, 0xec, 0x48, 0x6d, 0x49, 0xb7, 0x34, 0xc6, 0x7a, 0x48,
0x79, 0x84, 0x73, 0x56, 0xdf, 0x42, 0x43, 0xe0, 0x10, 0x5b, 0xa6, 0x38, 0x25, 0xe6, 0xb9, 0x2a,
0xc0, 0x21, 0xfc, 0x5f, 0x14, 0x83, 0x76, 0xac, 0xa2, 0x22, 0xf8, 0x28, 0xb9, 0xb9, 0x1f, 0x61,
0x2c, 0x0c, 0x92, 0x8c, 0x22, 0xed, 0x31, 0x92, 0x73, 0x88, 0x14, 0x81, 0x22, 0xfc, 0xdf, 0x39,
0x5c, 0xd4, 0xfa, 0x3f, 0x94, 0xc3, 0x29, 0x37, 0x26, 0x7d, 0x72, 0x48, 0x5a, 0x21, 0xaf, 0x53,
0x25, 0x59, 0xfd, 0x0f, 0x89, 0xff, 0x4b, 0xa9, 0x92, 0xdc, 0xdb, 0x8a, 0x45, 0x68, 0x86, 0x78,
0x93, 0x3f, 0xc2, 0xae, 0xba, 0x78, 0x1c, 0xa3, 0x3e, 0x39, 0x50, 0x81, 0xf4, 0x06, 0xdb, 0xe1,
0xb1, 0xca, 0x52, 0x92, 0x58, 0xfe, 0x8f, 0x2c, 0xa1, 0xb0, 0x24, 0xf4, 0x21, 0xfc, 0x38, 0xc5,
0x64, 0x4f, 0x99, 0x43, 0x6a, 0x87, 0x3b, 0xb6, 0xc1, 0xc2, 0x13, 0xa4, 0x65, 0x4f, 0xb9, 0x18,
0x05, 0xd2, 0x13, 0x6b, 0xa7, 0x42, 0x06, 0xa2, 0x13, 0x20, 0xac, 0x52, 0x50, 0x0e, 0xb1, 0x4b,
0x25, 0x9b, 0xbd, 0xef, 0x75, 0x3e, 0xc3, 0x2a, 0x9b, 0x2a, 0xf6, 0xb0, 0x8d, 0xe1, 0x00, 0x9e,
0xa4, 0xa3, 0x2b, 0x0c, 0xee, 0xc8, 0x9e, 0x34, 0xf0, 0x14, 0xe5, 0x1b, 0xcd, 0xf9, 0x96, 0x52,
0xb1, 0xbf, 0xb7, 0x06, 0x3e, 0xe7, 0x6c, 0xa6, 0xdd, 0x76, 0xf1, 0xa3, 0x7d, 0xd4, 0xc6, 0x15,
0x1e, 0xc2, 0x9f, 0xa6, 0x9a, 0x1e, 0x63, 0x36, 0x07, 0x69, 0x5b, 0x41, 0xb2, 0x28, 0x3f, 0xed,
0xa9, 0x10, 0x61, 0x8c, 0xd7, 0xd8, 0xf4, 0xad, 0x50, 0x6a, 0xdd, 0x47, 0x1f, 0x1c, 0xaa, 0xbf,
0xed, 0xf0, 0x20, 0x56, 0x5d, 0x1a, 0x8c, 0x30, 0x4e, 0xd4, 0x4d, 0x19, 0x4a, 0x7d, 0x62, 0x3b,
0x0f, 0x63, 0x93, 0x69, 0x21, 0x96, 0x79, 0x85, 0x4d, 0xb8, 0x68, 0xe2, 0x01, 0x4c, 0x34, 0x5f,
0x70, 0x58, 0x2d, 0xb5, 0x3e, 0xd1, 0xb3, 0xc0, 0xa0, 0x78, 0xce, 0x35, 0x65, 0xa5, 0xe0, 0x50,
0x43, 0xdc, 0x8a, 0xd5, 0x3d, 0x19, 0x76, 0x61, 0x9c, 0x04, 0x1f, 0xa2, 0x08, 0xac, 0x92, 0x2a,
0x9b, 0xda, 0x0c, 0xfa, 0x56, 0x63, 0xd9, 0xea, 0xa7, 0x03, 0xb1, 0x4d, 0x10, 0x89, 0x52, 0x27,
0x42, 0x1f, 0x26, 0x29, 0x1c, 0x49, 0xc1, 0x10, 0x6d, 0xaa, 0xf9, 0x5e, 0x36, 0x7b, 0x6e, 0xbf,
0xe0, 0xd3, 0xac, 0x9c, 0xaa, 0x06, 0x56, 0x5b, 0x97, 0xa1, 0x88, 0x07, 0x49, 0x57, 0x02, 0x9f,
0xa2, 0xb7, 0x19, 0x28, 0x61, 0x52, 0x00, 0x9b, 0xaf, 0xd6, 0xec, 0x80, 0xb7, 0x17, 0x67, 0x58,
0xe5, 0x56, 0xe8, 0xe3, 0xb1, 0x0c, 0xd1, 0x87, 0x31, 0xdb, 0x2d, 0x92, 0x3a, 0xcb, 0xcb, 0x96,
0xc2, 0x5d, 0x27, 0x63, 0x0a, 0x18, 0x52, 0xc9, 0xdf, 0x14, 0xba, 0x00, 0x1d, 0xd3, 0x8b, 0xb7,
0xed, 0xfa, 0xd8, 0x29, 0x5e, 0xef, 0xda, 0x17, 0x3f, 0x51, 0xf7, 0x72, 0x4c, 0xc3, 0x09, 0x69,
0xda, 0x42, 0x73, 0x38, 0xd0, 0x06, 0x7b, 0x2d, 0x15, 0x1e, 0xcb, 0xae, 0x06, 0x49, 0x9a, 0x76,
0x94, 0xf0, 0x0b, 0xd7, 0xef, 0x50, 0xce, 0xb9, 0x18, 0xa0, 0xd0, 0x45, 0xa9, 0x77, 0x6d, 0xbf,
0xb4, 0xa6, 0xae, 0x05, 0x52, 0x68, 0x08, 0xc8, 0x15, 0xb2, 0x32, 0x39, 0xf6, 0xe8, 0x7d, 0xd7,
0x02, 0x83, 0x71, 0x72, 0x0e, 0xf9, 0x02, 0x9b, 0x4d, 0xf8, 0x0f, 0x44, 0x6c, 0xa4, 0x15, 0xf2,
0xb2, 0x63, 0x33, 0x29, 0x56, 0x51, 0x8e, 0xbd, 0x42, 0xe3, 0xa9, 0x76, 0x53, 0xe8, 0x1c, 0xfa,
0x89, 0xc3, 0x17, 0xd9, 0xdc, 0xd0, 0xb5, 0x1c, 0xff, 0xa9, 0xc3, 0xe7, 0x59, 0x9d, 0x5c, 0xcb,
0x30, 0x0d, 0x3f, 0xb3, 0x20, 0x39, 0x51, 0x00, 0x7f, 0x6e, 0x25, 0xa4, 0x5e, 0x14, 0xf0, 0x5f,
0x58, 0x65, 0x24, 0x21, 0x4d, 0x22, 0x0d, 0xaf, 0x39, 0x64, 0xe9, 0x50, 0x59, 0x0a, 0xc3, 0xeb,
0x96, 0x91, 0xa4, 0x66, 0x8c, 0x6f, 0x58, 0xc6, 0x54, 0x66, 0x86, 0xbe, 0x69, 0xd1, 0x9b, 0x22,
0xf4, 0xd5, 0xf1, 0x71, 0x86, 0xbe, 0xe5, 0xf0, 0x06, 0x9b, 0xa7, 0xeb, 0xeb, 0x22, 0x10, 0xa1,
0x97, 0xf3, 0xbf, 0xed, 0xf0, 0x0b, 0x0c, 0xce, 0xa9, 0xd3, 0xf0, 0xfc, 0x38, 0x87, 0x61, 0x7c,
0x6d, 0x1d, 0xc1, 0x17, 0xc6, 0x6d, 0xac, 0x52, 0xc6, 0x04, 0xfb, 0xe2, 0x38, 0xaf, 0x27, 0x41,
0x4f, 0xce, 0x5f, 0x1a, 0xe7, 0x55, 0x36, 0xb9, 0x1d, 0x6a, 0x8c, 0x0d, 0x7c, 0x86, 0xf2, 0x7b,
0x32, 0xe9, 0xbd, 0xf0, 0x59, 0xaa, 0xa8, 0x09, 0x9b, 0xdf, 0xf0, 0x12, 0xcd, 0x75, 0xee, 0xa2,
0xc6, 0xd0, 0x2f, 0xd4, 0x8e, 0x86, 0xcf, 0xd9, 0x1b, 0xc9, 0xe0, 0x84, 0xbf, 0x94, 0x6c, 0x68,
0x8a, 0x53, 0xf4, 0xaf, 0x25, 0x32, 0x61, 0x0b, 0x4d, 0x5e, 0xd9, 0xf0, 0xb7, 0x12, 0xbf, 0xc4,
0x2e, 0x0c, 0x31, 0x3b, 0xd3, 0xb2, 0x9a, 0xfe, 0x7b, 0x89, 0x5f, 0x61, 0x17, 0xa9, 0xc1, 0x67,
0x79, 0x43, 0x97, 0xa4, 0x36, 0xd2, 0xd3, 0xf0, 0x6a, 0x89, 0x5f, 0x66, 0x8b, 0x5b, 0x68, 0xb2,
0xf7, 0x28, 0x10, 0xff, 0x51, 0xe2, 0x33, 0x6c, 0x9a, 0xaa, 0x5e, 0xe2, 0x29, 0xc2, 0x6b, 0x25,
0x7a, 0xd4, 0xe1, 0x31, 0x35, 0xe7, 0xf5, 0x12, 0x85, 0xfa, 0x03, 0xc2, 0x78, 0x27, 0xed, 0x5e,
0xeb, 0x44, 0x84, 0x21, 0x06, 0x1a, 0xde, 0x28, 0x51, 0x40, 0x5d, 0xec, 0xa9, 0x53, 0x2c, 0xc0,
0x6f, 0x5a, 0xa7, 0x2d, 0xf3, 0xfb, 0xfb, 0x18, 0x0f, 0x32, 0xc2, 0x5b, 0x25, 0x7a, 0x9a, 0x84,
0x7f, 0x94, 0xf2, 0x76, 0x89, 0x5f, 0x65, 0x8d, 0xa4, 0x59, 0x0c, 0x1f, 0x86, 0x88, 0x5d, 0xa4,
0xc6, 0x0c, 0xcf, 0x97, 0x33, 0x89, 0x6d, 0x0c, 0x8c, 0xc8, 0xee, 0x7d, 0xbc, 0x4c, 0x76, 0x51,
0x71, 0xe5, 0xfd, 0x58, 0xc3, 0x0b, 0x65, 0x7a, 0xd1, 0x2d, 0x34, 0x69, 0x4b, 0xd6, 0xf0, 0x09,
0x5a, 0xa3, 0xea, 0xb7, 0x42, 0xdd, 0xef, 0x64, 0x86, 0xc2, 0x27, 0x87, 0x97, 0xdb, 0x52, 0x9b,
0x58, 0x76, 0xfa, 0x36, 0xd3, 0x3f, 0x55, 0x26, 0xa7, 0x0e, 0x07, 0xa1, 0x37, 0x02, 0xbf, 0x68,
0x65, 0xa6, 0xb6, 0x59, 0xa3, 0x7e, 0x59, 0xe6, 0xb3, 0x8c, 0x25, 0x55, 0x6d, 0x81, 0x5f, 0x0d,
0xe5, 0xd1, 0xde, 0x74, 0x8a, 0xb1, 0x1d, 0x2a, 0xf0, 0xeb, 0xcc, 0xc4, 0x42, 0xef, 0x84, 0xdf,
0x94, 0x29, 0xe8, 0x47, 0xb2, 0x87, 0x47, 0xd2, 0xbb, 0x0b, 0x5f, 0xae, 0x90, 0x7d, 0x36, 0x26,
0x7b, 0xca, 0xc7, 0x24, 0x47, 0xbe, 0x52, 0xa1, 0x94, 0xa3, 0x4c, 0x4e, 0x52, 0xee, 0xab, 0xf6,
0x9c, 0x8e, 0x82, 0xed, 0x36, 0x7c, 0x8d, 0xf6, 0x37, 0x96, 0x9e, 0x8f, 0x0e, 0xf7, 0xe1, 0xeb,
0x15, 0x52, 0xb5, 0x16, 0x04, 0xca, 0x13, 0x26, 0xab, 0xa7, 0x6f, 0x54, 0xa8, 0x20, 0x0b, 0xda,
0xd3, 0x77, 0xff, 0x66, 0xc5, 0x3a, 0x9a, 0xe0, 0x36, 0x5d, 0xdb, 0xd4, 0x56, 0xbf, 0x65, 0xa5,
0xd2, 0x0c, 0x22, 0x4b, 0x8e, 0x0c, 0x7c, 0xdb, 0xf2, 0x9d, 0x5f, 0x49, 0xe0, 0xb7, 0xd5, 0x34,
0x43, 0x0b, 0xd8, 0xef, 0xaa, 0x49, 0x85, 0x8d, 0xee, 0x20, 0xf0, 0x7b, 0x0b, 0x9f, 0xdf, 0x5b,
0xe0, 0x0f, 0x55, 0x32, 0xac, 0xb8, 0x7a, 0xd0, 0x02, 0xae, 0xe1, 0x8f, 0x55, 0xb2, 0x20, 0x5f,
0x32, 0xe0, 0x3b, 0x35, 0x0a, 0xd6, 0x70, 0xbd, 0x80, 0xef, 0xd6, 0xc8, 0xcd, 0x73, 0x8b, 0x05,
0x7c, 0xaf, 0x66, 0x9f, 0x23, 0x5b, 0x29, 0xe0, 0xfb, 0x05, 0x80, 0xb8, 0xe0, 0x07, 0x35, 0xdb,
0xc3, 0x46, 0xd6, 0x08, 0xf8, 0x61, 0x8d, 0x6c, 0x3b, 0xbf, 0x40, 0xc0, 0x8f, 0x6a, 0xc9, 0x73,
0x67, 0xab, 0x03, 0xfc, 0xb8, 0x46, 0x35, 0xf4, 0xe0, 0xa5, 0x01, 0x5e, 0xb6, 0xba, 0xf2, 0x75,
0x01, 0x5e, 0xa9, 0x35, 0x97, 0xd9, 0x54, 0x5b, 0x07, 0x76, 0xf2, 0x4c, 0xb1, 0x52, 0x5b, 0x07,
0x30, 0x46, 0x8d, 0x7a, 0x5d, 0xa9, 0x60, 0xe3, 0x2c, 0x8a, 0x9f, 0x7b, 0x0a, 0x9c, 0xe6, 0x3a,
0x9b, 0x6d, 0xa9, 0x5e, 0x24, 0xb2, 0x82, 0xb5, 0xc3, 0x26, 0x99, 0x52, 0xe8, 0x27, 0xa9, 0x32,
0x46, 0xdd, 0x7e, 0xe3, 0x0c, 0xbd, 0xbe, 0x9d, 0x89, 0x0e, 0x1d, 0xe9, 0x12, 0x05, 0xd9, 0x87,
0xf1, 0xe6, 0x07, 0x19, 0xb4, 0x54, 0xa8, 0xa5, 0x36, 0x18, 0x7a, 0x83, 0x1d, 0x3c, 0xc5, 0xc0,
0x4e, 0x5e, 0x13, 0xab, 0xb0, 0x0b, 0x63, 0xf6, 0x1b, 0x05, 0xed, 0xb7, 0x46, 0x32, 0x9f, 0xd7,
0x69, 0x0f, 0xb1, 0x1f, 0x22, 0x75, 0xc6, 0x36, 0x4e, 0x31, 0x34, 0x7d, 0x11, 0x04, 0x03, 0x28,
0xd1, 0xb9, 0xd5, 0xd7, 0x46, 0xf5, 0xe4, 0xc7, 0x68, 0x4c, 0x37, 0x3f, 0xed, 0xb0, 0x6a, 0x32,
0x8c, 0x33, 0xd3, 0x92, 0xe3, 0x01, 0x86, 0xbe, 0xb4, 0xc2, 0x69, 0x8f, 0xb6, 0x50, 0xba, 0x41,
0x38, 0x39, 0xd3, 0xa1, 0x11, 0xb1, 0xb5, 0xd0, 0x7e, 0x3e, 0xa4, 0xf7, 0x62, 0x6b, 0xa7, 0x0f,
0x13, 0x39, 0x98, 0xfb, 0x32, 0x49, 0x0b, 0x63, 0x51, 0xdc, 0x5a, 0xe8, 0xb7, 0x02, 0x14, 0x34,
0xaf, 0xa7, 0x9a, 0x37, 0x18, 0xcb, 0x3f, 0x1f, 0xad, 0xad, 0xf9, 0x88, 0x1c, 0x23, 0x8f, 0xb7,
0x02, 0xd5, 0x11, 0x01, 0x38, 0xb4, 0x21, 0xd8, 0x07, 0x1f, 0x6f, 0xbe, 0x38, 0xc1, 0x66, 0xcf,
0x7d, 0x2c, 0x92, 0xc9, 0xd9, 0x61, 0x2d, 0xa0, 0x57, 0xb9, 0xca, 0x1e, 0xca, 0x90, 0xfb, 0x56,
0x02, 0x87, 0x16, 0xcc, 0x8c, 0x7c, 0x6e, 0x37, 0x18, 0xe7, 0xd7, 0xd8, 0xe5, 0x9c, 0x78, 0xff,
0x46, 0x40, 0x6d, 0xb9, 0x91, 0x31, 0x9c, 0x5f, 0x0d, 0xca, 0x14, 0xad, 0x8c, 0x4a, 0x95, 0x9e,
0x7c, 0xda, 0xe5, 0x5f, 0xb6, 0xc9, 0xc8, 0x83, 0x49, 0xfa, 0xda, 0xca, 0x6d, 0xcc, 0x52, 0x06,
0xa6, 0x28, 0x8e, 0x19, 0x21, 0x1d, 0x47, 0xd3, 0x23, 0x60, 0x3a, 0x96, 0x2a, 0x14, 0xdc, 0x0c,
0xa4, 0x7e, 0x94, 0xb7, 0x02, 0x46, 0xdf, 0x00, 0xe7, 0x42, 0x90, 0xf4, 0x9c, 0xea, 0x08, 0xc5,
0x62, 0x6d, 0x34, 0x42, 0x06, 0x50, 0xa3, 0x1d, 0x68, 0x24, 0x2e, 0xc9, 0x8d, 0x99, 0x11, 0xe5,
0xe9, 0x84, 0xab, 0xd3, 0xb6, 0x93, 0xaf, 0xe7, 0x76, 0x36, 0xce, 0x8e, 0x60, 0xb6, 0xf7, 0x01,
0x8c, 0xa8, 0x2b, 0x0c, 0x71, 0x98, 0x1b, 0x75, 0xd4, 0x26, 0x09, 0xf0, 0x91, 0xe8, 0x26, 0x76,
0xef, 0xdf, 0x0b, 0x31, 0xd6, 0x27, 0x32, 0x82, 0xf9, 0x91, 0xa0, 0x25, 0xed, 0xc7, 0xe6, 0xc5,
0xc2, 0x48, 0x28, 0xc8, 0xf4, 0xfc, 0xd2, 0x85, 0xd1, 0x07, 0xb3, 0x0d, 0x20, 0xa7, 0x2e, 0x8e,
0x50, 0x77, 0x45, 0x28, 0xba, 0x05, 0x85, 0x17, 0x47, 0x14, 0x16, 0x3a, 0x4f, 0xe3, 0x3d, 0x8a,
0xcd, 0x65, 0x7f, 0x6d, 0xdc, 0xc6, 0x33, 0x73, 0x5b, 0x75, 0xee, 0xf0, 0x6b, 0xab, 0xc9, 0x5f,
0x92, 0xab, 0xc3, 0xbf, 0x24, 0x57, 0x77, 0x51, 0x6b, 0x12, 0x19, 0xd9, 0xfc, 0x68, 0xfc, 0x79,
0xca, 0xfe, 0x67, 0xf3, 0xc8, 0x83, 0xff, 0x09, 0x2b, 0xfc, 0x07, 0xe3, 0xce, 0x46, 0x85, 0xd3,
0x7e, 0xe7, 0xce, 0xfa, 0x0e, 0xab, 0x4b, 0x35, 0xbc, 0xd7, 0x8d, 0x23, 0x6f, 0xbd, 0xda, 0xb2,
0xf7, 0x0e, 0x48, 0xc6, 0x81, 0xf3, 0xa1, 0x95, 0xae, 0x34, 0x27, 0xfd, 0x0e, 0x49, 0xbb, 0x9e,
0xb0, 0x3d, 0x21, 0x55, 0xfa, 0xeb, 0xba, 0x88, 0xe4, 0xf5, 0x44, 0x4d, 0xd4, 0xf9, 0xbc, 0xe3,
0x74, 0x26, 0xad, 0xe6, 0xa7, 0xff, 0x19, 0x00, 0x00, 0xff, 0xff, 0x05, 0x17, 0xce, 0xdd, 0x67,
0x15, 0x00, 0x00,
// 2554 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xd9, 0x73, 0x23, 0x47,
0x19, 0xf7, 0x58, 0xb2, 0x65, 0xb5, 0x64, 0xb9, 0xdd, 0xf6, 0x7a, 0x95, 0x3d, 0xb2, 0x8e, 0x49,
0xc0, 0x88, 0xc4, 0x9b, 0x6c, 0xaa, 0x80, 0xa2, 0x2a, 0x14, 0xb6, 0x64, 0x7b, 0x5d, 0xf1, 0xc5,
0xd8, 0x1b, 0x28, 0xaa, 0x60, 0xab, 0x35, 0xf3, 0x59, 0xee, 0xdd, 0xd1, 0xf4, 0x30, 0xdd, 0xf2,
0x5a, 0x3c, 0x85, 0x00, 0x79, 0xe1, 0x05, 0xc2, 0x3f, 0xc0, 0x1f, 0x00, 0x14, 0x67, 0xe0, 0x01,
0x28, 0x6e, 0x12, 0xae, 0x67, 0x6e, 0x78, 0x84, 0x77, 0xce, 0x6c, 0x0e, 0xea, 0xeb, 0x9e, 0x4b,
0xde, 0x0d, 0x3c, 0xf0, 0xa6, 0xfe, 0x7d, 0x67, 0x7f, 0xfd, 0x5d, 0x23, 0x52, 0xf7, 0x64, 0xbf,
0x2f, 0xc3, 0x95, 0x28, 0x96, 0x5a, 0xb2, 0xb9, 0xbe, 0x08, 0x4e, 0x06, 0xca, 0x9e, 0x56, 0x2c,
0xe9, 0xc2, 0x62, 0x4f, 0xca, 0x5e, 0x00, 0x57, 0x0d, 0xd8, 0x1d, 0x1c, 0x5d, 0xf5, 0x41, 0x79,
0xb1, 0x88, 0xb4, 0x8c, 0x2d, 0xe3, 0xd2, 0x4d, 0x32, 0x79, 0xa0, 0xb9, 0x1e, 0x28, 0xf6, 0x14,
0x21, 0x10, 0xc7, 0x32, 0xbe, 0xe9, 0x49, 0x1f, 0x9a, 0xce, 0xa2, 0xb3, 0xdc, 0xb8, 0xf6, 0xe0,
0xca, 0x7d, 0xb4, 0xae, 0xac, 0x23, 0x5b, 0x5b, 0xfa, 0xe0, 0x56, 0x21, 0xfd, 0xc9, 0x16, 0xc8,
0x64, 0x0c, 0x5c, 0xc9, 0xb0, 0x39, 0xbe, 0xe8, 0x2c, 0x57, 0xdd, 0xe4, 0xb4, 0xf4, 0x4e, 0x52,
0x7f, 0x1a, 0x86, 0xcf, 0xf0, 0x60, 0x00, 0xfb, 0x5c, 0xc4, 0x8c, 0x92, 0xd2, 0x6d, 0x18, 0x1a,
0xfd, 0x55, 0x17, 0x7f, 0xb2, 0x79, 0x32, 0x71, 0x82, 0xe4, 0x44, 0xd0, 0x1e, 0x96, 0x9e, 0x24,
0xb5, 0xa7, 0x61, 0xd8, 0xe1, 0x9a, 0xbf, 0x89, 0x18, 0x23, 0x65, 0x9f, 0x6b, 0x6e, 0xa4, 0xea,
0xae, 0xf9, 0xbd, 0x74, 0x89, 0x94, 0xd7, 0x02, 0xd9, 0xcd, 0x55, 0x3a, 0x86, 0x98, 0xa8, 0x3c,
0x21, 0x74, 0x3f, 0xe0, 0x1e, 0x1c, 0xcb, 0xc0, 0x87, 0xd8, 0xb8, 0x84, 0x7a, 0x35, 0xef, 0xa5,
0x7a, 0x35, 0xef, 0xb1, 0x77, 0x93, 0xb2, 0x1e, 0x46, 0xd6, 0x9b, 0xc6, 0xb5, 0x87, 0xef, 0x1b,
0x81, 0x82, 0x9a, 0xc3, 0x61, 0x04, 0xae, 0x91, 0xc0, 0x10, 0x18, 0x43, 0xaa, 0x59, 0x5a, 0x2c,
0x2d, 0xd7, 0xdd, 0xe4, 0xb4, 0xf4, 0xe1, 0x11, 0xbb, 0x9b, 0xb1, 0x1c, 0x44, 0x6c, 0x8b, 0xd4,
0xa3, 0x1c, 0x53, 0x4d, 0x67, 0xb1, 0xb4, 0x5c, 0xbb, 0xf6, 0xc8, 0xff, 0xb2, 0x66, 0x9c, 0x76,
0x47, 0x44, 0x97, 0x1e, 0x23, 0x95, 0x55, 0xdf, 0x8f, 0x41, 0x29, 0xd6, 0x20, 0xe3, 0x22, 0x4a,
0x2e, 0x33, 0x2e, 0x22, 0x8c, 0x51, 0x24, 0x63, 0x6d, 0xee, 0x52, 0x72, 0xcd, 0xef, 0xa5, 0x17,
0x1c, 0x52, 0xd9, 0x51, 0xbd, 0x35, 0xae, 0x80, 0xbd, 0x8b, 0x4c, 0xf5, 0x55, 0xef, 0xa6, 0xb9,
0xaf, 0x7d, 0xf1, 0x4b, 0xf7, 0xf5, 0x60, 0x47, 0xf5, 0xcc, 0x3d, 0x2b, 0x7d, 0xfb, 0x03, 0x03,
0xdc, 0x57, 0xbd, 0xad, 0x4e, 0xa2, 0xd9, 0x1e, 0xd8, 0x25, 0x52, 0xd5, 0xa2, 0x0f, 0x4a, 0xf3,
0x7e, 0xd4, 0x2c, 0x2d, 0x3a, 0xcb, 0x65, 0x37, 0x07, 0xd8, 0x05, 0x32, 0xa5, 0xe4, 0x20, 0xf6,
0x60, 0xab, 0xd3, 0x2c, 0x1b, 0xb1, 0xec, 0xbc, 0xf4, 0x14, 0xa9, 0xee, 0xa8, 0xde, 0x75, 0xe0,
0x3e, 0xc4, 0xec, 0x71, 0x52, 0xee, 0x72, 0x65, 0x3d, 0xaa, 0xbd, 0xb9, 0x47, 0x78, 0x03, 0xd7,
0x70, 0x2e, 0x7d, 0x84, 0xd4, 0x3b, 0x3b, 0xdb, 0xff, 0x87, 0x06, 0x74, 0x5d, 0x1d, 0xf3, 0xd8,
0xdf, 0xe5, 0xfd, 0x34, 0x11, 0x73, 0x60, 0xe9, 0xae, 0x43, 0xea, 0xfb, 0xb1, 0x38, 0x11, 0x01,
0xf4, 0x60, 0xfd, 0x54, 0xb3, 0xf7, 0x91, 0x9a, 0xec, 0xde, 0x02, 0x4f, 0x17, 0x63, 0x77, 0xe5,
0xbe, 0x76, 0xf6, 0x0c, 0x9f, 0x09, 0x1f, 0x91, 0xd9, 0x6f, 0xb6, 0x47, 0x68, 0xa2, 0x21, 0x4a,
0x15, 0xff, 0xd7, 0x94, 0xb3, 0x6a, 0x32, 0x27, 0xdc, 0x19, 0x39, 0x0a, 0xb0, 0x16, 0x99, 0x4d,
0x14, 0x86, 0xbc, 0x0f, 0x37, 0x45, 0xe8, 0xc3, 0xa9, 0x79, 0x84, 0x89, 0x94, 0x17, 0xaf, 0xb2,
0x85, 0x30, 0x7b, 0x94, 0xb0, 0x7b, 0x78, 0x95, 0x79, 0x94, 0x09, 0x97, 0x9e, 0x61, 0x56, 0xad,
0xe7, 0xaa, 0xa4, 0x9a, 0xd5, 0x3c, 0xab, 0x91, 0xca, 0xc1, 0xc0, 0xf3, 0x40, 0x29, 0x3a, 0xc6,
0xe6, 0xc8, 0xcc, 0x8d, 0x10, 0x4e, 0x23, 0xf0, 0x34, 0xf8, 0x86, 0x87, 0x3a, 0x6c, 0x96, 0x4c,
0xb7, 0x65, 0x18, 0x82, 0xa7, 0x37, 0xb8, 0x08, 0xc0, 0xa7, 0xe3, 0x6c, 0x9e, 0xd0, 0x7d, 0x88,
0xfb, 0x42, 0x29, 0x21, 0xc3, 0x0e, 0x84, 0x02, 0x7c, 0x5a, 0x62, 0xe7, 0xc9, 0x5c, 0x5b, 0x06,
0x01, 0x78, 0x5a, 0xc8, 0x70, 0x57, 0xea, 0xf5, 0x53, 0xa1, 0xb4, 0xa2, 0x65, 0x54, 0xbb, 0x15,
0x04, 0xd0, 0xe3, 0xc1, 0x6a, 0xdc, 0x1b, 0xf4, 0x21, 0xd4, 0x74, 0x02, 0x75, 0x24, 0x60, 0x47,
0xf4, 0x21, 0x44, 0x4d, 0xb4, 0x52, 0x40, 0x8d, 0xb7, 0x18, 0x5b, 0x3a, 0xc5, 0x1e, 0x20, 0xe7,
0x12, 0xb4, 0x60, 0x80, 0xf7, 0x81, 0x56, 0xd9, 0x0c, 0xa9, 0x25, 0xa4, 0xc3, 0xbd, 0xfd, 0xa7,
0x29, 0x29, 0x68, 0x70, 0xe5, 0x1d, 0x17, 0x3c, 0x19, 0xfb, 0xb4, 0x56, 0x70, 0xe1, 0x19, 0xf0,
0xb4, 0x8c, 0xb7, 0x3a, 0xb4, 0x8e, 0x0e, 0x27, 0xe0, 0x01, 0xf0, 0xd8, 0x3b, 0x76, 0x41, 0x0d,
0x02, 0x4d, 0xa7, 0x19, 0x25, 0xf5, 0x0d, 0x11, 0xc0, 0xae, 0xd4, 0x1b, 0x72, 0x10, 0xfa, 0xb4,
0xc1, 0x1a, 0x84, 0xec, 0x80, 0xe6, 0x49, 0x04, 0x66, 0xd0, 0x6c, 0x9b, 0x7b, 0xc7, 0x90, 0x00,
0x94, 0x2d, 0x10, 0xd6, 0xe6, 0x61, 0x28, 0x75, 0x3b, 0x06, 0xae, 0x61, 0xc3, 0x54, 0x33, 0x9d,
0x45, 0x77, 0x46, 0x70, 0x11, 0x00, 0x65, 0x39, 0x77, 0x07, 0x02, 0xc8, 0xb8, 0xe7, 0x72, 0xee,
0x04, 0x47, 0xee, 0x79, 0x74, 0x7e, 0x6d, 0x20, 0x02, 0xdf, 0x84, 0xc4, 0x3e, 0xcb, 0x39, 0xf4,
0x31, 0x71, 0x7e, 0x77, 0x7b, 0xeb, 0xe0, 0x90, 0x2e, 0xb0, 0x73, 0x64, 0x36, 0x41, 0x76, 0x40,
0xc7, 0xc2, 0x33, 0xc1, 0x3b, 0x8f, 0xae, 0xee, 0x0d, 0xf4, 0xde, 0xd1, 0x0e, 0xf4, 0x65, 0x3c,
0xa4, 0x4d, 0x7c, 0x50, 0xa3, 0x29, 0x7d, 0x22, 0xfa, 0x00, 0x5a, 0x58, 0xef, 0x47, 0x7a, 0x98,
0x87, 0x97, 0x5e, 0x60, 0x17, 0xc9, 0xf9, 0x1b, 0x91, 0xcf, 0x35, 0x6c, 0xf5, 0xb1, 0xd5, 0x1c,
0x72, 0x75, 0x1b, 0xaf, 0x3b, 0x88, 0x81, 0x5e, 0x64, 0x17, 0xc8, 0xc2, 0xe8, 0x5b, 0x64, 0xc1,
0xba, 0x84, 0x82, 0xf6, 0xb6, 0xed, 0x18, 0x7c, 0x08, 0xb5, 0xe0, 0x41, 0x2a, 0x78, 0x39, 0xd7,
0x7a, 0x2f, 0xf1, 0x41, 0x24, 0xda, 0x9b, 0xdf, 0x4b, 0xbc, 0xc2, 0x9a, 0x64, 0x7e, 0x13, 0xf4,
0xbd, 0x94, 0x45, 0xa4, 0x6c, 0x0b, 0x65, 0x48, 0x37, 0x14, 0xc4, 0x2a, 0xa5, 0x3c, 0xc4, 0x18,
0x69, 0x6c, 0x82, 0x46, 0x30, 0xc5, 0x96, 0x30, 0x4e, 0xd6, 0x3d, 0x57, 0x06, 0x90, 0xc2, 0x6f,
0xc1, 0x18, 0x74, 0x62, 0x19, 0x15, 0xc1, 0x87, 0xf1, 0x9a, 0x7b, 0x11, 0xc4, 0x5c, 0x03, 0xea,
0x28, 0xd2, 0x1e, 0x41, 0x3d, 0x07, 0x80, 0x11, 0x28, 0xc2, 0x6f, 0xcd, 0xe1, 0xa2, 0xd5, 0xb7,
0x61, 0x0e, 0x27, 0xdc, 0x60, 0xfb, 0x64, 0x4a, 0x5a, 0xc6, 0x5b, 0x27, 0x46, 0xb2, 0xfa, 0x4f,
0x89, 0x6f, 0xc7, 0x54, 0xb1, 0x72, 0x9b, 0x31, 0x0f, 0x75, 0x8a, 0xb7, 0xd8, 0x43, 0xe4, 0xb2,
0x0b, 0x47, 0x31, 0xa8, 0xe3, 0x7d, 0x19, 0x08, 0x6f, 0xb8, 0x15, 0x1e, 0xc9, 0x2c, 0x25, 0x91,
0xe5, 0x1d, 0xe8, 0x09, 0x86, 0xc5, 0xd2, 0x53, 0xf8, 0x51, 0x8c, 0xc9, 0xae, 0xd4, 0x07, 0xd8,
0x0e, 0xb7, 0x4d, 0x83, 0xa5, 0x8f, 0xa1, 0x95, 0x5d, 0xe9, 0x42, 0x14, 0x08, 0x8f, 0xaf, 0x9e,
0x70, 0x11, 0xf0, 0x6e, 0x00, 0x74, 0x05, 0x83, 0x72, 0x00, 0x3d, 0x2c, 0xd9, 0xec, 0x7d, 0xaf,
0xb2, 0x69, 0x52, 0xdd, 0x90, 0xb1, 0x07, 0x1d, 0x08, 0x87, 0xf4, 0x71, 0x3c, 0xba, 0x5c, 0xc3,
0xb6, 0xe8, 0x0b, 0x4d, 0x9f, 0xc0, 0x7c, 0xc3, 0x39, 0xdf, 0x96, 0x32, 0xf6, 0x77, 0x57, 0xa9,
0xcf, 0x18, 0x99, 0xee, 0x74, 0x5c, 0xf8, 0xe8, 0x00, 0x94, 0x76, 0xb9, 0x07, 0xf4, 0x2f, 0x95,
0x96, 0x47, 0x88, 0xc9, 0x41, 0xdc, 0x56, 0x00, 0x3d, 0xca, 0x4f, 0xbb, 0x32, 0x04, 0x3a, 0xc6,
0xea, 0x64, 0xea, 0x46, 0x28, 0x94, 0x1a, 0x80, 0x4f, 0x1d, 0xac, 0xbf, 0xad, 0x70, 0x3f, 0x96,
0x3d, 0x1c, 0x8c, 0x74, 0x1c, 0xa9, 0x1b, 0x22, 0x14, 0xea, 0xd8, 0x74, 0x1e, 0x42, 0x26, 0x93,
0x42, 0x2c, 0xb3, 0x2a, 0x99, 0x70, 0x41, 0xc7, 0x43, 0x3a, 0xd1, 0x7a, 0xce, 0x21, 0xf5, 0xc4,
0x7b, 0x6b, 0x67, 0x9e, 0xd0, 0xe2, 0x39, 0xb7, 0x94, 0x95, 0x82, 0x83, 0x0d, 0x71, 0x33, 0x96,
0x77, 0x44, 0xd8, 0xa3, 0xe3, 0xa8, 0xf8, 0x00, 0x78, 0x60, 0x8c, 0xd4, 0x48, 0x65, 0x23, 0x18,
0x18, 0x8b, 0x65, 0x63, 0x1f, 0x0f, 0xc8, 0x36, 0x81, 0x24, 0x4c, 0x9d, 0x08, 0x7c, 0x3a, 0x89,
0xe1, 0xb0, 0x05, 0x83, 0xb4, 0x4a, 0xeb, 0xbd, 0x64, 0xe6, 0xcc, 0x7e, 0xc1, 0xa6, 0x48, 0x39,
0x31, 0x4d, 0x49, 0x7d, 0x4d, 0x84, 0x3c, 0x1e, 0xda, 0xae, 0x44, 0x7d, 0x8c, 0xde, 0x46, 0x20,
0xb9, 0x4e, 0x00, 0x68, 0xbd, 0x38, 0x6d, 0x06, 0xbc, 0x11, 0x9c, 0x26, 0xd5, 0x1b, 0xa1, 0x0f,
0x47, 0x22, 0x04, 0x9f, 0x8e, 0x99, 0x6e, 0x61, 0xeb, 0x2c, 0x2f, 0x5b, 0x0c, 0x77, 0x03, 0x9d,
0x29, 0x60, 0x80, 0x25, 0x7f, 0x9d, 0xab, 0x02, 0x74, 0x84, 0x2f, 0xde, 0x31, 0xeb, 0x63, 0xb7,
0x28, 0xde, 0x33, 0x2f, 0x7e, 0x2c, 0xef, 0xe4, 0x98, 0xa2, 0xc7, 0x68, 0x69, 0x13, 0xf4, 0xc1,
0x50, 0x69, 0xe8, 0xb7, 0x65, 0x78, 0x24, 0x7a, 0x8a, 0x0a, 0xb4, 0xb4, 0x2d, 0xb9, 0x5f, 0x10,
0xbf, 0x85, 0x39, 0xe7, 0x42, 0x00, 0x5c, 0x15, 0xb5, 0xde, 0x36, 0xfd, 0xd2, 0xb8, 0xba, 0x1a,
0x08, 0xae, 0x68, 0x80, 0x57, 0x41, 0x2f, 0xed, 0xb1, 0x8f, 0xef, 0xbb, 0x1a, 0x68, 0x88, 0xed,
0x39, 0x64, 0xf3, 0x64, 0xc6, 0xf2, 0xef, 0xf3, 0x58, 0x0b, 0xa3, 0xe4, 0x25, 0xc7, 0x64, 0x52,
0x2c, 0xa3, 0x1c, 0x7b, 0x19, 0xc7, 0x53, 0xfd, 0x3a, 0x57, 0x39, 0xf4, 0x33, 0x87, 0x2d, 0x90,
0xd9, 0xf4, 0x6a, 0x39, 0xfe, 0x73, 0x87, 0xcd, 0x91, 0x06, 0x5e, 0x2d, 0xc3, 0x14, 0xfd, 0x85,
0x01, 0xf1, 0x12, 0x05, 0xf0, 0x97, 0x46, 0x43, 0x72, 0x8b, 0x02, 0xfe, 0x2b, 0x63, 0x0c, 0x35,
0x24, 0x49, 0xa4, 0xe8, 0x2b, 0x0e, 0x7a, 0x9a, 0x1a, 0x4b, 0x60, 0x7a, 0xd7, 0x30, 0xa2, 0xd6,
0x8c, 0xf1, 0x55, 0xc3, 0x98, 0xe8, 0xcc, 0xd0, 0xd7, 0x0c, 0x7a, 0x9d, 0x87, 0xbe, 0x3c, 0x3a,
0xca, 0xd0, 0xd7, 0x1d, 0xd6, 0x24, 0x73, 0x28, 0xbe, 0xc6, 0x03, 0x1e, 0x7a, 0x39, 0xff, 0x1b,
0x0e, 0x3b, 0x47, 0xe8, 0x19, 0x73, 0x8a, 0x3e, 0x3b, 0xce, 0x68, 0x1a, 0x5f, 0x53, 0x47, 0xf4,
0x0b, 0xe3, 0x26, 0x56, 0x09, 0xa3, 0xc5, 0xbe, 0x38, 0xce, 0x1a, 0x36, 0xe8, 0xf6, 0xfc, 0xa5,
0x71, 0x56, 0x23, 0x93, 0x5b, 0xa1, 0x82, 0x58, 0xd3, 0xcf, 0x60, 0x7e, 0x4f, 0xda, 0xde, 0x4b,
0x3f, 0x8b, 0x15, 0x35, 0x61, 0xf2, 0x9b, 0xbe, 0x80, 0x73, 0x9d, 0xb9, 0xa0, 0x20, 0xf4, 0x0b,
0xb5, 0xa3, 0xe8, 0xe7, 0x8c, 0x84, 0x1d, 0x9c, 0xf4, 0x6f, 0x25, 0x13, 0x9a, 0xe2, 0x14, 0xfd,
0x7b, 0x09, 0x5d, 0xd8, 0x04, 0x9d, 0x57, 0x36, 0xfd, 0x47, 0x89, 0x5d, 0x20, 0xe7, 0x52, 0xcc,
0xcc, 0xb4, 0xac, 0xa6, 0xff, 0x59, 0x62, 0x97, 0xc8, 0x79, 0x6c, 0xf0, 0x59, 0xde, 0xa0, 0x90,
0x50, 0x5a, 0x78, 0x8a, 0xfe, 0xab, 0xc4, 0x2e, 0x92, 0x85, 0x4d, 0xd0, 0xd9, 0x7b, 0x14, 0x88,
0xff, 0x2e, 0xb1, 0x69, 0x32, 0x85, 0x55, 0x2f, 0xe0, 0x04, 0xe8, 0x2b, 0x25, 0x7c, 0xd4, 0xf4,
0x98, 0xb8, 0x73, 0xb7, 0x84, 0xa1, 0xfe, 0x00, 0xd7, 0xde, 0x71, 0xa7, 0xdf, 0x3e, 0xe6, 0x61,
0x08, 0x81, 0xa2, 0xaf, 0x96, 0x30, 0xa0, 0x2e, 0xf4, 0xe5, 0x09, 0x14, 0xe0, 0xd7, 0xcc, 0xa5,
0x0d, 0xf3, 0xfb, 0x07, 0x10, 0x0f, 0x33, 0xc2, 0xeb, 0x25, 0x7c, 0x1a, 0xcb, 0x3f, 0x4a, 0x79,
0xa3, 0xc4, 0x2e, 0x93, 0xa6, 0x6d, 0x16, 0xe9, 0xc3, 0x20, 0xb1, 0x07, 0xd8, 0x98, 0xe9, 0xb3,
0xe5, 0x4c, 0x63, 0x07, 0x02, 0xcd, 0x33, 0xb9, 0x8f, 0x97, 0xd1, 0x2f, 0x2c, 0xae, 0xbc, 0x1f,
0x2b, 0xfa, 0x5c, 0x19, 0x5f, 0x74, 0x13, 0x74, 0xd2, 0x92, 0x15, 0xfd, 0x04, 0xae, 0x51, 0x8d,
0x1b, 0xa1, 0x1a, 0x74, 0x33, 0x47, 0xe9, 0x27, 0x53, 0xe1, 0x8e, 0x50, 0x3a, 0x16, 0xdd, 0x81,
0xc9, 0xf4, 0x4f, 0x95, 0xf1, 0x52, 0x07, 0xc3, 0xd0, 0x1b, 0x81, 0x9f, 0x37, 0x3a, 0x13, 0xdf,
0x8c, 0x53, 0xbf, 0x2e, 0xb3, 0x19, 0x42, 0x6c, 0x55, 0x1b, 0xe0, 0x37, 0xa9, 0x3e, 0xdc, 0x9b,
0x4e, 0x20, 0x36, 0x43, 0x85, 0xfe, 0x36, 0x73, 0xb1, 0xd0, 0x3b, 0xe9, 0xef, 0x8c, 0x43, 0xc9,
0x56, 0x33, 0x08, 0x6d, 0xa1, 0x7f, 0x7b, 0x02, 0xf3, 0x00, 0x73, 0x2c, 0x83, 0xbe, 0x33, 0x91,
0x48, 0xa7, 0x88, 0xd1, 0xf9, 0xdd, 0x09, 0x7c, 0xb2, 0x43, 0xd1, 0x87, 0x43, 0xe1, 0xdd, 0xa6,
0x5f, 0xae, 0xa2, 0x32, 0x13, 0xd1, 0x5d, 0xe9, 0x83, 0xcd, 0xb0, 0xaf, 0x54, 0x31, 0x61, 0xb1,
0x0e, 0x6c, 0xc2, 0x7e, 0xd5, 0x9c, 0x93, 0x41, 0xb2, 0xd5, 0xa1, 0x5f, 0xc3, 0xed, 0x8f, 0x24,
0xe7, 0xc3, 0x83, 0x3d, 0xfa, 0xf5, 0x2a, 0x9a, 0x5a, 0x0d, 0x02, 0xe9, 0x71, 0x9d, 0x55, 0xe3,
0x37, 0xaa, 0x58, 0xce, 0x05, 0xdf, 0x93, 0xac, 0x79, 0xb1, 0x6a, 0xc2, 0x64, 0x71, 0x93, 0xec,
0x1d, 0x6c, 0xca, 0xdf, 0x34, 0x5a, 0x71, 0x82, 0xa1, 0x27, 0x87, 0x9a, 0x7e, 0xcb, 0xf0, 0x9d,
0x5d, 0x68, 0xe8, 0xef, 0x6b, 0x49, 0x7e, 0x17, 0xb0, 0x3f, 0xd4, 0x6c, 0x7d, 0x8e, 0x6e, 0x30,
0xf4, 0x8f, 0x06, 0x3e, 0xbb, 0xf5, 0xd0, 0x3f, 0xd5, 0xd0, 0xb1, 0xe2, 0xe2, 0x82, 0xeb, 0xbb,
0xa2, 0x7f, 0xae, 0xa1, 0x07, 0xf9, 0x8a, 0x42, 0xbf, 0x57, 0xc7, 0x60, 0xa5, 0xcb, 0x09, 0xfd,
0x7e, 0x1d, 0xaf, 0x79, 0x66, 0x2d, 0xa1, 0x3f, 0xa8, 0x9b, 0xc7, 0xcc, 0x16, 0x12, 0xfa, 0xc3,
0x02, 0x80, 0x5c, 0xf4, 0x47, 0x75, 0xd3, 0x01, 0x47, 0x96, 0x10, 0xfa, 0xe3, 0x3a, 0xfa, 0x76,
0x76, 0xfd, 0xa0, 0x3f, 0xa9, 0xdb, 0x64, 0xc9, 0x16, 0x0f, 0xfa, 0xd3, 0x3a, 0x56, 0xe0, 0xfd,
0x57, 0x0e, 0xfa, 0x92, 0xb1, 0x95, 0x2f, 0x1b, 0xf4, 0xe5, 0x7a, 0x6b, 0x89, 0x54, 0x3a, 0x2a,
0x30, 0x73, 0xab, 0x42, 0x4a, 0x1d, 0x15, 0xd0, 0x31, 0x6c, 0xf3, 0x6b, 0x52, 0x06, 0xeb, 0xa7,
0x51, 0xfc, 0xcc, 0x13, 0xd4, 0x69, 0xad, 0x91, 0x99, 0xb6, 0xec, 0x47, 0x3c, 0x2b, 0x77, 0x33,
0xaa, 0xec, 0x8c, 0x03, 0xdf, 0x26, 0xda, 0x18, 0xce, 0x8a, 0xf5, 0x53, 0xf0, 0x06, 0x66, 0xa2,
0x3a, 0x78, 0x44, 0x21, 0x0c, 0xb2, 0x4f, 0xc7, 0x5b, 0x1f, 0x24, 0xb4, 0x2d, 0x43, 0x25, 0x94,
0x86, 0xd0, 0x1b, 0x6e, 0xc3, 0x09, 0x04, 0x66, 0x6e, 0xeb, 0x58, 0x86, 0x3d, 0x3a, 0x66, 0xbe,
0x70, 0xc0, 0x7c, 0xa9, 0xd8, 0xe9, 0xbe, 0x86, 0x5b, 0x8c, 0xf9, 0x8c, 0x69, 0x10, 0xb2, 0x7e,
0x02, 0xa1, 0x1e, 0xf0, 0x20, 0x18, 0xd2, 0x12, 0x9e, 0xdb, 0x03, 0xa5, 0x65, 0x5f, 0x7c, 0x0c,
0x87, 0x7c, 0xeb, 0xd3, 0x0e, 0xa9, 0xd9, 0x51, 0x9e, 0xb9, 0x66, 0x8f, 0xfb, 0x10, 0xfa, 0xc2,
0x28, 0xc7, 0x2d, 0xdc, 0x40, 0xc9, 0xfe, 0xe1, 0xe4, 0x4c, 0x07, 0x9a, 0xc7, 0xc6, 0x43, 0xf3,
0xf1, 0x91, 0xc8, 0xc5, 0xc6, 0x4f, 0x9f, 0x4e, 0xe4, 0x60, 0x7e, 0x97, 0x49, 0x5c, 0x37, 0x8b,
0xea, 0x56, 0x43, 0xbf, 0x1d, 0x00, 0xc7, 0x69, 0x5f, 0x69, 0x5d, 0x23, 0x24, 0xff, 0xf8, 0x34,
0xbe, 0xe6, 0x03, 0x76, 0x0c, 0x6f, 0xbc, 0x19, 0xc8, 0x2e, 0x0f, 0xa8, 0x83, 0xfb, 0x85, 0x79,
0xf0, 0xf1, 0xd6, 0xf3, 0x13, 0x64, 0xe6, 0xcc, 0xa7, 0x26, 0xba, 0x9c, 0x1d, 0x56, 0x03, 0x7c,
0x95, 0xcb, 0xe4, 0x81, 0x0c, 0xb9, 0x67, 0xa1, 0x70, 0x70, 0x3d, 0xcd, 0xc8, 0x67, 0x36, 0x8b,
0x71, 0x76, 0x85, 0x5c, 0xcc, 0x89, 0xf7, 0xee, 0x13, 0xd8, 0xd4, 0x9b, 0x19, 0xc3, 0xd9, 0xc5,
0xa2, 0x8c, 0xd1, 0xca, 0xa8, 0x58, 0xe9, 0xf6, 0xc3, 0x30, 0xff, 0x2e, 0xb6, 0x03, 0x93, 0x4e,
0xe2, 0xb7, 0x5a, 0xee, 0x63, 0x96, 0x32, 0xb4, 0x82, 0x71, 0xcc, 0x08, 0xc9, 0x30, 0x9b, 0x1a,
0x01, 0x93, 0xa1, 0x56, 0xc5, 0xe0, 0x66, 0x20, 0x76, 0xb3, 0xbc, 0x15, 0x10, 0xfc, 0x82, 0x38,
0x13, 0x02, 0xdb, 0x73, 0x6a, 0x23, 0x14, 0x83, 0x75, 0x40, 0x73, 0x11, 0xd0, 0x3a, 0x6e, 0x50,
0x23, 0x71, 0xb1, 0x12, 0xd3, 0x23, 0xc6, 0x93, 0xf9, 0xd8, 0xc0, 0x5d, 0x29, 0x5f, 0xee, 0xcd,
0x64, 0x9d, 0x19, 0xc1, 0x4c, 0xef, 0xa3, 0x74, 0xc4, 0x5c, 0x61, 0x05, 0xa0, 0xb3, 0xa3, 0x17,
0x35, 0x49, 0x42, 0xd9, 0x48, 0x74, 0xad, 0xdf, 0x7b, 0x77, 0x42, 0x88, 0xd5, 0xb1, 0x88, 0xe8,
0xdc, 0x48, 0xd0, 0x6c, 0xfb, 0x31, 0x79, 0x31, 0x3f, 0x12, 0x0a, 0x74, 0x3d, 0x17, 0x3a, 0x37,
0xfa, 0x60, 0xa6, 0x01, 0xe4, 0xd4, 0x85, 0x11, 0xea, 0x0e, 0x0f, 0x79, 0xaf, 0x60, 0xf0, 0xfc,
0x88, 0xc1, 0x42, 0xe7, 0x69, 0xbe, 0x47, 0x92, 0xd9, 0xec, 0x8f, 0x91, 0x9b, 0x70, 0xaa, 0x6f,
0xca, 0xee, 0x2d, 0x76, 0x65, 0xc5, 0xfe, 0xa1, 0xb9, 0x92, 0xfe, 0xa1, 0xb9, 0xb2, 0x03, 0x4a,
0xa1, 0xca, 0xc8, 0xe4, 0x47, 0xf3, 0xaf, 0x15, 0xf3, 0x8f, 0xcf, 0x43, 0xf7, 0xff, 0x1f, 0xad,
0xf0, 0x0f, 0x8e, 0x3b, 0x13, 0x15, 0x4e, 0x7b, 0xdd, 0x5b, 0x6b, 0xdb, 0xa4, 0x21, 0x64, 0x2a,
0xd7, 0x8b, 0x23, 0x6f, 0xad, 0xd6, 0x36, 0x72, 0xfb, 0xa8, 0x63, 0xdf, 0xf9, 0xd0, 0x72, 0x4f,
0xe8, 0xe3, 0x41, 0x17, 0xb5, 0x5d, 0xb5, 0x6c, 0x8f, 0x09, 0x99, 0xfc, 0xba, 0xca, 0x23, 0x71,
0xd5, 0x9a, 0x89, 0xba, 0x9f, 0x77, 0x9c, 0xee, 0xa4, 0xb1, 0xfc, 0xe4, 0x7f, 0x02, 0x00, 0x00,
0xff, 0xff, 0xe4, 0xe3, 0x40, 0x8a, 0xa5, 0x15, 0x00, 0x00,
}

861
api/milvuspb/milvus.pb.go
View File

@ -6935,6 +6935,120 @@ func (m *OperatePrivilegeRequest) GetType() OperatePrivilegeType {
return OperatePrivilegeType_Grant
}
type CreateFunctionRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
// The unique function name in rootcoord.(Required)
FunctionName string `protobuf:"bytes,2,opt,name=function_name,json=functionName,proto3" json:"function_name,omitempty"`
// wat file after base64.(Required)
WatBodyBase64 string `protobuf:"bytes,3,opt,name=wat_body_base64,json=watBodyBase64,proto3" json:"wat_body_base64,omitempty"`
// list of function parameter types.(Required)
ArgTypes []schemapb.DataType `protobuf:"varint,4,rep,packed,name=arg_types,json=argTypes,proto3,enum=milvus.proto.schema.DataType" json:"arg_types,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateFunctionRequest) Reset() { *m = CreateFunctionRequest{} }
func (m *CreateFunctionRequest) String() string { return proto.CompactTextString(m) }
func (*CreateFunctionRequest) ProtoMessage() {}
func (*CreateFunctionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{110}
}
func (m *CreateFunctionRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CreateFunctionRequest.Unmarshal(m, b)
}
func (m *CreateFunctionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CreateFunctionRequest.Marshal(b, m, deterministic)
}
func (m *CreateFunctionRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CreateFunctionRequest.Merge(m, src)
}
func (m *CreateFunctionRequest) XXX_Size() int {
return xxx_messageInfo_CreateFunctionRequest.Size(m)
}
func (m *CreateFunctionRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CreateFunctionRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CreateFunctionRequest proto.InternalMessageInfo
func (m *CreateFunctionRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *CreateFunctionRequest) GetFunctionName() string {
if m != nil {
return m.FunctionName
}
return ""
}
func (m *CreateFunctionRequest) GetWatBodyBase64() string {
if m != nil {
return m.WatBodyBase64
}
return ""
}
func (m *CreateFunctionRequest) GetArgTypes() []schemapb.DataType {
if m != nil {
return m.ArgTypes
}
return nil
}
type DropFunctionRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
// The unique function name in rootcoord.(Required)
FunctionName string `protobuf:"bytes,2,opt,name=function_name,json=functionName,proto3" json:"function_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DropFunctionRequest) Reset() { *m = DropFunctionRequest{} }
func (m *DropFunctionRequest) String() string { return proto.CompactTextString(m) }
func (*DropFunctionRequest) ProtoMessage() {}
func (*DropFunctionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{111}
}
func (m *DropFunctionRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DropFunctionRequest.Unmarshal(m, b)
}
func (m *DropFunctionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_DropFunctionRequest.Marshal(b, m, deterministic)
}
func (m *DropFunctionRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_DropFunctionRequest.Merge(m, src)
}
func (m *DropFunctionRequest) XXX_Size() int {
return xxx_messageInfo_DropFunctionRequest.Size(m)
}
func (m *DropFunctionRequest) XXX_DiscardUnknown() {
xxx_messageInfo_DropFunctionRequest.DiscardUnknown(m)
}
var xxx_messageInfo_DropFunctionRequest proto.InternalMessageInfo
func (m *DropFunctionRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *DropFunctionRequest) GetFunctionName() string {
if m != nil {
return m.FunctionName
}
return ""
}
type MilvusExt struct {
Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -6946,7 +7060,7 @@ func (m *MilvusExt) Reset() { *m = MilvusExt{} }
func (m *MilvusExt) String() string { return proto.CompactTextString(m) }
func (*MilvusExt) ProtoMessage() {}
func (*MilvusExt) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{110}
return fileDescriptor_02345ba45cc0e303, []int{112}
}
func (m *MilvusExt) XXX_Unmarshal(b []byte) error {
@ -7100,6 +7214,8 @@ func init() {
proto.RegisterType((*SelectGrantRequest)(nil), "milvus.proto.milvus.SelectGrantRequest")
proto.RegisterType((*SelectGrantResponse)(nil), "milvus.proto.milvus.SelectGrantResponse")
proto.RegisterType((*OperatePrivilegeRequest)(nil), "milvus.proto.milvus.OperatePrivilegeRequest")
proto.RegisterType((*CreateFunctionRequest)(nil), "milvus.proto.milvus.CreateFunctionRequest")
proto.RegisterType((*DropFunctionRequest)(nil), "milvus.proto.milvus.DropFunctionRequest")
proto.RegisterType((*MilvusExt)(nil), "milvus.proto.milvus.MilvusExt")
proto.RegisterExtension(E_MilvusExtObj)
}
@ -7107,338 +7223,345 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{
// 5293 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7d, 0x4b, 0x6c, 0x1c, 0x47,
0x7a, 0x30, 0x7b, 0xde, 0xf3, 0xcd, 0x83, 0xc3, 0xe2, 0x6b, 0x3c, 0x92, 0x2c, 0xaa, 0x6d, 0xd9,
0xb4, 0xb4, 0xa6, 0x6c, 0xca, 0x8f, 0xb5, 0xec, 0xb5, 0x2d, 0x89, 0xb6, 0x44, 0x58, 0x0f, 0xba,
0x29, 0x7b, 0xb1, 0xbf, 0x7f, 0xa3, 0xd1, 0x9c, 0x2e, 0x0e, 0xdb, 0xea, 0xe9, 0x1e, 0x75, 0xf7,
0x90, 0xa2, 0x73, 0x59, 0x60, 0xb3, 0x8b, 0x0d, 0xb2, 0x59, 0x23, 0xcf, 0x45, 0x0e, 0x79, 0x20,
0xd8, 0x1c, 0x82, 0x6c, 0x82, 0x38, 0x09, 0x10, 0x60, 0x73, 0xc8, 0xdd, 0x48, 0x90, 0xec, 0x21,
0x48, 0x16, 0xc9, 0x71, 0x91, 0x20, 0x87, 0x00, 0x39, 0xe4, 0x96, 0x04, 0x09, 0xea, 0xd1, 0x3d,
0xd5, 0x3d, 0xd5, 0xc3, 0xa1, 0xc6, 0x32, 0x29, 0xf3, 0x34, 0xfd, 0xd5, 0x57, 0x55, 0x5f, 0x7d,
0xf5, 0xbd, 0xaa, 0xea, 0xab, 0x22, 0x54, 0xbb, 0x96, 0xbd, 0xdb, 0xf7, 0x57, 0x7a, 0x9e, 0x1b,
0xb8, 0x68, 0x56, 0xfc, 0x5a, 0x61, 0x1f, 0xad, 0x6a, 0xdb, 0xed, 0x76, 0x5d, 0x87, 0x01, 0x5b,
0x55, 0xbf, 0xbd, 0x83, 0xbb, 0x06, 0xff, 0x5a, 0xea, 0xb8, 0x6e, 0xc7, 0xc6, 0x17, 0xe8, 0xd7,
0x56, 0x7f, 0xfb, 0x82, 0x89, 0xfd, 0xb6, 0x67, 0xf5, 0x02, 0xd7, 0x63, 0x18, 0xea, 0x6f, 0x2b,
0x80, 0xae, 0x7a, 0xd8, 0x08, 0xf0, 0x65, 0xdb, 0x32, 0x7c, 0x0d, 0xdf, 0xeb, 0x63, 0x3f, 0x40,
0xcf, 0x41, 0x6e, 0xcb, 0xf0, 0x71, 0x53, 0x59, 0x52, 0x96, 0x2b, 0xab, 0x27, 0x57, 0x62, 0x1d,
0xf3, 0x0e, 0x6f, 0xfa, 0x9d, 0x2b, 0x86, 0x8f, 0x35, 0x8a, 0x89, 0x16, 0xa1, 0x68, 0x6e, 0xe9,
0x8e, 0xd1, 0xc5, 0xcd, 0xcc, 0x92, 0xb2, 0x5c, 0xd6, 0x0a, 0xe6, 0xd6, 0x2d, 0xa3, 0x8b, 0xd1,
0xd3, 0x30, 0xdd, 0x76, 0x6d, 0x1b, 0xb7, 0x03, 0xcb, 0x75, 0x18, 0x42, 0x96, 0x22, 0xd4, 0x07,
0x60, 0x8a, 0x38, 0x07, 0x79, 0x83, 0xd0, 0xd0, 0xcc, 0xd1, 0x62, 0xf6, 0xa1, 0xfa, 0xd0, 0x58,
0xf3, 0xdc, 0xde, 0xc3, 0xa2, 0x2e, 0xea, 0x34, 0x2b, 0x76, 0xfa, 0x5b, 0x0a, 0xcc, 0x5c, 0xb6,
0x03, 0xec, 0x1d, 0x53, 0xa6, 0xfc, 0x28, 0x03, 0x8b, 0x6c, 0xd6, 0xae, 0x46, 0xe8, 0x47, 0x49,
0xe5, 0x02, 0x14, 0x98, 0xdc, 0x51, 0x32, 0xab, 0x1a, 0xff, 0x42, 0xa7, 0x00, 0xfc, 0x1d, 0xc3,
0x33, 0x7d, 0xdd, 0xe9, 0x77, 0x9b, 0xf9, 0x25, 0x65, 0x39, 0xaf, 0x95, 0x19, 0xe4, 0x56, 0xbf,
0x8b, 0x34, 0x98, 0x69, 0xbb, 0x8e, 0x6f, 0xf9, 0x01, 0x76, 0xda, 0xfb, 0xba, 0x8d, 0x77, 0xb1,
0xdd, 0x2c, 0x2c, 0x29, 0xcb, 0xf5, 0xd5, 0xb3, 0x52, 0xba, 0xaf, 0x0e, 0xb0, 0x6f, 0x10, 0x64,
0xad, 0xd1, 0x4e, 0x40, 0x2e, 0xa1, 0xcf, 0x5e, 0x9f, 0x2e, 0x29, 0x0d, 0xa5, 0xf9, 0xbf, 0xe1,
0x9f, 0xa2, 0xfe, 0x8e, 0x02, 0xf3, 0x44, 0x88, 0x8e, 0x05, 0xb3, 0x42, 0x0a, 0x33, 0x22, 0x85,
0x7f, 0xa0, 0xc0, 0xdc, 0x75, 0xc3, 0x3f, 0x1e, 0xb3, 0x79, 0x0a, 0x20, 0xb0, 0xba, 0x58, 0xf7,
0x03, 0xa3, 0xdb, 0xa3, 0x33, 0x9a, 0xd3, 0xca, 0x04, 0xb2, 0x49, 0x00, 0xea, 0x37, 0xa0, 0x7a,
0xc5, 0x75, 0x6d, 0x0d, 0xfb, 0x3d, 0xd7, 0xf1, 0x31, 0xba, 0x08, 0x05, 0x3f, 0x30, 0x82, 0xbe,
0xcf, 0x89, 0x3c, 0x21, 0x25, 0x72, 0x93, 0xa2, 0x68, 0x1c, 0x95, 0xc8, 0xf5, 0xae, 0x61, 0xf7,
0x19, 0x8d, 0x25, 0x8d, 0x7d, 0xa8, 0x1f, 0x40, 0x7d, 0x33, 0xf0, 0x2c, 0xa7, 0xf3, 0x39, 0x36,
0x5e, 0x0e, 0x1b, 0xff, 0x17, 0x05, 0x1e, 0x5b, 0xa3, 0xf6, 0x6f, 0xeb, 0x98, 0xa8, 0x8d, 0x0a,
0xd5, 0x01, 0x64, 0x7d, 0x8d, 0xb2, 0x3a, 0xab, 0xc5, 0x60, 0x89, 0xc9, 0xc8, 0x27, 0x26, 0x23,
0x14, 0xa6, 0xac, 0x28, 0x4c, 0xdf, 0xcc, 0x43, 0x4b, 0x36, 0xd0, 0x49, 0x58, 0xfa, 0xb5, 0x48,
0xc3, 0x33, 0xb4, 0x52, 0x42, 0x3f, 0xb9, 0xd7, 0x19, 0xf4, 0xb6, 0x49, 0x01, 0x91, 0x21, 0x48,
0x8e, 0x34, 0x2b, 0x19, 0xe9, 0x2a, 0xcc, 0xef, 0x5a, 0x5e, 0xd0, 0x37, 0x6c, 0xbd, 0xbd, 0x63,
0x38, 0x0e, 0xb6, 0x29, 0xef, 0x88, 0xe9, 0xcb, 0x2e, 0x97, 0xb5, 0x59, 0x5e, 0x78, 0x95, 0x95,
0x11, 0x06, 0xfa, 0xe8, 0x05, 0x58, 0xe8, 0xed, 0xec, 0xfb, 0x56, 0x7b, 0xa8, 0x52, 0x9e, 0x56,
0x9a, 0x0b, 0x4b, 0x63, 0xb5, 0xce, 0xc3, 0x4c, 0x9b, 0x5a, 0x4f, 0x53, 0x27, 0x9c, 0x64, 0xac,
0x2d, 0x50, 0xd6, 0x36, 0x78, 0xc1, 0x9d, 0x10, 0x4e, 0xc8, 0x0a, 0x91, 0xfb, 0x41, 0x5b, 0xa8,
0x50, 0xa4, 0x15, 0x66, 0x79, 0xe1, 0x7b, 0x41, 0x7b, 0x50, 0x27, 0x6e, 0xf7, 0x4a, 0x49, 0xbb,
0xd7, 0x84, 0x22, 0xb5, 0xe3, 0xd8, 0x6f, 0x96, 0x29, 0x99, 0xe1, 0x27, 0x5a, 0x87, 0x69, 0x3f,
0x30, 0xbc, 0x40, 0xef, 0xb9, 0xbe, 0x45, 0xf8, 0xe2, 0x37, 0x61, 0x29, 0xbb, 0x5c, 0x59, 0x5d,
0x92, 0x4e, 0xd2, 0x3b, 0x78, 0x7f, 0xcd, 0x08, 0x8c, 0x0d, 0xc3, 0xf2, 0xb4, 0x3a, 0xad, 0xb8,
0x11, 0xd6, 0x93, 0x1b, 0xd7, 0xca, 0x44, 0xc6, 0x55, 0x26, 0xd9, 0x55, 0x99, 0x64, 0xab, 0x7f,
0xa9, 0xc0, 0xfc, 0x0d, 0xd7, 0x30, 0x8f, 0x87, 0x9e, 0x9d, 0x85, 0xba, 0x87, 0x7b, 0xb6, 0xd5,
0x36, 0xc8, 0x7c, 0x6c, 0x61, 0x8f, 0x6a, 0x5a, 0x5e, 0xab, 0x71, 0xe8, 0x2d, 0x0a, 0xbc, 0x54,
0xfc, 0xec, 0xf5, 0x5c, 0x23, 0xdf, 0xcc, 0xaa, 0x3f, 0x50, 0xa0, 0xa9, 0x61, 0x1b, 0x1b, 0xfe,
0xf1, 0x30, 0x14, 0x8c, 0xb2, 0x42, 0x33, 0xab, 0xfe, 0xbb, 0x02, 0x73, 0xd7, 0x70, 0x40, 0x94,
0xd3, 0xf2, 0x03, 0xab, 0x7d, 0xa4, 0xb1, 0xc9, 0xd3, 0x30, 0xdd, 0x33, 0xbc, 0xc0, 0x8a, 0xf0,
0x42, 0x55, 0xad, 0x47, 0x60, 0xa6, 0x6f, 0x17, 0x60, 0xb6, 0xd3, 0x37, 0x3c, 0xc3, 0x09, 0x30,
0x16, 0x14, 0x88, 0x19, 0x33, 0x14, 0x15, 0x45, 0xfa, 0xc3, 0xc6, 0x0b, 0xcd, 0xac, 0xfa, 0x6d,
0x05, 0xe6, 0x13, 0xe3, 0x9d, 0xc4, 0x8a, 0xbd, 0x0c, 0x79, 0xf2, 0xcb, 0x6f, 0x66, 0xa8, 0x52,
0x9d, 0x49, 0x53, 0xaa, 0xf7, 0x89, 0xc3, 0xa0, 0x5a, 0xc5, 0xf0, 0x49, 0x40, 0xf8, 0xf8, 0x35,
0x1c, 0x08, 0xf6, 0xed, 0x38, 0xcc, 0xc0, 0x80, 0x4f, 0x9f, 0x28, 0x70, 0x3a, 0x95, 0xbe, 0x23,
0xe1, 0xd8, 0x7f, 0x2a, 0xb0, 0xb0, 0xb9, 0xe3, 0xee, 0x0d, 0x48, 0x7a, 0x18, 0x9c, 0x8a, 0x7b,
0xc7, 0x6c, 0xc2, 0x3b, 0xa2, 0xe7, 0x21, 0x17, 0xec, 0xf7, 0x30, 0x55, 0xf7, 0xfa, 0xea, 0xa9,
0x15, 0xc9, 0xfa, 0x69, 0x85, 0x10, 0x79, 0x67, 0xbf, 0x87, 0x35, 0x8a, 0x8a, 0x9e, 0x81, 0x46,
0x82, 0xf7, 0xa1, 0x2f, 0x99, 0x8e, 0x33, 0xdf, 0x0f, 0x7d, 0x6f, 0x4e, 0xf4, 0xbd, 0xff, 0x91,
0x81, 0xc5, 0xa1, 0x61, 0x4f, 0x32, 0x01, 0x32, 0x7a, 0x32, 0x52, 0x7a, 0x88, 0x99, 0x13, 0x50,
0x2d, 0x93, 0x2c, 0x6a, 0xb2, 0xcb, 0x59, 0xad, 0x26, 0xb8, 0x59, 0xd3, 0x47, 0xcf, 0x02, 0x1a,
0xf2, 0x7e, 0x4c, 0x73, 0x73, 0xda, 0x4c, 0xd2, 0xfd, 0x51, 0x17, 0x2b, 0xf5, 0x7f, 0x8c, 0x2d,
0x39, 0x6d, 0x4e, 0xe2, 0x00, 0x7d, 0xf4, 0x3c, 0xcc, 0x59, 0xce, 0x4d, 0xdc, 0x75, 0xbd, 0x7d,
0xbd, 0x87, 0xbd, 0x36, 0x76, 0x02, 0xa3, 0x83, 0xfd, 0x66, 0x81, 0x52, 0x34, 0x1b, 0x96, 0x6d,
0x0c, 0x8a, 0xd0, 0x4b, 0xb0, 0x78, 0xaf, 0x8f, 0xbd, 0x7d, 0xdd, 0xc7, 0xde, 0xae, 0xd5, 0xc6,
0xba, 0xb1, 0x6b, 0x58, 0xb6, 0xb1, 0x65, 0xe3, 0x66, 0x71, 0x29, 0xbb, 0x5c, 0xd2, 0xe6, 0x69,
0xf1, 0x26, 0x2b, 0xbd, 0x1c, 0x16, 0xaa, 0x7f, 0xa6, 0xc0, 0x02, 0x5b, 0x0c, 0x6d, 0x84, 0x66,
0xe7, 0x88, 0x9d, 0x4d, 0xdc, 0x2a, 0xf2, 0xa5, 0x5b, 0x2d, 0x66, 0x14, 0xd5, 0x4f, 0x15, 0x98,
0x23, 0x6b, 0x92, 0x47, 0x89, 0xe6, 0x3f, 0x51, 0x60, 0xf6, 0xba, 0xe1, 0x3f, 0x4a, 0x24, 0xff,
0x13, 0x0f, 0x44, 0x22, 0x9a, 0x1f, 0x0d, 0x8f, 0x39, 0x1c, 0xb1, 0xe4, 0x25, 0x11, 0x8b, 0xfa,
0x17, 0x83, 0x40, 0xe5, 0xd1, 0x1a, 0xa0, 0xfa, 0x63, 0x05, 0x4e, 0x5d, 0xc3, 0x41, 0x44, 0xf5,
0xf1, 0x88, 0x68, 0xc6, 0x14, 0xaa, 0xef, 0xb3, 0x68, 0x40, 0x4a, 0xfc, 0x91, 0x38, 0xdb, 0x5f,
0xcc, 0xc0, 0x3c, 0xf1, 0x3a, 0xc7, 0x43, 0x08, 0xc6, 0x59, 0xd6, 0x4a, 0x04, 0x25, 0x2f, 0xd5,
0x84, 0xd0, 0x85, 0x17, 0xc6, 0x76, 0xe1, 0xea, 0x9f, 0x66, 0x58, 0xe8, 0x21, 0x72, 0x63, 0x92,
0x69, 0x91, 0xd0, 0x9a, 0x91, 0xd2, 0xaa, 0x42, 0x35, 0x82, 0xac, 0xaf, 0x85, 0xee, 0x37, 0x06,
0x3b, 0xae, 0xde, 0x57, 0xfd, 0x9e, 0x02, 0x0b, 0xe1, 0xa6, 0xc1, 0x26, 0xee, 0x74, 0xb1, 0x13,
0x3c, 0xb8, 0x0c, 0x25, 0x25, 0x20, 0x23, 0x91, 0x80, 0x93, 0x50, 0xf6, 0x59, 0x3f, 0xd1, 0x7e,
0xc0, 0x00, 0xa0, 0xfe, 0x95, 0x02, 0x8b, 0x43, 0xe4, 0x4c, 0x32, 0x89, 0x4d, 0x28, 0x5a, 0x8e,
0x89, 0xef, 0x47, 0xd4, 0x84, 0x9f, 0xa4, 0x64, 0xab, 0x6f, 0xd9, 0x66, 0x44, 0x46, 0xf8, 0x89,
0xce, 0x40, 0x15, 0x3b, 0x24, 0xc6, 0xd0, 0x29, 0x2e, 0x15, 0xe4, 0x92, 0x56, 0x61, 0xb0, 0x75,
0x02, 0x22, 0x95, 0xb7, 0x2d, 0x4c, 0x2b, 0xe7, 0x59, 0x65, 0xfe, 0xa9, 0xfe, 0x92, 0x02, 0xb3,
0x44, 0x0a, 0x39, 0xf5, 0xfe, 0xc3, 0xe5, 0xe6, 0x12, 0x54, 0x04, 0x31, 0xe3, 0x03, 0x11, 0x41,
0xea, 0x5d, 0x98, 0x8b, 0x93, 0x33, 0x09, 0x37, 0x1f, 0x07, 0x88, 0xe6, 0x8a, 0x69, 0x43, 0x56,
0x13, 0x20, 0xea, 0xaf, 0x67, 0xc2, 0x63, 0x05, 0xca, 0xa6, 0x23, 0xde, 0xcd, 0xa4, 0x53, 0x22,
0xda, 0xf3, 0x32, 0x85, 0xd0, 0xe2, 0x35, 0xa8, 0xe2, 0xfb, 0x81, 0x67, 0xe8, 0x3d, 0xc3, 0x33,
0xba, 0x4c, 0xad, 0xc6, 0x32, 0xbd, 0x15, 0x5a, 0x6d, 0x83, 0xd6, 0x22, 0x9d, 0x50, 0x11, 0x61,
0x9d, 0x14, 0x58, 0x27, 0x14, 0x32, 0x58, 0xa7, 0x55, 0x9a, 0x59, 0xf5, 0x27, 0x24, 0xea, 0xe3,
0x62, 0x7d, 0xdc, 0x39, 0x13, 0x1f, 0x53, 0x5e, 0x3a, 0xa6, 0x6a, 0x33, 0xab, 0xfe, 0xbe, 0x02,
0x0d, 0x3a, 0x96, 0x35, 0x7e, 0xb8, 0x64, 0xb9, 0x4e, 0xa2, 0xb2, 0x92, 0xa8, 0x3c, 0x42, 0x1b,
0x5f, 0x81, 0x02, 0x9f, 0x89, 0xec, 0xb8, 0x33, 0xc1, 0x2b, 0x1c, 0x30, 0x1e, 0xf5, 0xf7, 0x14,
0x98, 0x4f, 0xf0, 0x7e, 0x12, 0x15, 0xb8, 0x03, 0x88, 0x8d, 0xd0, 0x1c, 0x0c, 0x3b, 0xf4, 0xdc,
0x67, 0xa5, 0x6e, 0x2a, 0xc9, 0x24, 0x6d, 0xc6, 0x4a, 0x40, 0x7c, 0xf5, 0xa7, 0x0a, 0x9c, 0xbc,
0x86, 0x03, 0x8a, 0x7a, 0x85, 0x98, 0xa1, 0x0d, 0xcf, 0xed, 0x78, 0xd8, 0xf7, 0xbf, 0x04, 0x82,
0xf2, 0x1b, 0x2c, 0xe6, 0x93, 0x8d, 0x6d, 0x92, 0x89, 0x38, 0x03, 0x55, 0xda, 0x19, 0x36, 0x75,
0xcf, 0xdd, 0xf3, 0xb9, 0x40, 0x55, 0x38, 0x4c, 0x73, 0xf7, 0xa8, 0x64, 0x04, 0x6e, 0x60, 0xd8,
0x0c, 0x81, 0x3b, 0x1b, 0x0a, 0x21, 0xc5, 0x54, 0x2b, 0x43, 0xc2, 0x48, 0xe3, 0xf8, 0x4b, 0xc0,
0xec, 0x1f, 0xb2, 0x9d, 0x33, 0x71, 0x4c, 0x93, 0x30, 0xf9, 0x45, 0x16, 0x9a, 0xb2, 0x51, 0xd5,
0x57, 0x4f, 0x4b, 0xeb, 0x08, 0x9d, 0x31, 0x6c, 0x74, 0x1a, 0x2a, 0xdb, 0x86, 0x65, 0xeb, 0x1e,
0x36, 0x7c, 0xd7, 0xe1, 0x23, 0x06, 0x02, 0xd2, 0x28, 0x44, 0xfd, 0x1b, 0x85, 0x9d, 0xef, 0x7e,
0x19, 0x8c, 0x61, 0xad, 0x99, 0x55, 0x7f, 0x94, 0x81, 0xda, 0xba, 0xe3, 0x63, 0x2f, 0x38, 0xfe,
0xeb, 0x18, 0xf4, 0x06, 0x54, 0xe8, 0x08, 0x7d, 0xdd, 0x34, 0x02, 0x83, 0xbb, 0xbe, 0xc7, 0xa5,
0x27, 0x3b, 0x6f, 0x13, 0xbc, 0x35, 0x23, 0x30, 0x34, 0xc6, 0x26, 0x9f, 0xfc, 0x46, 0x27, 0xa0,
0xbc, 0x63, 0xf8, 0x3b, 0xfa, 0x5d, 0xbc, 0xcf, 0x82, 0xcb, 0x9a, 0x56, 0x22, 0x80, 0x77, 0xf0,
0xbe, 0x8f, 0x1e, 0x83, 0x92, 0xd3, 0xef, 0x32, 0x95, 0x2b, 0x2e, 0x29, 0xcb, 0x35, 0xad, 0xe8,
0xf4, 0xbb, 0x44, 0xe1, 0x18, 0xbb, 0x4a, 0xcd, 0xac, 0xfa, 0xd7, 0x19, 0xa8, 0xdf, 0xec, 0x93,
0xe5, 0x13, 0x3d, 0xa0, 0xea, 0xdb, 0xc1, 0x83, 0x89, 0xe7, 0x39, 0xc8, 0xb2, 0x40, 0x84, 0xd4,
0x68, 0x4a, 0x47, 0xb0, 0xbe, 0xe6, 0x6b, 0x04, 0x89, 0x1e, 0xce, 0xf4, 0xdb, 0x6d, 0x1e, 0xd3,
0x65, 0x29, 0xd5, 0x65, 0x02, 0x61, 0x11, 0xdd, 0x09, 0x28, 0x63, 0xcf, 0x8b, 0x22, 0x3e, 0x3a,
0x26, 0xec, 0x79, 0xac, 0x50, 0x85, 0xaa, 0xd1, 0xbe, 0xeb, 0xb8, 0x7b, 0x36, 0x36, 0x3b, 0xd8,
0xa4, 0x82, 0x50, 0xd2, 0x62, 0x30, 0x26, 0x2a, 0x44, 0x02, 0xf4, 0xb6, 0x13, 0xd0, 0x58, 0x20,
0x4b, 0x44, 0x85, 0x40, 0xae, 0x3a, 0x01, 0x29, 0x36, 0xb1, 0x8d, 0x03, 0x4c, 0x8b, 0x8b, 0xac,
0x98, 0x41, 0x78, 0x71, 0xbf, 0x17, 0xd5, 0x2e, 0xb1, 0x62, 0x06, 0x21, 0xc5, 0x27, 0xa1, 0x3c,
0xd8, 0x40, 0x2f, 0x0f, 0xf6, 0x3b, 0x29, 0x40, 0xfd, 0x99, 0x02, 0xb5, 0x35, 0xda, 0xd4, 0x23,
0x20, 0x7d, 0x08, 0x72, 0xf8, 0x7e, 0xcf, 0xe3, 0xca, 0x44, 0x7f, 0x8f, 0x14, 0x28, 0x26, 0x35,
0xe5, 0x66, 0x56, 0xfd, 0x4e, 0x0e, 0x6a, 0x9b, 0xd8, 0xf0, 0xda, 0x3b, 0x8f, 0xc4, 0x66, 0x4e,
0x03, 0xb2, 0xa6, 0x6f, 0xf3, 0x71, 0x92, 0x9f, 0xe8, 0x3c, 0xcc, 0xf4, 0x6c, 0xa3, 0x8d, 0x77,
0x5c, 0xdb, 0xc4, 0x9e, 0xde, 0xf1, 0xdc, 0x3e, 0x3b, 0x80, 0xac, 0x6a, 0x0d, 0xa1, 0xe0, 0x1a,
0x81, 0xa3, 0x97, 0xa1, 0x64, 0xfa, 0xb6, 0x4e, 0x57, 0xc1, 0x45, 0x6a, 0x7d, 0xe5, 0xe3, 0x5b,
0xf3, 0x6d, 0xba, 0x08, 0x2e, 0x9a, 0xec, 0x07, 0x7a, 0x02, 0x6a, 0x6e, 0x3f, 0xe8, 0xf5, 0x03,
0x9d, 0xa9, 0x6c, 0xb3, 0x44, 0xc9, 0xab, 0x32, 0x20, 0xd5, 0x68, 0x1f, 0xbd, 0x0d, 0x35, 0x9f,
0xb2, 0x32, 0x0c, 0x80, 0xcb, 0xe3, 0x86, 0x5d, 0x55, 0x56, 0x8f, 0x47, 0xc0, 0xcf, 0x40, 0x23,
0xf0, 0x8c, 0x5d, 0x6c, 0x0b, 0x07, 0x3c, 0x40, 0xe5, 0x73, 0x9a, 0xc1, 0x07, 0xa7, 0xa3, 0x29,
0xc7, 0x41, 0x95, 0xb4, 0xe3, 0x20, 0x54, 0x87, 0x8c, 0x73, 0x8f, 0x9e, 0x34, 0x66, 0xb5, 0x8c,
0x73, 0x8f, 0x09, 0x42, 0xbd, 0x99, 0x55, 0xdf, 0x81, 0xdc, 0x75, 0x2b, 0xa0, 0x1c, 0x26, 0xea,
0xaf, 0xd0, 0x75, 0x08, 0x55, 0xf2, 0xc7, 0xa0, 0xe4, 0xb9, 0x7b, 0xcc, 0xae, 0x91, 0x98, 0xac,
0xaa, 0x15, 0x3d, 0x77, 0x8f, 0x1a, 0x2d, 0x9a, 0xac, 0xe2, 0x7a, 0x98, 0x45, 0x98, 0x19, 0x8d,
0x7f, 0xa9, 0x7f, 0xac, 0x0c, 0xa4, 0x8a, 0x58, 0x22, 0xff, 0xc1, 0x4c, 0xd1, 0x1b, 0x50, 0xf4,
0x58, 0xfd, 0x91, 0x47, 0xe5, 0x62, 0x4f, 0xd4, 0xae, 0x86, 0xb5, 0xc6, 0x16, 0x40, 0xb2, 0xc2,
0xac, 0xbe, 0x6d, 0xf7, 0xfd, 0x87, 0xa1, 0x05, 0xb2, 0x63, 0x87, 0xac, 0xfc, 0x18, 0x84, 0xce,
0xc6, 0xf4, 0x52, 0x56, 0xfd, 0xaf, 0x1c, 0xd4, 0x38, 0x3d, 0x93, 0x84, 0x1a, 0xa9, 0x34, 0x6d,
0x42, 0x85, 0xf4, 0xad, 0xfb, 0xb8, 0x13, 0xee, 0xae, 0x54, 0x56, 0x57, 0xa5, 0xa1, 0x76, 0x8c,
0x0c, 0x9a, 0x96, 0xb0, 0x49, 0x2b, 0xbd, 0xe5, 0x04, 0xde, 0xbe, 0x06, 0xed, 0x08, 0x80, 0xda,
0x30, 0xb3, 0x4d, 0x90, 0x75, 0xb1, 0xe9, 0x1c, 0x6d, 0xfa, 0xe5, 0x31, 0x9a, 0xa6, 0x5f, 0xc9,
0xf6, 0xa7, 0xb7, 0xe3, 0x50, 0xf4, 0x21, 0x9b, 0x52, 0xdd, 0xc7, 0x06, 0xd7, 0x0f, 0xee, 0x6c,
0x5f, 0x1c, 0x9b, 0x7a, 0x83, 0x29, 0x10, 0xeb, 0xa0, 0xd6, 0x16, 0x61, 0xad, 0x0f, 0x61, 0x3a,
0x41, 0x02, 0xd1, 0x88, 0xbb, 0x78, 0x9f, 0x2f, 0xbc, 0xc8, 0x4f, 0xf4, 0x82, 0x98, 0x14, 0x93,
0xe6, 0xe6, 0x6f, 0xb8, 0x4e, 0xe7, 0xb2, 0xe7, 0x19, 0xfb, 0x3c, 0x69, 0xe6, 0x52, 0xe6, 0xab,
0x4a, 0x6b, 0x0b, 0xe6, 0x64, 0xc3, 0xfc, 0x5c, 0xfb, 0x78, 0x13, 0xd0, 0xf0, 0x38, 0x25, 0x3d,
0xc4, 0x52, 0x7b, 0xb2, 0x42, 0x0b, 0xea, 0x27, 0x59, 0xa8, 0xbe, 0xdb, 0xc7, 0xde, 0xfe, 0x51,
0xfa, 0x84, 0xd0, 0xa7, 0xe5, 0x04, 0x9f, 0x36, 0x64, 0x86, 0xf3, 0x12, 0x33, 0x2c, 0x71, 0x26,
0x05, 0xa9, 0x33, 0x91, 0xd9, 0xd9, 0xe2, 0xa1, 0xec, 0x6c, 0x29, 0xd5, 0xce, 0xae, 0x41, 0x95,
0x9d, 0xc0, 0x1d, 0xd6, 0x15, 0x54, 0x68, 0x35, 0xe6, 0x09, 0x98, 0x3d, 0x68, 0x34, 0xb3, 0xea,
0x1f, 0x29, 0xd1, 0x8c, 0x4c, 0x64, 0x4f, 0x63, 0x41, 0x6a, 0xe6, 0xd0, 0x41, 0xea, 0xd8, 0xf6,
0xf4, 0x53, 0x05, 0xca, 0xef, 0xe3, 0x76, 0xe0, 0x7a, 0x44, 0x67, 0x25, 0xd5, 0x94, 0x31, 0x56,
0x0e, 0x99, 0xe4, 0xca, 0xe1, 0x22, 0x94, 0x2c, 0x53, 0x37, 0x88, 0xc0, 0xd3, 0x7e, 0x47, 0xc5,
0xa7, 0x45, 0xcb, 0xa4, 0x9a, 0x31, 0xfe, 0x39, 0xca, 0x0f, 0x14, 0xa8, 0x32, 0x9a, 0x7d, 0x56,
0xf3, 0x55, 0xa1, 0x3b, 0x45, 0xa6, 0x85, 0xfc, 0x23, 0x1a, 0xe8, 0xf5, 0xa9, 0x41, 0xb7, 0x97,
0x01, 0x08, 0x93, 0x79, 0x75, 0xa6, 0xc4, 0x4b, 0x52, 0x6a, 0x59, 0x75, 0xca, 0xf0, 0xeb, 0x53,
0x5a, 0x99, 0xd4, 0xa2, 0x4d, 0x5c, 0x29, 0x42, 0x9e, 0xd6, 0x56, 0xff, 0x5b, 0x81, 0xd9, 0xab,
0x86, 0xdd, 0x5e, 0xb3, 0xfc, 0xc0, 0x70, 0xda, 0x13, 0x44, 0xa4, 0x97, 0xa0, 0xe8, 0xf6, 0x74,
0x1b, 0x6f, 0x07, 0x9c, 0xa4, 0x33, 0x23, 0x46, 0xc4, 0xd8, 0xa0, 0x15, 0xdc, 0xde, 0x0d, 0xbc,
0x1d, 0xa0, 0xd7, 0xa0, 0xe4, 0xf6, 0x74, 0xcf, 0xea, 0xec, 0x04, 0x9c, 0xfb, 0x63, 0x54, 0x2e,
0xba, 0x3d, 0x8d, 0xd4, 0x10, 0x36, 0xa3, 0x72, 0x87, 0xdc, 0x8c, 0x52, 0x7f, 0x32, 0x34, 0xfc,
0x09, 0x74, 0xe0, 0x12, 0x94, 0x2c, 0x27, 0xd0, 0x4d, 0xcb, 0x0f, 0x59, 0x70, 0x4a, 0x2e, 0x43,
0x4e, 0x40, 0x47, 0x40, 0xe7, 0xd4, 0x09, 0x48, 0xdf, 0xe8, 0x4d, 0x80, 0x6d, 0xdb, 0x35, 0x78,
0x6d, 0xc6, 0x83, 0xd3, 0x72, 0xf5, 0x21, 0x68, 0x61, 0xfd, 0x32, 0xad, 0x44, 0x5a, 0x18, 0x4c,
0xe9, 0xdf, 0x2a, 0x30, 0xbf, 0x81, 0x3d, 0x96, 0x13, 0x16, 0xf0, 0x9d, 0xe4, 0x75, 0x67, 0xdb,
0x8d, 0x6f, 0xe6, 0x2b, 0x89, 0xcd, 0xfc, 0xcf, 0x67, 0x03, 0x3b, 0xb6, 0x9e, 0x64, 0x47, 0x4a,
0xe1, 0x7a, 0x32, 0x3c, 0x38, 0x63, 0x0b, 0xf3, 0x7a, 0xca, 0x34, 0x71, 0x7a, 0xc5, 0xfd, 0x09,
0xf5, 0x57, 0x59, 0xde, 0x8c, 0x74, 0x50, 0x0f, 0x2e, 0xb0, 0x0b, 0xc0, 0x1d, 0x47, 0xc2, 0x8d,
0x3c, 0x05, 0x09, 0xdb, 0x91, 0x62, 0x88, 0x7e, 0x53, 0x81, 0xa5, 0x74, 0xaa, 0x26, 0x89, 0xad,
0xde, 0x84, 0xbc, 0xe5, 0x6c, 0xbb, 0xe1, 0x3e, 0xe5, 0x39, 0xa9, 0x2e, 0xc8, 0xfb, 0x65, 0x15,
0xd5, 0xbf, 0xcb, 0x40, 0xe3, 0x5d, 0x96, 0x87, 0xf1, 0x85, 0x4f, 0x7f, 0x17, 0x77, 0x75, 0xdf,
0xfa, 0x18, 0x87, 0xd3, 0xdf, 0xc5, 0xdd, 0x4d, 0xeb, 0x63, 0x1c, 0x93, 0x8c, 0x7c, 0x5c, 0x32,
0x46, 0x6f, 0xcc, 0x8b, 0xfb, 0xd0, 0xc5, 0xf8, 0x3e, 0xf4, 0x02, 0x14, 0x1c, 0xd7, 0xc4, 0xeb,
0x6b, 0x7c, 0x0d, 0xce, 0xbf, 0x06, 0xa2, 0x56, 0x3e, 0x9c, 0xa8, 0x91, 0xae, 0x68, 0x13, 0x26,
0x4b, 0xe9, 0x24, 0x34, 0xb2, 0x4f, 0xf5, 0xfb, 0x0a, 0xb4, 0xae, 0xe1, 0x20, 0xc9, 0xd5, 0xa3,
0x93, 0xbf, 0x4f, 0x14, 0x38, 0x21, 0x25, 0x68, 0x12, 0xd1, 0x7b, 0x35, 0x2e, 0x7a, 0xf2, 0x2d,
0xf2, 0xa1, 0x2e, 0xb9, 0xd4, 0x3d, 0x0f, 0xd5, 0xb5, 0x7e, 0xb7, 0x1b, 0xc5, 0x76, 0x67, 0xa0,
0xea, 0xb1, 0x9f, 0x6c, 0x5d, 0xcc, 0x3c, 0x73, 0x85, 0xc3, 0xc8, 0xea, 0x57, 0x3d, 0x0f, 0x35,
0x5e, 0x85, 0x53, 0xdd, 0x82, 0x92, 0xc7, 0x7f, 0x73, 0xfc, 0xe8, 0x5b, 0x9d, 0x87, 0x59, 0x0d,
0x77, 0x88, 0xd0, 0x7b, 0x37, 0x2c, 0xe7, 0x2e, 0xef, 0x46, 0xfd, 0x96, 0x02, 0x73, 0x71, 0x38,
0x6f, 0xeb, 0x25, 0x28, 0x1a, 0xa6, 0xe9, 0x61, 0xdf, 0x1f, 0x39, 0x2d, 0x97, 0x19, 0x8e, 0x16,
0x22, 0x0b, 0x9c, 0xcb, 0x8c, 0xcd, 0x39, 0x55, 0x87, 0x99, 0x6b, 0x38, 0xb8, 0x89, 0x03, 0x6f,
0xa2, 0xf4, 0x88, 0x26, 0x59, 0x98, 0xd2, 0xca, 0x5c, 0x2c, 0xc2, 0x4f, 0xf5, 0x7b, 0x0a, 0x20,
0xb1, 0x87, 0x49, 0xa6, 0x59, 0xe4, 0x72, 0x26, 0xce, 0x65, 0x96, 0xa0, 0xd6, 0xed, 0xb9, 0x0e,
0x76, 0x02, 0x31, 0x10, 0xab, 0x45, 0x50, 0x2a, 0x7e, 0x3f, 0x53, 0x00, 0xdd, 0x70, 0x0d, 0xf3,
0x8a, 0x61, 0x4f, 0x16, 0x38, 0x9c, 0x02, 0xf0, 0xbd, 0xb6, 0xce, 0xf5, 0x38, 0xc3, 0xed, 0x92,
0xd7, 0xbe, 0xc5, 0x54, 0xf9, 0x34, 0x54, 0x4c, 0x3f, 0xe0, 0xc5, 0xe1, 0x69, 0x3d, 0x98, 0x7e,
0xc0, 0xca, 0x69, 0x9e, 0x38, 0x59, 0xb1, 0x61, 0x53, 0x17, 0x0e, 0x3b, 0x73, 0x14, 0xad, 0xc1,
0x0a, 0x36, 0x23, 0xb8, 0x44, 0xb9, 0xf2, 0xe9, 0x39, 0x9b, 0x33, 0xcd, 0xbc, 0xba, 0x0d, 0x8b,
0x37, 0x0d, 0xa7, 0x6f, 0xd8, 0x57, 0xdd, 0x6e, 0xcf, 0x88, 0xe5, 0x18, 0x27, 0x2d, 0xa6, 0x22,
0xb1, 0x98, 0x8f, 0xb3, 0xd4, 0x47, 0x16, 0xf4, 0xd3, 0xc1, 0xe5, 0x34, 0x01, 0xc2, 0xfa, 0x29,
0x36, 0x15, 0xd5, 0x87, 0xe6, 0x70, 0x3f, 0x93, 0x4c, 0x31, 0xa5, 0x2e, 0x6c, 0x4a, 0xb4, 0xe7,
0x03, 0x98, 0xfa, 0x06, 0x3c, 0x46, 0xf3, 0x51, 0x43, 0x50, 0xec, 0x58, 0x25, 0xd9, 0x80, 0x22,
0x69, 0xe0, 0x0f, 0x33, 0xd4, 0x28, 0x0e, 0xb5, 0x30, 0x09, 0xe1, 0x97, 0xe2, 0x87, 0x18, 0x4f,
0xa6, 0xa4, 0xc1, 0xc7, 0x7b, 0xe4, 0xe6, 0x7b, 0x19, 0xa6, 0xf1, 0x7d, 0xdc, 0xee, 0x07, 0x96,
0xd3, 0xd9, 0xb0, 0x0d, 0xe7, 0x96, 0xcb, 0x9d, 0x54, 0x12, 0x8c, 0x9e, 0x84, 0x1a, 0x99, 0x06,
0xb7, 0x1f, 0x70, 0x3c, 0xe6, 0xad, 0xe2, 0x40, 0xd2, 0x1e, 0x19, 0xaf, 0x8d, 0x03, 0x6c, 0x72,
0x3c, 0xe6, 0xba, 0x92, 0x60, 0xc2, 0xad, 0x6d, 0xc3, 0xb2, 0x23, 0x34, 0xb6, 0xa3, 0x1c, 0x83,
0x0d, 0xb1, 0x9b, 0x80, 0xfd, 0xc3, 0xb0, 0xfb, 0x1f, 0x94, 0x04, 0xbb, 0x79, 0x0b, 0x47, 0xc5,
0xee, 0xeb, 0x00, 0x5d, 0xec, 0x75, 0xf0, 0x3a, 0x75, 0x19, 0x6c, 0xab, 0x67, 0x59, 0xea, 0x32,
0x06, 0x0d, 0xdc, 0x0c, 0x2b, 0x68, 0x42, 0x5d, 0xf5, 0x1a, 0xcc, 0x4a, 0x50, 0x88, 0x35, 0xf4,
0xdd, 0xbe, 0xd7, 0xc6, 0xe1, 0xb6, 0x61, 0xf8, 0x49, 0xbc, 0x67, 0x60, 0x78, 0x1d, 0x1c, 0x70,
0xc1, 0xe6, 0x5f, 0xea, 0x4b, 0xf4, 0x90, 0x90, 0xee, 0x84, 0xc4, 0xa4, 0x39, 0x9e, 0x0b, 0xa1,
0x0c, 0xe5, 0x42, 0x6c, 0xd3, 0x83, 0x38, 0xb1, 0xde, 0x84, 0x79, 0x2c, 0x74, 0x77, 0x09, 0x9b,
0xfc, 0xea, 0x54, 0xf8, 0xa9, 0xfe, 0x8f, 0x02, 0xb5, 0xf5, 0x6e, 0xcf, 0x1d, 0x1c, 0x3d, 0x8d,
0xbd, 0x84, 0x1d, 0xde, 0xb1, 0xcf, 0xc8, 0x76, 0xec, 0x9f, 0x80, 0x5a, 0xfc, 0x92, 0x0d, 0xdb,
0x11, 0xac, 0xb6, 0xc5, 0xcb, 0x35, 0x27, 0xa0, 0xec, 0xb9, 0x7b, 0x3a, 0x31, 0xc0, 0x26, 0xcf,
0x98, 0x29, 0x79, 0xee, 0x1e, 0x31, 0xcb, 0x26, 0x9a, 0x83, 0xfc, 0xb6, 0x65, 0x47, 0xc9, 0x5e,
0xec, 0x03, 0xbd, 0x4a, 0x16, 0x78, 0xec, 0xfc, 0xbc, 0x30, 0xee, 0x3a, 0x2b, 0xac, 0xc1, 0xec,
0x1c, 0x6a, 0x2a, 0xea, 0x07, 0x50, 0x0f, 0x87, 0x3f, 0xe1, 0xe5, 0xb1, 0xc0, 0xf0, 0xef, 0x86,
0x59, 0x2d, 0xec, 0x43, 0x3d, 0xcf, 0x4e, 0x53, 0x69, 0xfb, 0xb1, 0xd9, 0x47, 0x90, 0x23, 0x18,
0x5c, 0xa9, 0xe8, 0x6f, 0xf5, 0x5f, 0x33, 0xb0, 0x90, 0xc4, 0x9e, 0x84, 0xa4, 0x97, 0xe2, 0x8a,
0x24, 0xbf, 0x0b, 0x24, 0xf6, 0xc6, 0x95, 0x88, 0x4f, 0x45, 0xdb, 0xed, 0x3b, 0x01, 0xb7, 0x56,
0x64, 0x2a, 0xae, 0x92, 0x6f, 0xb4, 0x08, 0x45, 0xcb, 0xd4, 0x6d, 0xb2, 0x28, 0x64, 0x2e, 0xad,
0x60, 0x99, 0x37, 0xc8, 0x82, 0xf1, 0xe5, 0x30, 0x50, 0x1b, 0x3b, 0x15, 0x86, 0xe1, 0xa3, 0x3a,
0x64, 0x2c, 0x93, 0x9b, 0xa7, 0x8c, 0x65, 0x52, 0x71, 0x11, 0xf3, 0xd1, 0x79, 0x88, 0x2d, 0xba,
0x31, 0x93, 0x38, 0x61, 0xae, 0x2b, 0x34, 0x63, 0xbd, 0x14, 0x57, 0x1f, 0x93, 0xca, 0x13, 0xcb,
0x71, 0xd3, 0x03, 0x9f, 0x06, 0xdd, 0x59, 0xad, 0xc4, 0x00, 0x77, 0x7c, 0xf5, 0xeb, 0xb0, 0x40,
0x68, 0x66, 0x63, 0xbf, 0x43, 0x66, 0xea, 0xd0, 0xb2, 0x3f, 0x07, 0x79, 0xdb, 0xea, 0x5a, 0xa1,
0xb6, 0xb3, 0x0f, 0xf5, 0x97, 0x15, 0x58, 0x1c, 0x6a, 0x79, 0x92, 0x39, 0xbc, 0x2c, 0x8a, 0x55,
0x65, 0xf5, 0xbc, 0xd4, 0x96, 0xc9, 0x85, 0x26, 0x94, 0xc1, 0x5f, 0x63, 0x61, 0x9a, 0xc6, 0x52,
0x80, 0x1f, 0x72, 0x42, 0xd9, 0x32, 0x34, 0xf6, 0xac, 0x60, 0x47, 0xa7, 0xb7, 0xd6, 0x68, 0x8c,
0xc4, 0x12, 0x27, 0x4a, 0x5a, 0x9d, 0xc0, 0x37, 0x09, 0x98, 0xc4, 0x49, 0xbe, 0xfa, 0x5d, 0x05,
0x66, 0x63, 0x64, 0x4d, 0xc2, 0xa6, 0xd7, 0x48, 0xf8, 0xc8, 0x1a, 0xe2, 0x9c, 0x5a, 0x92, 0x72,
0x8a, 0xf7, 0x46, 0xad, 0x7d, 0x54, 0x43, 0xfd, 0xa9, 0x02, 0x15, 0xa1, 0x84, 0xac, 0x4b, 0x79,
0xd9, 0x60, 0x5d, 0x1a, 0x01, 0xc6, 0x62, 0xc3, 0x13, 0x30, 0xb0, 0x81, 0xc2, 0x95, 0x0a, 0x21,
0xa7, 0xd3, 0xf4, 0xd1, 0x75, 0xa8, 0x33, 0x36, 0x45, 0xa4, 0x4b, 0xb7, 0x8b, 0xa2, 0x6c, 0x55,
0xc3, 0x33, 0x39, 0x95, 0x5a, 0xcd, 0x17, 0xbe, 0xd8, 0x99, 0xb9, 0x6b, 0x62, 0xda, 0x53, 0x7e,
0x68, 0x95, 0x58, 0x15, 0xab, 0x92, 0x48, 0xdb, 0xc6, 0x86, 0x89, 0xbd, 0x68, 0x6c, 0xd1, 0x37,
0xd1, 0x2a, 0xf6, 0x5b, 0x27, 0x2b, 0x0f, 0x6e, 0xcd, 0x81, 0x81, 0xc8, 0xa2, 0x04, 0x3d, 0x05,
0xd3, 0x66, 0x37, 0x76, 0x65, 0x32, 0x8c, 0xc5, 0xcd, 0xae, 0x70, 0x57, 0x32, 0x46, 0x50, 0x2e,
0x4e, 0xd0, 0xb7, 0x07, 0x97, 0xd0, 0x3d, 0x6c, 0x62, 0x27, 0xb0, 0x0c, 0xfb, 0xc1, 0x65, 0xb2,
0x05, 0xa5, 0xbe, 0x8f, 0x3d, 0xc1, 0xf9, 0x44, 0xdf, 0xa4, 0xac, 0x67, 0xf8, 0xfe, 0x9e, 0xeb,
0x99, 0x9c, 0xca, 0xe8, 0x7b, 0x44, 0x82, 0x2c, 0xbb, 0xb8, 0x2c, 0x4f, 0x90, 0x7d, 0x09, 0x16,
0xbb, 0xae, 0x69, 0x6d, 0x5b, 0xb2, 0xbc, 0x5a, 0x52, 0x6d, 0x3e, 0x2c, 0x8e, 0xd5, 0x0b, 0xaf,
0xfc, 0xcc, 0x8a, 0x57, 0x7e, 0x7e, 0x98, 0x81, 0xc5, 0xf7, 0x7a, 0xe6, 0x17, 0xc0, 0x87, 0x25,
0xa8, 0xb8, 0xb6, 0xb9, 0x11, 0x67, 0x85, 0x08, 0x22, 0x18, 0x0e, 0xde, 0x8b, 0x30, 0xd8, 0x31,
0x84, 0x08, 0x1a, 0x99, 0x50, 0xfc, 0x40, 0xfc, 0x2a, 0x8c, 0xe2, 0x57, 0xf9, 0xb3, 0xd7, 0x0b,
0xa5, 0x4c, 0x63, 0xae, 0x99, 0x51, 0x7f, 0x0e, 0x16, 0x59, 0x6a, 0xc2, 0x43, 0xe6, 0x52, 0x38,
0x47, 0xf3, 0xe2, 0x1c, 0x7d, 0x04, 0xf3, 0xc4, 0x9a, 0x93, 0xae, 0xdf, 0xf3, 0xb1, 0x37, 0xa1,
0x91, 0x3a, 0x09, 0xe5, 0xb0, 0xb7, 0x30, 0x15, 0x7c, 0x00, 0x50, 0xff, 0x3f, 0xcc, 0x25, 0xfa,
0x7a, 0xc0, 0x51, 0x86, 0x23, 0x59, 0x10, 0x47, 0xb2, 0x04, 0xa0, 0xb9, 0x36, 0x7e, 0xcb, 0x09,
0xac, 0x60, 0x9f, 0x44, 0x1f, 0x82, 0x6b, 0xa3, 0xbf, 0x09, 0x06, 0xe9, 0x77, 0x04, 0xc6, 0xaf,
0x28, 0x30, 0xc3, 0x34, 0x97, 0x34, 0xf5, 0xe0, 0xb3, 0xf0, 0x32, 0x14, 0x30, 0xed, 0x85, 0xef,
0x66, 0x9c, 0x96, 0x9b, 0xea, 0x88, 0x5c, 0x8d, 0xa3, 0x4b, 0xd5, 0x28, 0x80, 0xe9, 0x35, 0xcf,
0xed, 0x4d, 0x46, 0x11, 0x8d, 0x78, 0x6c, 0x2c, 0xc6, 0xb0, 0x25, 0x02, 0xb8, 0x95, 0x26, 0x18,
0x7f, 0xaf, 0xc0, 0xc2, 0xed, 0x1e, 0xf6, 0x8c, 0x00, 0x13, 0xa6, 0x4d, 0xd6, 0xfb, 0x28, 0xdd,
0x8d, 0x51, 0x96, 0x8d, 0x53, 0x86, 0x5e, 0x8b, 0xdd, 0x53, 0x94, 0xaf, 0x73, 0x12, 0x54, 0x0e,
0xee, 0x3b, 0x84, 0xe3, 0x5a, 0x14, 0xc7, 0xf5, 0x63, 0x05, 0x66, 0x36, 0x31, 0xf1, 0x63, 0x93,
0x0d, 0xe9, 0x22, 0xe4, 0x08, 0x95, 0xe3, 0x4e, 0x30, 0x45, 0x46, 0xe7, 0x60, 0xc6, 0x72, 0xda,
0x76, 0xdf, 0xc4, 0x3a, 0x19, 0xbf, 0x4e, 0xc2, 0x43, 0x1e, 0x3c, 0x4c, 0xf3, 0x02, 0x32, 0x0c,
0xe2, 0xa2, 0xa5, 0x32, 0x7e, 0x9f, 0xc9, 0x78, 0x94, 0x10, 0xc6, 0x48, 0x50, 0x0e, 0x43, 0xc2,
0x8b, 0x90, 0x27, 0x5d, 0x87, 0x41, 0x84, 0xbc, 0xd6, 0x40, 0x4d, 0x34, 0x86, 0xad, 0xfe, 0xbc,
0x02, 0x48, 0x64, 0xdb, 0x24, 0x56, 0xe2, 0x15, 0x31, 0x11, 0x24, 0x3b, 0x92, 0x74, 0x36, 0xd2,
0x28, 0x05, 0x44, 0xfd, 0x34, 0x9a, 0x3d, 0x3a, 0xdd, 0x93, 0xcc, 0x1e, 0x19, 0xd7, 0xc8, 0xd9,
0x13, 0x98, 0x40, 0x91, 0xc5, 0xd9, 0xa3, 0x12, 0x2b, 0x99, 0x3d, 0x42, 0x33, 0x9d, 0x3d, 0x6e,
0xdf, 0x9b, 0xcd, 0x0c, 0x99, 0x34, 0x46, 0x6c, 0x38, 0x69, 0xb4, 0x67, 0xe5, 0x30, 0x3d, 0xbf,
0x08, 0x79, 0xd2, 0xe3, 0xc1, 0xfc, 0x0a, 0x27, 0x8d, 0x62, 0x0b, 0x93, 0xc6, 0x09, 0x78, 0xf8,
0x93, 0x36, 0x18, 0xe9, 0x60, 0xd2, 0x54, 0xa8, 0xde, 0xde, 0xfa, 0x08, 0xb7, 0x83, 0x11, 0x96,
0xf7, 0x2c, 0x4c, 0x6f, 0x78, 0xd6, 0xae, 0x65, 0xe3, 0xce, 0x28, 0x13, 0xfe, 0x5d, 0x05, 0x6a,
0xd7, 0x3c, 0xc3, 0x09, 0xdc, 0xd0, 0x8c, 0x3f, 0x10, 0x3f, 0xaf, 0x40, 0xb9, 0x17, 0xf6, 0xc6,
0x65, 0xe0, 0x49, 0xf9, 0x89, 0x4f, 0x9c, 0x26, 0x6d, 0x50, 0x4d, 0x7d, 0x1f, 0xe6, 0x28, 0x25,
0x49, 0xb2, 0x5f, 0x87, 0x12, 0x35, 0xe6, 0x16, 0xdf, 0x40, 0xa9, 0xac, 0xaa, 0xf2, 0x25, 0x8d,
0x38, 0x0c, 0x2d, 0xaa, 0xa3, 0xfe, 0xb3, 0x02, 0x15, 0x5a, 0x36, 0x18, 0xe0, 0xe1, 0xb5, 0xfc,
0x15, 0x28, 0xb8, 0x94, 0xe5, 0x23, 0x0f, 0x86, 0xc5, 0x59, 0xd1, 0x78, 0x05, 0x12, 0x21, 0xb3,
0x5f, 0xa2, 0x45, 0x06, 0x06, 0xe2, 0x36, 0xb9, 0xd8, 0x61, 0xb4, 0x53, 0xb3, 0x3c, 0xde, 0xf8,
0xc2, 0x2a, 0x74, 0xad, 0xc6, 0x64, 0x92, 0x22, 0x3c, 0xb8, 0x0a, 0x7f, 0x35, 0xe1, 0x63, 0x97,
0xd2, 0xa9, 0x90, 0x3b, 0xd9, 0x98, 0x65, 0x25, 0x6b, 0xb5, 0x18, 0x59, 0x13, 0xae, 0xd5, 0x22,
0x11, 0x18, 0xb5, 0x56, 0x13, 0x89, 0x1b, 0x08, 0xc0, 0x3f, 0x2a, 0xb0, 0xc8, 0x7d, 0x5a, 0x24,
0x5b, 0x47, 0xc0, 0x26, 0xf4, 0x35, 0xee, 0x7b, 0xb3, 0xd4, 0xf7, 0x3e, 0x33, 0xca, 0xf7, 0x46,
0x74, 0x1e, 0xe0, 0x7c, 0xcf, 0x42, 0xf9, 0x26, 0xad, 0xf8, 0xd6, 0xfd, 0x00, 0x35, 0xa1, 0xb8,
0x8b, 0x3d, 0xdf, 0x72, 0x1d, 0xae, 0xe2, 0xe1, 0xe7, 0xb9, 0x33, 0x50, 0x0a, 0x6f, 0x2e, 0xa2,
0x22, 0x64, 0x2f, 0xdb, 0x76, 0x63, 0x0a, 0x55, 0xa1, 0xb4, 0xce, 0xaf, 0xe7, 0x35, 0x94, 0x73,
0x6f, 0xc2, 0xac, 0xc4, 0xef, 0xa3, 0x19, 0xa8, 0x5d, 0x36, 0x69, 0x74, 0x79, 0xc7, 0x25, 0xc0,
0xc6, 0x14, 0x5a, 0x00, 0xa4, 0xe1, 0xae, 0xbb, 0x4b, 0x11, 0xdf, 0xf6, 0xdc, 0x2e, 0x85, 0x2b,
0xe7, 0x9e, 0x85, 0x39, 0x19, 0xf5, 0xa8, 0x0c, 0x79, 0xca, 0x8d, 0xc6, 0x14, 0x02, 0x28, 0x68,
0x78, 0xd7, 0xbd, 0x8b, 0x1b, 0xca, 0xea, 0x9f, 0x9f, 0x83, 0x1a, 0xa3, 0x9d, 0xdf, 0xb3, 0x47,
0x3a, 0x34, 0x92, 0x4f, 0x8d, 0xa1, 0xaf, 0xc8, 0x77, 0x62, 0xe5, 0x2f, 0x92, 0xb5, 0x46, 0x09,
0x93, 0x3a, 0x85, 0x3e, 0x80, 0x7a, 0xfc, 0x71, 0x2e, 0x24, 0x3f, 0x96, 0x96, 0xbe, 0xe0, 0x75,
0x50, 0xe3, 0x3a, 0xd4, 0x62, 0xef, 0x6a, 0x21, 0xf9, 0x04, 0xcb, 0xde, 0xde, 0x6a, 0xc9, 0xad,
0x89, 0xf8, 0xf6, 0x15, 0xa3, 0x3e, 0xfe, 0xd0, 0x4d, 0x0a, 0xf5, 0xd2, 0xd7, 0x70, 0x0e, 0xa2,
0xde, 0x80, 0x99, 0xa1, 0x77, 0x68, 0xd0, 0xb3, 0x29, 0x1b, 0x22, 0xf2, 0xf7, 0x6a, 0x0e, 0xea,
0x62, 0x0f, 0xd0, 0xf0, 0x5b, 0x51, 0x68, 0x45, 0x3e, 0x03, 0x69, 0xaf, 0x67, 0xb5, 0x2e, 0x8c,
0x8d, 0x1f, 0x31, 0xee, 0x3b, 0x0a, 0x2c, 0xa6, 0x3c, 0x59, 0x82, 0x2e, 0xa6, 0xed, 0x8e, 0x8d,
0x78, 0x80, 0xa5, 0xf5, 0xc2, 0xe1, 0x2a, 0x45, 0x84, 0x38, 0x30, 0x9d, 0x78, 0xb1, 0x03, 0x9d,
0x4f, 0xbd, 0x66, 0x3c, 0xfc, 0x9c, 0x49, 0xeb, 0x2b, 0xe3, 0x21, 0x47, 0xfd, 0x7d, 0x08, 0xd3,
0x89, 0xe7, 0x2a, 0x52, 0xfa, 0x93, 0x3f, 0x6a, 0x71, 0xd0, 0x84, 0x7e, 0x03, 0x6a, 0xb1, 0x77,
0x25, 0x52, 0x24, 0x5e, 0xf6, 0xf6, 0xc4, 0x41, 0x4d, 0x7f, 0x08, 0x55, 0xf1, 0xf9, 0x07, 0xb4,
0x9c, 0xa6, 0x4b, 0x43, 0x0d, 0x1f, 0x46, 0x95, 0x06, 0xd7, 0xb6, 0x47, 0xa8, 0xd2, 0xd0, 0x4d,
0xf7, 0xf1, 0x55, 0x49, 0x68, 0x7f, 0xa4, 0x2a, 0x1d, 0xba, 0x8b, 0x6f, 0x29, 0x74, 0xdb, 0x5f,
0xf2, 0x2c, 0x00, 0x5a, 0x4d, 0x93, 0xcd, 0xf4, 0x07, 0x10, 0x5a, 0x17, 0x0f, 0x55, 0x27, 0xe2,
0xe2, 0x5d, 0xa8, 0xc7, 0x2f, 0xbf, 0xa7, 0x70, 0x51, 0xfa, 0x5e, 0x40, 0xeb, 0xfc, 0x58, 0xb8,
0x51, 0x67, 0xef, 0x41, 0x45, 0x78, 0x3d, 0x14, 0x3d, 0x3d, 0x42, 0x8e, 0xc5, 0xa7, 0x34, 0x0f,
0xe2, 0xe4, 0xbb, 0x50, 0x8e, 0x1e, 0xfd, 0x44, 0x67, 0x53, 0xe5, 0xf7, 0x30, 0x4d, 0x6e, 0x02,
0x0c, 0x5e, 0xf4, 0x44, 0x4f, 0x49, 0xdb, 0x1c, 0x7a, 0xf2, 0xf3, 0xa0, 0x46, 0xa3, 0xe1, 0xb3,
0xdb, 0x41, 0xa3, 0x86, 0x2f, 0x5e, 0x70, 0x3b, 0xa8, 0xd9, 0x1d, 0xa8, 0xc5, 0x2e, 0xaa, 0xa6,
0xa9, 0xb0, 0xe4, 0x22, 0x71, 0xeb, 0xdc, 0x38, 0xa8, 0xd1, 0xfc, 0xed, 0x40, 0x2d, 0x76, 0x49,
0x30, 0xa5, 0x27, 0xd9, 0xe5, 0xc8, 0x94, 0x9e, 0xa4, 0x77, 0x0e, 0xd5, 0x29, 0xf4, 0x4d, 0xe1,
0x3e, 0x62, 0xec, 0xf2, 0x27, 0x7a, 0x7e, 0x64, 0x3b, 0xb2, 0x4b, 0xb0, 0xad, 0xd5, 0xc3, 0x54,
0x89, 0x48, 0xe0, 0x52, 0xc5, 0x58, 0x9a, 0x2e, 0x55, 0x87, 0x99, 0xa9, 0x4d, 0x28, 0xb0, 0xdb,
0x7e, 0x48, 0x4d, 0xb9, 0xf2, 0x2b, 0x5c, 0x05, 0x6c, 0x3d, 0x21, 0xc5, 0x89, 0xdf, 0x7f, 0x63,
0x8d, 0xb2, 0x9d, 0xd2, 0x94, 0x46, 0x63, 0x37, 0xbc, 0xc6, 0x6d, 0x54, 0x83, 0x02, 0xbb, 0x72,
0x92, 0xd2, 0x68, 0xec, 0x3e, 0x55, 0x6b, 0x34, 0x0e, 0x5b, 0xef, 0x4e, 0xa1, 0x0d, 0xc8, 0xd3,
0x63, 0x6d, 0x74, 0x66, 0xd4, 0x35, 0x86, 0x51, 0x2d, 0xc6, 0x6e, 0x3a, 0xa8, 0x53, 0xe8, 0x36,
0xe4, 0x69, 0x0a, 0x58, 0x4a, 0x8b, 0x62, 0x7e, 0x7f, 0x6b, 0x24, 0x4a, 0x48, 0xa2, 0x09, 0x55,
0x31, 0x0b, 0x37, 0xc5, 0x65, 0x49, 0xf2, 0x94, 0x5b, 0xe3, 0x60, 0x86, 0xbd, 0x30, 0x35, 0x1a,
0x1c, 0xf1, 0xa7, 0xab, 0xd1, 0x50, 0xfa, 0x40, 0xba, 0x1a, 0x0d, 0x67, 0x0c, 0xa8, 0x53, 0xe8,
0x17, 0x14, 0x68, 0xa6, 0xa5, 0x86, 0xa2, 0xd4, 0x08, 0x68, 0x54, 0x7e, 0x6b, 0xeb, 0xc5, 0x43,
0xd6, 0x8a, 0x68, 0xf9, 0x98, 0x9e, 0xfb, 0x0d, 0x25, 0x83, 0x5e, 0x48, 0x6b, 0x2f, 0x25, 0xc1,
0xb1, 0xf5, 0xdc, 0xf8, 0x15, 0xa2, 0xbe, 0xb7, 0xa0, 0x22, 0x9c, 0x39, 0xa6, 0x58, 0xde, 0xe1,
0xc3, 0xd2, 0x94, 0x59, 0x95, 0x1c, 0x5f, 0x32, 0xf1, 0xa6, 0x19, 0x84, 0x29, 0xc2, 0x28, 0x26,
0x24, 0xa6, 0x88, 0x77, 0x2c, 0x01, 0x51, 0x9d, 0x42, 0x18, 0xaa, 0x62, 0x3a, 0x61, 0x8a, 0x34,
0x4a, 0x32, 0x11, 0x5b, 0xcf, 0x8c, 0x81, 0x19, 0x75, 0xa3, 0x03, 0x0c, 0xd2, 0xf9, 0x52, 0x7c,
0xdd, 0x50, 0x46, 0x61, 0xeb, 0xe9, 0x03, 0xf1, 0x44, 0xb7, 0x2f, 0x24, 0xe8, 0xa5, 0x70, 0x7f,
0x38, 0x85, 0x6f, 0x8c, 0xb5, 0xc8, 0x70, 0xca, 0x57, 0xca, 0x5a, 0x24, 0x35, 0xbb, 0xac, 0x75,
0x61, 0x6c, 0xfc, 0x68, 0x3c, 0xf7, 0xa0, 0x91, 0x4c, 0x91, 0x4b, 0x59, 0xe3, 0xa6, 0x64, 0xec,
0xb5, 0x9e, 0x1d, 0x13, 0x5b, 0xf4, 0x87, 0x27, 0x86, 0x69, 0xfa, 0xba, 0x15, 0xec, 0xd0, 0xcc,
0xab, 0x71, 0x46, 0x2d, 0x26, 0x79, 0x8d, 0x33, 0xea, 0x58, 0x4a, 0x17, 0x77, 0x5e, 0x34, 0xdb,
0x20, 0xcd, 0x79, 0x89, 0xc9, 0x44, 0x29, 0x7e, 0x26, 0x9e, 0x71, 0xc3, 0xc2, 0xcf, 0x78, 0x16,
0x03, 0x3a, 0x37, 0x56, 0xaa, 0xc3, 0xa8, 0xf0, 0x53, 0x9e, 0x16, 0xc1, 0x96, 0x6e, 0x89, 0x24,
0x8d, 0x94, 0xa5, 0x94, 0x3c, 0x49, 0x24, 0x65, 0xe9, 0x96, 0x92, 0xf7, 0x41, 0x15, 0xab, 0x91,
0x3c, 0xf1, 0x1e, 0xbd, 0x17, 0x92, 0x3c, 0xea, 0x3c, 0x78, 0xbb, 0xa2, 0x91, 0x3c, 0x4a, 0x4e,
0xe9, 0x20, 0xe5, 0xc4, 0x79, 0x8c, 0x0e, 0x92, 0xa7, 0xb0, 0x29, 0x1d, 0xa4, 0x1c, 0xd6, 0x8e,
0x11, 0xbb, 0xc6, 0x4e, 0x3f, 0x53, 0x5c, 0xa1, 0xec, 0x84, 0x34, 0xc5, 0x15, 0x4a, 0x0f, 0x6e,
0x59, 0x44, 0x3f, 0x38, 0xc4, 0x4c, 0xb1, 0x72, 0x43, 0xa7, 0x9c, 0x07, 0x91, 0x7f, 0x1b, 0x4a,
0xe1, 0x29, 0x24, 0x7a, 0x32, 0x35, 0x44, 0x3c, 0x44, 0x83, 0x1f, 0xc2, 0x74, 0x62, 0x07, 0x2f,
0x45, 0x44, 0xe5, 0xa7, 0x90, 0x07, 0xcf, 0x27, 0x0c, 0xce, 0xab, 0x52, 0x98, 0x30, 0x74, 0x0e,
0x98, 0x62, 0xea, 0x87, 0x0f, 0xbe, 0xc4, 0x0e, 0x08, 0x61, 0x23, 0x3b, 0x10, 0x8e, 0xaa, 0x46,
0x76, 0x20, 0x1e, 0xd2, 0x30, 0x89, 0x4c, 0x6e, 0x50, 0xa6, 0x48, 0x64, 0xca, 0x6e, 0xf1, 0x41,
0x2c, 0xda, 0x82, 0x8a, 0xb0, 0xe5, 0x8d, 0x46, 0x91, 0x26, 0xee, 0xd5, 0xa7, 0x84, 0x0a, 0x92,
0xdd, 0x73, 0x75, 0x6a, 0xb5, 0x0f, 0xd5, 0x0d, 0xcf, 0xbd, 0x1f, 0x3e, 0x4e, 0xfa, 0x05, 0x39,
0xfa, 0x4b, 0x6d, 0xa8, 0x33, 0x04, 0x1d, 0xdf, 0x0f, 0x74, 0x77, 0xeb, 0x23, 0x74, 0x72, 0x85,
0xfd, 0xcb, 0x8f, 0x95, 0xf0, 0x5f, 0x7e, 0xac, 0xbc, 0x6d, 0xd9, 0xf8, 0x36, 0xcf, 0xae, 0xfc,
0xb7, 0xe2, 0x88, 0x1b, 0x81, 0xd1, 0x96, 0xb5, 0xc6, 0xff, 0xeb, 0xc8, 0x5b, 0xf7, 0x83, 0xdb,
0x5b, 0x1f, 0x5d, 0x79, 0xff, 0xb3, 0xd7, 0x8b, 0x90, 0x5f, 0x5d, 0x79, 0x7e, 0xe5, 0x39, 0xa8,
0x5b, 0x11, 0x7a, 0xc7, 0xeb, 0xb5, 0xaf, 0x54, 0x58, 0xa5, 0x0d, 0xd2, 0xce, 0x86, 0xf2, 0xff,
0x96, 0x3b, 0x56, 0xb0, 0xd3, 0xdf, 0x22, 0x53, 0x70, 0x81, 0xa1, 0x3d, 0x6b, 0xb9, 0xfc, 0xd7,
0x05, 0xa3, 0x67, 0xf1, 0x9f, 0xbd, 0xad, 0xdf, 0x55, 0x94, 0xad, 0x02, 0xed, 0xfd, 0xe2, 0xff,
0x05, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x9c, 0xc8, 0xa5, 0xe4, 0x64, 0x00, 0x00,
// 5401 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3d, 0x4b, 0x6c, 0x1c, 0x47,
0x76, 0xec, 0xf9, 0xcf, 0x9b, 0x0f, 0x87, 0xc5, 0xdf, 0x78, 0x24, 0x59, 0x54, 0xdb, 0xb2, 0x69,
0x69, 0x4d, 0xd9, 0x94, 0x2d, 0xaf, 0x65, 0xaf, 0x6d, 0x49, 0xb4, 0x24, 0xc2, 0xfa, 0xd0, 0x4d,
0xd9, 0xc6, 0xc6, 0x31, 0x1a, 0xcd, 0xe9, 0xe2, 0xb0, 0xad, 0x9e, 0xee, 0x71, 0x77, 0x0f, 0x29,
0x3a, 0x97, 0x05, 0x36, 0xbb, 0xd8, 0x20, 0x9b, 0x35, 0xf2, 0x5d, 0xe4, 0x90, 0x0f, 0x82, 0xcd,
0x21, 0xc8, 0x26, 0x88, 0x93, 0x43, 0x80, 0xcd, 0x21, 0x77, 0x23, 0x41, 0xb2, 0x01, 0x82, 0x64,
0x91, 0x1c, 0x17, 0x09, 0x12, 0x20, 0x40, 0x0e, 0xb9, 0x25, 0x41, 0x82, 0xfa, 0x74, 0x4f, 0x75,
0x4f, 0xf5, 0x70, 0xa8, 0xb1, 0x2c, 0xca, 0x3c, 0x4d, 0xbf, 0xfa, 0xbd, 0x7a, 0xf5, 0x7e, 0x55,
0xef, 0x55, 0x11, 0xaa, 0x5d, 0xcb, 0xde, 0xed, 0xfb, 0x2b, 0x3d, 0xcf, 0x0d, 0x5c, 0x34, 0x2b,
0x7e, 0xad, 0xb0, 0x8f, 0x56, 0xb5, 0xed, 0x76, 0xbb, 0xae, 0xc3, 0x80, 0xad, 0xaa, 0xdf, 0xde,
0xc1, 0x5d, 0x83, 0x7f, 0x2d, 0x75, 0x5c, 0xb7, 0x63, 0xe3, 0x73, 0xf4, 0x6b, 0xab, 0xbf, 0x7d,
0xce, 0xc4, 0x7e, 0xdb, 0xb3, 0x7a, 0x81, 0xeb, 0xb1, 0x1a, 0xea, 0x6f, 0x2b, 0x80, 0xae, 0x78,
0xd8, 0x08, 0xf0, 0x25, 0xdb, 0x32, 0x7c, 0x0d, 0x7f, 0xd4, 0xc7, 0x7e, 0x80, 0x9e, 0x83, 0xdc,
0x96, 0xe1, 0xe3, 0xa6, 0xb2, 0xa4, 0x2c, 0x57, 0x56, 0x8f, 0xaf, 0xc4, 0x06, 0xe6, 0x03, 0xde,
0xf4, 0x3b, 0x97, 0x0d, 0x1f, 0x6b, 0xb4, 0x26, 0x5a, 0x84, 0xa2, 0xb9, 0xa5, 0x3b, 0x46, 0x17,
0x37, 0x33, 0x4b, 0xca, 0x72, 0x59, 0x2b, 0x98, 0x5b, 0xb7, 0x8c, 0x2e, 0x46, 0x4f, 0xc3, 0x74,
0xdb, 0xb5, 0x6d, 0xdc, 0x0e, 0x2c, 0xd7, 0x61, 0x15, 0xb2, 0xb4, 0x42, 0x7d, 0x00, 0xa6, 0x15,
0xe7, 0x20, 0x6f, 0x10, 0x1c, 0x9a, 0x39, 0x5a, 0xcc, 0x3e, 0x54, 0x1f, 0x1a, 0x6b, 0x9e, 0xdb,
0x7b, 0x50, 0xd8, 0x45, 0x83, 0x66, 0xc5, 0x41, 0x7f, 0x4b, 0x81, 0x99, 0x4b, 0x76, 0x80, 0xbd,
0x23, 0x4a, 0x94, 0x1f, 0x66, 0x60, 0x91, 0xad, 0xda, 0x95, 0xa8, 0xfa, 0xc3, 0xc4, 0x72, 0x01,
0x0a, 0x8c, 0xef, 0x28, 0x9a, 0x55, 0x8d, 0x7f, 0xa1, 0x13, 0x00, 0xfe, 0x8e, 0xe1, 0x99, 0xbe,
0xee, 0xf4, 0xbb, 0xcd, 0xfc, 0x92, 0xb2, 0x9c, 0xd7, 0xca, 0x0c, 0x72, 0xab, 0xdf, 0x45, 0x1a,
0xcc, 0xb4, 0x5d, 0xc7, 0xb7, 0xfc, 0x00, 0x3b, 0xed, 0x7d, 0xdd, 0xc6, 0xbb, 0xd8, 0x6e, 0x16,
0x96, 0x94, 0xe5, 0xfa, 0xea, 0x69, 0x29, 0xde, 0x57, 0x06, 0xb5, 0x6f, 0x90, 0xca, 0x5a, 0xa3,
0x9d, 0x80, 0x5c, 0x44, 0x9f, 0xbd, 0x36, 0x5d, 0x52, 0x1a, 0x4a, 0xf3, 0xff, 0xc2, 0x3f, 0x45,
0xfd, 0x1d, 0x05, 0xe6, 0x09, 0x13, 0x1d, 0x09, 0x62, 0x85, 0x18, 0x66, 0x44, 0x0c, 0xff, 0x40,
0x81, 0xb9, 0xeb, 0x86, 0x7f, 0x34, 0x56, 0xf3, 0x04, 0x40, 0x60, 0x75, 0xb1, 0xee, 0x07, 0x46,
0xb7, 0x47, 0x57, 0x34, 0xa7, 0x95, 0x09, 0x64, 0x93, 0x00, 0xd4, 0xaf, 0x43, 0xf5, 0xb2, 0xeb,
0xda, 0x1a, 0xf6, 0x7b, 0xae, 0xe3, 0x63, 0x74, 0x1e, 0x0a, 0x7e, 0x60, 0x04, 0x7d, 0x9f, 0x23,
0x79, 0x4c, 0x8a, 0xe4, 0x26, 0xad, 0xa2, 0xf1, 0xaa, 0x84, 0xaf, 0x77, 0x0d, 0xbb, 0xcf, 0x70,
0x2c, 0x69, 0xec, 0x43, 0x7d, 0x1f, 0xea, 0x9b, 0x81, 0x67, 0x39, 0x9d, 0xcf, 0xb1, 0xf3, 0x72,
0xd8, 0xf9, 0xbf, 0x28, 0xf0, 0xd8, 0x1a, 0xd5, 0x7f, 0x5b, 0x47, 0x44, 0x6c, 0x54, 0xa8, 0x0e,
0x20, 0xeb, 0x6b, 0x94, 0xd4, 0x59, 0x2d, 0x06, 0x4b, 0x2c, 0x46, 0x3e, 0xb1, 0x18, 0x21, 0x33,
0x65, 0x45, 0x66, 0xfa, 0x46, 0x1e, 0x5a, 0xb2, 0x89, 0x4e, 0x42, 0xd2, 0xaf, 0x45, 0x12, 0x9e,
0xa1, 0x8d, 0x12, 0xf2, 0xc9, 0xad, 0xce, 0x60, 0xb4, 0x4d, 0x0a, 0x88, 0x14, 0x41, 0x72, 0xa6,
0x59, 0xc9, 0x4c, 0x57, 0x61, 0x7e, 0xd7, 0xf2, 0x82, 0xbe, 0x61, 0xeb, 0xed, 0x1d, 0xc3, 0x71,
0xb0, 0x4d, 0x69, 0x47, 0x54, 0x5f, 0x76, 0xb9, 0xac, 0xcd, 0xf2, 0xc2, 0x2b, 0xac, 0x8c, 0x10,
0xd0, 0x47, 0x2f, 0xc0, 0x42, 0x6f, 0x67, 0xdf, 0xb7, 0xda, 0x43, 0x8d, 0xf2, 0xb4, 0xd1, 0x5c,
0x58, 0x1a, 0x6b, 0x75, 0x16, 0x66, 0xda, 0x54, 0x7b, 0x9a, 0x3a, 0xa1, 0x24, 0x23, 0x6d, 0x81,
0x92, 0xb6, 0xc1, 0x0b, 0xee, 0x84, 0x70, 0x82, 0x56, 0x58, 0xb9, 0x1f, 0xb4, 0x85, 0x06, 0x45,
0xda, 0x60, 0x96, 0x17, 0xbe, 0x13, 0xb4, 0x07, 0x6d, 0xe2, 0x7a, 0xaf, 0x94, 0xd4, 0x7b, 0x4d,
0x28, 0x52, 0x3d, 0x8e, 0xfd, 0x66, 0x99, 0xa2, 0x19, 0x7e, 0xa2, 0x75, 0x98, 0xf6, 0x03, 0xc3,
0x0b, 0xf4, 0x9e, 0xeb, 0x5b, 0x84, 0x2e, 0x7e, 0x13, 0x96, 0xb2, 0xcb, 0x95, 0xd5, 0x25, 0xe9,
0x22, 0xbd, 0x85, 0xf7, 0xd7, 0x8c, 0xc0, 0xd8, 0x30, 0x2c, 0x4f, 0xab, 0xd3, 0x86, 0x1b, 0x61,
0x3b, 0xb9, 0x72, 0xad, 0x4c, 0xa4, 0x5c, 0x65, 0x9c, 0x5d, 0x95, 0x71, 0xb6, 0xfa, 0x17, 0x0a,
0xcc, 0xdf, 0x70, 0x0d, 0xf3, 0x68, 0xc8, 0xd9, 0x69, 0xa8, 0x7b, 0xb8, 0x67, 0x5b, 0x6d, 0x83,
0xac, 0xc7, 0x16, 0xf6, 0xa8, 0xa4, 0xe5, 0xb5, 0x1a, 0x87, 0xde, 0xa2, 0xc0, 0x8b, 0xc5, 0xcf,
0x5e, 0xcb, 0x35, 0xf2, 0xcd, 0xac, 0xfa, 0x7d, 0x05, 0x9a, 0x1a, 0xb6, 0xb1, 0xe1, 0x1f, 0x0d,
0x45, 0xc1, 0x30, 0x2b, 0x34, 0xb3, 0xea, 0x7f, 0x28, 0x30, 0x77, 0x0d, 0x07, 0x44, 0x38, 0x2d,
0x3f, 0xb0, 0xda, 0x0f, 0xd5, 0x37, 0x79, 0x1a, 0xa6, 0x7b, 0x86, 0x17, 0x58, 0x51, 0xbd, 0x50,
0x54, 0xeb, 0x11, 0x98, 0xc9, 0xdb, 0x39, 0x98, 0xed, 0xf4, 0x0d, 0xcf, 0x70, 0x02, 0x8c, 0x05,
0x01, 0x62, 0xca, 0x0c, 0x45, 0x45, 0x91, 0xfc, 0xb0, 0xf9, 0x42, 0x33, 0xab, 0x7e, 0x4b, 0x81,
0xf9, 0xc4, 0x7c, 0x27, 0xd1, 0x62, 0x2f, 0x41, 0x9e, 0xfc, 0xf2, 0x9b, 0x19, 0x2a, 0x54, 0xa7,
0xd2, 0x84, 0xea, 0x5d, 0x62, 0x30, 0xa8, 0x54, 0xb1, 0xfa, 0xc4, 0x21, 0x7c, 0xfc, 0x1a, 0x0e,
0x04, 0xfd, 0x76, 0x14, 0x56, 0x60, 0x40, 0xa7, 0x4f, 0x14, 0x38, 0x99, 0x8a, 0xdf, 0x43, 0xa1,
0xd8, 0x7f, 0x29, 0xb0, 0xb0, 0xb9, 0xe3, 0xee, 0x0d, 0x50, 0x7a, 0x10, 0x94, 0x8a, 0x5b, 0xc7,
0x6c, 0xc2, 0x3a, 0xa2, 0xe7, 0x21, 0x17, 0xec, 0xf7, 0x30, 0x15, 0xf7, 0xfa, 0xea, 0x89, 0x15,
0xc9, 0xfe, 0x69, 0x85, 0x20, 0x79, 0x67, 0xbf, 0x87, 0x35, 0x5a, 0x15, 0x3d, 0x03, 0x8d, 0x04,
0xed, 0x43, 0x5b, 0x32, 0x1d, 0x27, 0xbe, 0x1f, 0xda, 0xde, 0x9c, 0x68, 0x7b, 0xff, 0x33, 0x03,
0x8b, 0x43, 0xd3, 0x9e, 0x64, 0x01, 0x64, 0xf8, 0x64, 0xa4, 0xf8, 0x10, 0x35, 0x27, 0x54, 0xb5,
0x4c, 0xb2, 0xa9, 0xc9, 0x2e, 0x67, 0xb5, 0x9a, 0x60, 0x66, 0x4d, 0x1f, 0x3d, 0x0b, 0x68, 0xc8,
0xfa, 0x31, 0xc9, 0xcd, 0x69, 0x33, 0x49, 0xf3, 0x47, 0x4d, 0xac, 0xd4, 0xfe, 0x31, 0xb2, 0xe4,
0xb4, 0x39, 0x89, 0x01, 0xf4, 0xd1, 0xf3, 0x30, 0x67, 0x39, 0x37, 0x71, 0xd7, 0xf5, 0xf6, 0xf5,
0x1e, 0xf6, 0xda, 0xd8, 0x09, 0x8c, 0x0e, 0xf6, 0x9b, 0x05, 0x8a, 0xd1, 0x6c, 0x58, 0xb6, 0x31,
0x28, 0x42, 0x17, 0x60, 0xf1, 0xa3, 0x3e, 0xf6, 0xf6, 0x75, 0x1f, 0x7b, 0xbb, 0x56, 0x1b, 0xeb,
0xc6, 0xae, 0x61, 0xd9, 0xc6, 0x96, 0x8d, 0x9b, 0xc5, 0xa5, 0xec, 0x72, 0x49, 0x9b, 0xa7, 0xc5,
0x9b, 0xac, 0xf4, 0x52, 0x58, 0xa8, 0xfe, 0x99, 0x02, 0x0b, 0x6c, 0x33, 0xb4, 0x11, 0xaa, 0x9d,
0x87, 0x6c, 0x6c, 0xe2, 0x5a, 0x91, 0x6f, 0xdd, 0x6a, 0x31, 0xa5, 0xa8, 0x7e, 0xaa, 0xc0, 0x1c,
0xd9, 0x93, 0x3c, 0x4a, 0x38, 0xff, 0x89, 0x02, 0xb3, 0xd7, 0x0d, 0xff, 0x51, 0x42, 0xf9, 0x9f,
0xb8, 0x23, 0x12, 0xe1, 0xfc, 0x68, 0x58, 0xcc, 0x61, 0x8f, 0x25, 0x2f, 0xf1, 0x58, 0xd4, 0x3f,
0x1f, 0x38, 0x2a, 0x8f, 0xd6, 0x04, 0xd5, 0x1f, 0x29, 0x70, 0xe2, 0x1a, 0x0e, 0x22, 0xac, 0x8f,
0x86, 0x47, 0x33, 0x26, 0x53, 0x7d, 0x8f, 0x79, 0x03, 0x52, 0xe4, 0x1f, 0x8a, 0xb1, 0xfd, 0xc5,
0x0c, 0xcc, 0x13, 0xab, 0x73, 0x34, 0x98, 0x60, 0x9c, 0x6d, 0xad, 0x84, 0x51, 0xf2, 0x52, 0x49,
0x08, 0x4d, 0x78, 0x61, 0x6c, 0x13, 0xae, 0xfe, 0x69, 0x86, 0xb9, 0x1e, 0x22, 0x35, 0x26, 0x59,
0x16, 0x09, 0xae, 0x19, 0x29, 0xae, 0x2a, 0x54, 0x23, 0xc8, 0xfa, 0x5a, 0x68, 0x7e, 0x63, 0xb0,
0xa3, 0x6a, 0x7d, 0xd5, 0xef, 0x2a, 0xb0, 0x10, 0x1e, 0x1a, 0x6c, 0xe2, 0x4e, 0x17, 0x3b, 0xc1,
0xfd, 0xf3, 0x50, 0x92, 0x03, 0x32, 0x12, 0x0e, 0x38, 0x0e, 0x65, 0x9f, 0x8d, 0x13, 0x9d, 0x07,
0x0c, 0x00, 0xea, 0x5f, 0x2a, 0xb0, 0x38, 0x84, 0xce, 0x24, 0x8b, 0xd8, 0x84, 0xa2, 0xe5, 0x98,
0xf8, 0x5e, 0x84, 0x4d, 0xf8, 0x49, 0x4a, 0xb6, 0xfa, 0x96, 0x6d, 0x46, 0x68, 0x84, 0x9f, 0xe8,
0x14, 0x54, 0xb1, 0x43, 0x7c, 0x0c, 0x9d, 0xd6, 0xa5, 0x8c, 0x5c, 0xd2, 0x2a, 0x0c, 0xb6, 0x4e,
0x40, 0xa4, 0xf1, 0xb6, 0x85, 0x69, 0xe3, 0x3c, 0x6b, 0xcc, 0x3f, 0xd5, 0x5f, 0x52, 0x60, 0x96,
0x70, 0x21, 0xc7, 0xde, 0x7f, 0xb0, 0xd4, 0x5c, 0x82, 0x8a, 0xc0, 0x66, 0x7c, 0x22, 0x22, 0x48,
0xbd, 0x0b, 0x73, 0x71, 0x74, 0x26, 0xa1, 0xe6, 0xe3, 0x00, 0xd1, 0x5a, 0x31, 0x69, 0xc8, 0x6a,
0x02, 0x44, 0xfd, 0xf5, 0x4c, 0x18, 0x56, 0xa0, 0x64, 0x7a, 0xc8, 0xa7, 0x99, 0x74, 0x49, 0x44,
0x7d, 0x5e, 0xa6, 0x10, 0x5a, 0xbc, 0x06, 0x55, 0x7c, 0x2f, 0xf0, 0x0c, 0xbd, 0x67, 0x78, 0x46,
0x97, 0x89, 0xd5, 0x58, 0xaa, 0xb7, 0x42, 0x9b, 0x6d, 0xd0, 0x56, 0x64, 0x10, 0xca, 0x22, 0x6c,
0x90, 0x02, 0x1b, 0x84, 0x42, 0x06, 0xfb, 0xb4, 0x4a, 0x33, 0xab, 0xfe, 0x98, 0x78, 0x7d, 0x9c,
0xad, 0x8f, 0x3a, 0x65, 0xe2, 0x73, 0xca, 0x4b, 0xe7, 0x54, 0x6d, 0x66, 0xd5, 0xdf, 0x57, 0xa0,
0x41, 0xe7, 0xb2, 0xc6, 0x83, 0x4b, 0x96, 0xeb, 0x24, 0x1a, 0x2b, 0x89, 0xc6, 0x23, 0xa4, 0xf1,
0x65, 0x28, 0xf0, 0x95, 0xc8, 0x8e, 0xbb, 0x12, 0xbc, 0xc1, 0x01, 0xf3, 0x51, 0x7f, 0x4f, 0x81,
0xf9, 0x04, 0xed, 0x27, 0x11, 0x81, 0x3b, 0x80, 0xd8, 0x0c, 0xcd, 0xc1, 0xb4, 0x43, 0xcb, 0x7d,
0x5a, 0x6a, 0xa6, 0x92, 0x44, 0xd2, 0x66, 0xac, 0x04, 0xc4, 0x57, 0x7f, 0xa2, 0xc0, 0xf1, 0x6b,
0x38, 0xa0, 0x55, 0x2f, 0x13, 0x35, 0xb4, 0xe1, 0xb9, 0x1d, 0x0f, 0xfb, 0xfe, 0x97, 0x80, 0x51,
0x7e, 0x83, 0xf9, 0x7c, 0xb2, 0xb9, 0x4d, 0xb2, 0x10, 0xa7, 0xa0, 0x4a, 0x07, 0xc3, 0xa6, 0xee,
0xb9, 0x7b, 0x3e, 0x67, 0xa8, 0x0a, 0x87, 0x69, 0xee, 0x1e, 0xe5, 0x8c, 0xc0, 0x0d, 0x0c, 0x9b,
0x55, 0xe0, 0xc6, 0x86, 0x42, 0x48, 0x31, 0x95, 0xca, 0x10, 0x31, 0xd2, 0x39, 0xfe, 0x12, 0x10,
0xfb, 0x07, 0xec, 0xe4, 0x4c, 0x9c, 0xd3, 0x24, 0x44, 0x7e, 0x91, 0xb9, 0xa6, 0x6c, 0x56, 0xf5,
0xd5, 0x93, 0xd2, 0x36, 0xc2, 0x60, 0xac, 0x36, 0x3a, 0x09, 0x95, 0x6d, 0xc3, 0xb2, 0x75, 0x0f,
0x1b, 0xbe, 0xeb, 0xf0, 0x19, 0x03, 0x01, 0x69, 0x14, 0xa2, 0xfe, 0xb5, 0xc2, 0xe2, 0xbb, 0x5f,
0x06, 0x65, 0x58, 0x6b, 0x66, 0xd5, 0x1f, 0x66, 0xa0, 0xb6, 0xee, 0xf8, 0xd8, 0x0b, 0x8e, 0xfe,
0x3e, 0x06, 0xbd, 0x0e, 0x15, 0x3a, 0x43, 0x5f, 0x37, 0x8d, 0xc0, 0xe0, 0xa6, 0xef, 0x71, 0x69,
0x64, 0xe7, 0x2a, 0xa9, 0xb7, 0x66, 0x04, 0x86, 0xc6, 0xc8, 0xe4, 0x93, 0xdf, 0xe8, 0x18, 0x94,
0x77, 0x0c, 0x7f, 0x47, 0xbf, 0x8b, 0xf7, 0x99, 0x73, 0x59, 0xd3, 0x4a, 0x04, 0xf0, 0x16, 0xde,
0xf7, 0xd1, 0x63, 0x50, 0x72, 0xfa, 0x5d, 0x26, 0x72, 0xc5, 0x25, 0x65, 0xb9, 0xa6, 0x15, 0x9d,
0x7e, 0x97, 0x08, 0x1c, 0x23, 0x57, 0xa9, 0x99, 0x55, 0xff, 0x2a, 0x03, 0xf5, 0x9b, 0x7d, 0xb2,
0x7d, 0xa2, 0x01, 0xaa, 0xbe, 0x1d, 0xdc, 0x1f, 0x7b, 0x9e, 0x81, 0x2c, 0x73, 0x44, 0x48, 0x8b,
0xa6, 0x74, 0x06, 0xeb, 0x6b, 0xbe, 0x46, 0x2a, 0xd1, 0xe0, 0x4c, 0xbf, 0xdd, 0xe6, 0x3e, 0x5d,
0x96, 0x62, 0x5d, 0x26, 0x10, 0xe6, 0xd1, 0x1d, 0x83, 0x32, 0xf6, 0xbc, 0xc8, 0xe3, 0xa3, 0x73,
0xc2, 0x9e, 0xc7, 0x0a, 0x55, 0xa8, 0x1a, 0xed, 0xbb, 0x8e, 0xbb, 0x67, 0x63, 0xb3, 0x83, 0x4d,
0xca, 0x08, 0x25, 0x2d, 0x06, 0x63, 0xac, 0x42, 0x38, 0x40, 0x6f, 0x3b, 0x01, 0xf5, 0x05, 0xb2,
0x84, 0x55, 0x08, 0xe4, 0x8a, 0x13, 0x90, 0x62, 0x13, 0xdb, 0x38, 0xc0, 0xb4, 0xb8, 0xc8, 0x8a,
0x19, 0x84, 0x17, 0xf7, 0x7b, 0x51, 0xeb, 0x12, 0x2b, 0x66, 0x10, 0x52, 0x7c, 0x1c, 0xca, 0x83,
0x03, 0xf4, 0xf2, 0xe0, 0xbc, 0x93, 0x02, 0xd4, 0x9f, 0x2a, 0x50, 0x5b, 0xa3, 0x5d, 0x3d, 0x02,
0xdc, 0x87, 0x20, 0x87, 0xef, 0xf5, 0x3c, 0x2e, 0x4c, 0xf4, 0xf7, 0x48, 0x86, 0x62, 0x5c, 0x53,
0x6e, 0x66, 0xd5, 0x6f, 0xe7, 0xa0, 0xb6, 0x89, 0x0d, 0xaf, 0xbd, 0xf3, 0x48, 0x1c, 0xe6, 0x34,
0x20, 0x6b, 0xfa, 0x36, 0x9f, 0x27, 0xf9, 0x89, 0xce, 0xc2, 0x4c, 0xcf, 0x36, 0xda, 0x78, 0xc7,
0xb5, 0x4d, 0xec, 0xe9, 0x1d, 0xcf, 0xed, 0xb3, 0x00, 0x64, 0x55, 0x6b, 0x08, 0x05, 0xd7, 0x08,
0x1c, 0xbd, 0x04, 0x25, 0xd3, 0xb7, 0x75, 0xba, 0x0b, 0x2e, 0x52, 0xed, 0x2b, 0x9f, 0xdf, 0x9a,
0x6f, 0xd3, 0x4d, 0x70, 0xd1, 0x64, 0x3f, 0xd0, 0x13, 0x50, 0x73, 0xfb, 0x41, 0xaf, 0x1f, 0xe8,
0x4c, 0x64, 0x9b, 0x25, 0x8a, 0x5e, 0x95, 0x01, 0xa9, 0x44, 0xfb, 0xe8, 0x2a, 0xd4, 0x7c, 0x4a,
0xca, 0xd0, 0x01, 0x2e, 0x8f, 0xeb, 0x76, 0x55, 0x59, 0x3b, 0xee, 0x01, 0x3f, 0x03, 0x8d, 0xc0,
0x33, 0x76, 0xb1, 0x2d, 0x04, 0x78, 0x80, 0xf2, 0xe7, 0x34, 0x83, 0x0f, 0xa2, 0xa3, 0x29, 0xe1,
0xa0, 0x4a, 0x5a, 0x38, 0x08, 0xd5, 0x21, 0xe3, 0x7c, 0x44, 0x23, 0x8d, 0x59, 0x2d, 0xe3, 0x7c,
0xc4, 0x18, 0xa1, 0xde, 0xcc, 0xaa, 0x6f, 0x41, 0xee, 0xba, 0x15, 0x50, 0x0a, 0x13, 0xf1, 0x57,
0xe8, 0x3e, 0x84, 0x0a, 0xf9, 0x63, 0x50, 0xf2, 0xdc, 0x3d, 0xa6, 0xd7, 0x88, 0x4f, 0x56, 0xd5,
0x8a, 0x9e, 0xbb, 0x47, 0x95, 0x16, 0x4d, 0x56, 0x71, 0x3d, 0xcc, 0x3c, 0xcc, 0x8c, 0xc6, 0xbf,
0xd4, 0x3f, 0x56, 0x06, 0x5c, 0x45, 0x34, 0x91, 0x7f, 0x7f, 0xaa, 0xe8, 0x75, 0x28, 0x7a, 0xac,
0xfd, 0xc8, 0x50, 0xb9, 0x38, 0x12, 0xd5, 0xab, 0x61, 0xab, 0xb1, 0x19, 0x90, 0xec, 0x30, 0xab,
0x57, 0xed, 0xbe, 0xff, 0x20, 0xa4, 0x40, 0x16, 0x76, 0xc8, 0xca, 0xc3, 0x20, 0x74, 0x35, 0xa6,
0x97, 0xb2, 0xea, 0x7f, 0xe7, 0xa0, 0xc6, 0xf1, 0x99, 0xc4, 0xd5, 0x48, 0xc5, 0x69, 0x13, 0x2a,
0x64, 0x6c, 0xdd, 0xc7, 0x9d, 0xf0, 0x74, 0xa5, 0xb2, 0xba, 0x2a, 0x75, 0xb5, 0x63, 0x68, 0xd0,
0xb4, 0x84, 0x4d, 0xda, 0xe8, 0x4d, 0x27, 0xf0, 0xf6, 0x35, 0x68, 0x47, 0x00, 0xd4, 0x86, 0x99,
0x6d, 0x52, 0x59, 0x17, 0xbb, 0xce, 0xd1, 0xae, 0x5f, 0x1a, 0xa3, 0x6b, 0xfa, 0x95, 0xec, 0x7f,
0x7a, 0x3b, 0x0e, 0x45, 0x1f, 0xb0, 0x25, 0xd5, 0x7d, 0x6c, 0x70, 0xf9, 0xe0, 0xc6, 0xf6, 0xc5,
0xb1, 0xb1, 0x37, 0x98, 0x00, 0xb1, 0x01, 0x6a, 0x6d, 0x11, 0xd6, 0xfa, 0x00, 0xa6, 0x13, 0x28,
0x10, 0x89, 0xb8, 0x8b, 0xf7, 0xf9, 0xc6, 0x8b, 0xfc, 0x44, 0x2f, 0x88, 0x49, 0x31, 0x69, 0x66,
0xfe, 0x86, 0xeb, 0x74, 0x2e, 0x79, 0x9e, 0xb1, 0xcf, 0x93, 0x66, 0x2e, 0x66, 0xbe, 0xaa, 0xb4,
0xb6, 0x60, 0x4e, 0x36, 0xcd, 0xcf, 0x75, 0x8c, 0x37, 0x00, 0x0d, 0xcf, 0x53, 0x32, 0x42, 0x2c,
0xb5, 0x27, 0x2b, 0xf4, 0xa0, 0x7e, 0x92, 0x85, 0xea, 0xdb, 0x7d, 0xec, 0xed, 0x3f, 0x4c, 0x9b,
0x10, 0xda, 0xb4, 0x9c, 0x60, 0xd3, 0x86, 0xd4, 0x70, 0x5e, 0xa2, 0x86, 0x25, 0xc6, 0xa4, 0x20,
0x35, 0x26, 0x32, 0x3d, 0x5b, 0x3c, 0x94, 0x9e, 0x2d, 0xa5, 0xea, 0xd9, 0x35, 0xa8, 0xb2, 0x08,
0xdc, 0x61, 0x4d, 0x41, 0x85, 0x36, 0x63, 0x96, 0x80, 0xe9, 0x83, 0x46, 0x33, 0xab, 0xfe, 0x91,
0x12, 0xad, 0xc8, 0x44, 0xfa, 0x34, 0xe6, 0xa4, 0x66, 0x0e, 0xed, 0xa4, 0x8e, 0xad, 0x4f, 0x3f,
0x55, 0xa0, 0xfc, 0x2e, 0x6e, 0x07, 0xae, 0x47, 0x64, 0x56, 0xd2, 0x4c, 0x19, 0x63, 0xe7, 0x90,
0x49, 0xee, 0x1c, 0xce, 0x43, 0xc9, 0x32, 0x75, 0x83, 0x30, 0x3c, 0x1d, 0x77, 0x94, 0x7f, 0x5a,
0xb4, 0x4c, 0x2a, 0x19, 0xe3, 0xc7, 0x51, 0xbe, 0xaf, 0x40, 0x95, 0xe1, 0xec, 0xb3, 0x96, 0xaf,
0x08, 0xc3, 0x29, 0x32, 0x29, 0xe4, 0x1f, 0xd1, 0x44, 0xaf, 0x4f, 0x0d, 0x86, 0xbd, 0x04, 0x40,
0x88, 0xcc, 0x9b, 0x33, 0x21, 0x5e, 0x92, 0x62, 0xcb, 0x9a, 0x53, 0x82, 0x5f, 0x9f, 0xd2, 0xca,
0xa4, 0x15, 0xed, 0xe2, 0x72, 0x11, 0xf2, 0xb4, 0xb5, 0xfa, 0x3f, 0x0a, 0xcc, 0x5e, 0x31, 0xec,
0xf6, 0x9a, 0xe5, 0x07, 0x86, 0xd3, 0x9e, 0xc0, 0x23, 0xbd, 0x08, 0x45, 0xb7, 0xa7, 0xdb, 0x78,
0x3b, 0xe0, 0x28, 0x9d, 0x1a, 0x31, 0x23, 0x46, 0x06, 0xad, 0xe0, 0xf6, 0x6e, 0xe0, 0xed, 0x00,
0xbd, 0x0a, 0x25, 0xb7, 0xa7, 0x7b, 0x56, 0x67, 0x27, 0xe0, 0xd4, 0x1f, 0xa3, 0x71, 0xd1, 0xed,
0x69, 0xa4, 0x85, 0x70, 0x18, 0x95, 0x3b, 0xe4, 0x61, 0x94, 0xfa, 0xe3, 0xa1, 0xe9, 0x4f, 0x20,
0x03, 0x17, 0xa1, 0x64, 0x39, 0x81, 0x6e, 0x5a, 0x7e, 0x48, 0x82, 0x13, 0x72, 0x1e, 0x72, 0x02,
0x3a, 0x03, 0xba, 0xa6, 0x4e, 0x40, 0xc6, 0x46, 0x6f, 0x00, 0x6c, 0xdb, 0xae, 0xc1, 0x5b, 0x33,
0x1a, 0x9c, 0x94, 0x8b, 0x0f, 0xa9, 0x16, 0xb6, 0x2f, 0xd3, 0x46, 0xa4, 0x87, 0xc1, 0x92, 0xfe,
0x8d, 0x02, 0xf3, 0x1b, 0xd8, 0x63, 0x39, 0x61, 0x01, 0x3f, 0x49, 0x5e, 0x77, 0xb6, 0xdd, 0xf8,
0x61, 0xbe, 0x92, 0x38, 0xcc, 0xff, 0x7c, 0x0e, 0xb0, 0x63, 0xfb, 0x49, 0x16, 0x52, 0x0a, 0xf7,
0x93, 0x61, 0xe0, 0x8c, 0x6d, 0xcc, 0xeb, 0x29, 0xcb, 0xc4, 0xf1, 0x15, 0xcf, 0x27, 0xd4, 0x5f,
0x65, 0x79, 0x33, 0xd2, 0x49, 0xdd, 0x3f, 0xc3, 0x2e, 0x00, 0x37, 0x1c, 0x09, 0x33, 0xf2, 0x14,
0x24, 0x74, 0x47, 0x8a, 0x22, 0xfa, 0x4d, 0x05, 0x96, 0xd2, 0xb1, 0x9a, 0xc4, 0xb7, 0x7a, 0x03,
0xf2, 0x96, 0xb3, 0xed, 0x86, 0xe7, 0x94, 0x67, 0xa4, 0xb2, 0x20, 0x1f, 0x97, 0x35, 0x54, 0xff,
0x36, 0x03, 0x8d, 0xb7, 0x59, 0x1e, 0xc6, 0x17, 0xbe, 0xfc, 0x5d, 0xdc, 0xd5, 0x7d, 0xeb, 0x63,
0x1c, 0x2e, 0x7f, 0x17, 0x77, 0x37, 0xad, 0x8f, 0x71, 0x8c, 0x33, 0xf2, 0x71, 0xce, 0x18, 0x7d,
0x30, 0x2f, 0x9e, 0x43, 0x17, 0xe3, 0xe7, 0xd0, 0x0b, 0x50, 0x70, 0x5c, 0x13, 0xaf, 0xaf, 0xf1,
0x3d, 0x38, 0xff, 0x1a, 0xb0, 0x5a, 0xf9, 0x70, 0xac, 0x46, 0x86, 0xa2, 0x5d, 0x98, 0x2c, 0xa5,
0x93, 0xe0, 0xc8, 0x3e, 0xd5, 0xef, 0x29, 0xd0, 0xba, 0x86, 0x83, 0x24, 0x55, 0x1f, 0x1e, 0xff,
0x7d, 0xa2, 0xc0, 0x31, 0x29, 0x42, 0x93, 0xb0, 0xde, 0x2b, 0x71, 0xd6, 0x93, 0x1f, 0x91, 0x0f,
0x0d, 0xc9, 0xb9, 0xee, 0x79, 0xa8, 0xae, 0xf5, 0xbb, 0xdd, 0xc8, 0xb7, 0x3b, 0x05, 0x55, 0x8f,
0xfd, 0x64, 0xfb, 0x62, 0x66, 0x99, 0x2b, 0x1c, 0x46, 0x76, 0xbf, 0xea, 0x59, 0xa8, 0xf1, 0x26,
0x1c, 0xeb, 0x16, 0x94, 0x3c, 0xfe, 0x9b, 0xd7, 0x8f, 0xbe, 0xd5, 0x79, 0x98, 0xd5, 0x70, 0x87,
0x30, 0xbd, 0x77, 0xc3, 0x72, 0xee, 0xf2, 0x61, 0xd4, 0x6f, 0x2a, 0x30, 0x17, 0x87, 0xf3, 0xbe,
0x2e, 0x40, 0xd1, 0x30, 0x4d, 0x0f, 0xfb, 0xfe, 0xc8, 0x65, 0xb9, 0xc4, 0xea, 0x68, 0x61, 0x65,
0x81, 0x72, 0x99, 0xb1, 0x29, 0xa7, 0xea, 0x30, 0x73, 0x0d, 0x07, 0x37, 0x71, 0xe0, 0x4d, 0x94,
0x1e, 0xd1, 0x24, 0x1b, 0x53, 0xda, 0x98, 0xb3, 0x45, 0xf8, 0xa9, 0x7e, 0x57, 0x01, 0x24, 0x8e,
0x30, 0xc9, 0x32, 0x8b, 0x54, 0xce, 0xc4, 0xa9, 0xcc, 0x12, 0xd4, 0xba, 0x3d, 0xd7, 0xc1, 0x4e,
0x20, 0x3a, 0x62, 0xb5, 0x08, 0x4a, 0xd9, 0xef, 0xa7, 0x0a, 0xa0, 0x1b, 0xae, 0x61, 0x5e, 0x36,
0xec, 0xc9, 0x1c, 0x87, 0x13, 0x00, 0xbe, 0xd7, 0xd6, 0xb9, 0x1c, 0x67, 0xb8, 0x5e, 0xf2, 0xda,
0xb7, 0x98, 0x28, 0x9f, 0x84, 0x8a, 0xe9, 0x07, 0xbc, 0x38, 0x8c, 0xd6, 0x83, 0xe9, 0x07, 0xac,
0x9c, 0xe6, 0x89, 0x93, 0x1d, 0x1b, 0x36, 0x75, 0x21, 0xd8, 0x99, 0xa3, 0xd5, 0x1a, 0xac, 0x60,
0x33, 0x82, 0x4b, 0x84, 0x2b, 0x9f, 0x9e, 0xb3, 0x39, 0xd3, 0xcc, 0xab, 0xdb, 0xb0, 0x78, 0xd3,
0x70, 0xfa, 0x86, 0x7d, 0xc5, 0xed, 0xf6, 0x8c, 0x58, 0x8e, 0x71, 0x52, 0x63, 0x2a, 0x12, 0x8d,
0xf9, 0x38, 0x4b, 0x7d, 0x64, 0x4e, 0x3f, 0x9d, 0x5c, 0x4e, 0x13, 0x20, 0x6c, 0x9c, 0x62, 0x53,
0x51, 0x7d, 0x68, 0x0e, 0x8f, 0x33, 0xc9, 0x12, 0x53, 0xec, 0xc2, 0xae, 0x44, 0x7d, 0x3e, 0x80,
0xa9, 0xaf, 0xc3, 0x63, 0x34, 0x1f, 0x35, 0x04, 0xc5, 0xc2, 0x2a, 0xc9, 0x0e, 0x14, 0x49, 0x07,
0x7f, 0x98, 0xa1, 0x4a, 0x71, 0xa8, 0x87, 0x49, 0x10, 0xbf, 0x18, 0x0f, 0x62, 0x3c, 0x99, 0x92,
0x06, 0x1f, 0x1f, 0x91, 0xab, 0xef, 0x65, 0x98, 0xc6, 0xf7, 0x70, 0xbb, 0x1f, 0x58, 0x4e, 0x67,
0xc3, 0x36, 0x9c, 0x5b, 0x2e, 0x37, 0x52, 0x49, 0x30, 0x7a, 0x12, 0x6a, 0x64, 0x19, 0xdc, 0x7e,
0xc0, 0xeb, 0x31, 0x6b, 0x15, 0x07, 0x92, 0xfe, 0xc8, 0x7c, 0x6d, 0x1c, 0x60, 0x93, 0xd7, 0x63,
0xa6, 0x2b, 0x09, 0x26, 0xd4, 0xda, 0x36, 0x2c, 0x3b, 0xaa, 0xc6, 0x4e, 0x94, 0x63, 0xb0, 0x21,
0x72, 0x13, 0xb0, 0x7f, 0x18, 0x72, 0xff, 0x83, 0x92, 0x20, 0x37, 0xef, 0xe1, 0x61, 0x91, 0xfb,
0x3a, 0x40, 0x17, 0x7b, 0x1d, 0xbc, 0x4e, 0x4d, 0x06, 0x3b, 0xea, 0x59, 0x96, 0x9a, 0x8c, 0x41,
0x07, 0x37, 0xc3, 0x06, 0x9a, 0xd0, 0x56, 0xbd, 0x06, 0xb3, 0x92, 0x2a, 0x44, 0x1b, 0xfa, 0x6e,
0xdf, 0x6b, 0xe3, 0xf0, 0xd8, 0x30, 0xfc, 0x24, 0xd6, 0x33, 0x30, 0xbc, 0x0e, 0x0e, 0x38, 0x63,
0xf3, 0x2f, 0xf5, 0x02, 0x0d, 0x12, 0xd2, 0x93, 0x90, 0x18, 0x37, 0xc7, 0x73, 0x21, 0x94, 0xa1,
0x5c, 0x88, 0x6d, 0x1a, 0x88, 0x13, 0xdb, 0x4d, 0x98, 0xc7, 0x42, 0x4f, 0x97, 0xb0, 0xc9, 0xaf,
0x4e, 0x85, 0x9f, 0xea, 0xff, 0x2a, 0x50, 0x5b, 0xef, 0xf6, 0xdc, 0x41, 0xe8, 0x69, 0xec, 0x2d,
0xec, 0xf0, 0x89, 0x7d, 0x46, 0x76, 0x62, 0xff, 0x04, 0xd4, 0xe2, 0x97, 0x6c, 0xd8, 0x89, 0x60,
0xb5, 0x2d, 0x5e, 0xae, 0x39, 0x06, 0x65, 0xcf, 0xdd, 0xd3, 0x89, 0x02, 0x36, 0x79, 0xc6, 0x4c,
0xc9, 0x73, 0xf7, 0x88, 0x5a, 0x36, 0xd1, 0x1c, 0xe4, 0xb7, 0x2d, 0x3b, 0x4a, 0xf6, 0x62, 0x1f,
0xe8, 0x15, 0xb2, 0xc1, 0x63, 0xf1, 0xf3, 0xc2, 0xb8, 0xfb, 0xac, 0xb0, 0x05, 0xd3, 0x73, 0xa8,
0xa9, 0xa8, 0xef, 0x43, 0x3d, 0x9c, 0xfe, 0x84, 0x97, 0xc7, 0x02, 0xc3, 0xbf, 0x1b, 0x66, 0xb5,
0xb0, 0x0f, 0xf5, 0x2c, 0x8b, 0xa6, 0xd2, 0xfe, 0x63, 0xab, 0x8f, 0x20, 0x47, 0x6a, 0x70, 0xa1,
0xa2, 0xbf, 0xd5, 0x7f, 0xcd, 0xc0, 0x42, 0xb2, 0xf6, 0x24, 0x28, 0x5d, 0x88, 0x0b, 0x92, 0xfc,
0x2e, 0x90, 0x38, 0x1a, 0x17, 0x22, 0xbe, 0x14, 0x6d, 0xb7, 0xef, 0x04, 0x5c, 0x5b, 0x91, 0xa5,
0xb8, 0x42, 0xbe, 0xd1, 0x22, 0x14, 0x2d, 0x53, 0xb7, 0xc9, 0xa6, 0x90, 0x99, 0xb4, 0x82, 0x65,
0xde, 0x20, 0x1b, 0xc6, 0x97, 0x42, 0x47, 0x6d, 0xec, 0x54, 0x18, 0x56, 0x1f, 0xd5, 0x21, 0x63,
0x99, 0x5c, 0x3d, 0x65, 0x2c, 0x93, 0xb2, 0x8b, 0x98, 0x8f, 0xce, 0x5d, 0x6c, 0xd1, 0x8c, 0x99,
0xc4, 0x08, 0x73, 0x59, 0xa1, 0x19, 0xeb, 0xa5, 0xb8, 0xf8, 0x98, 0x94, 0x9f, 0x58, 0x8e, 0x9b,
0x1e, 0xf8, 0xd4, 0xe9, 0xce, 0x6a, 0x25, 0x06, 0xb8, 0xe3, 0xab, 0xef, 0xc1, 0x02, 0xc1, 0x99,
0xcd, 0xfd, 0x0e, 0x59, 0xa9, 0x43, 0xf3, 0xfe, 0x1c, 0xe4, 0x6d, 0xab, 0x6b, 0x85, 0xd2, 0xce,
0x3e, 0xd4, 0x5f, 0x56, 0x60, 0x71, 0xa8, 0xe7, 0x49, 0xd6, 0xf0, 0x92, 0xc8, 0x56, 0x95, 0xd5,
0xb3, 0x52, 0x5d, 0x26, 0x67, 0x9a, 0x90, 0x07, 0x7f, 0x8d, 0xb9, 0x69, 0x1a, 0x4b, 0x01, 0x7e,
0xc0, 0x09, 0x65, 0xcb, 0xd0, 0xd8, 0xb3, 0x82, 0x1d, 0x9d, 0xde, 0x5a, 0xa3, 0x3e, 0x12, 0x4b,
0x9c, 0x28, 0x69, 0x75, 0x02, 0xdf, 0x24, 0x60, 0xe2, 0x27, 0xf9, 0xea, 0x77, 0x14, 0x98, 0x8d,
0xa1, 0x35, 0x09, 0x99, 0x5e, 0x25, 0xee, 0x23, 0xeb, 0x88, 0x53, 0x6a, 0x49, 0x4a, 0x29, 0x3e,
0x1a, 0xd5, 0xf6, 0x51, 0x0b, 0xf5, 0x27, 0x0a, 0x54, 0x84, 0x12, 0xb2, 0x2f, 0xe5, 0x65, 0x83,
0x7d, 0x69, 0x04, 0x18, 0x8b, 0x0c, 0x4f, 0xc0, 0x40, 0x07, 0x0a, 0x57, 0x2a, 0x84, 0x9c, 0x4e,
0xd3, 0x47, 0xd7, 0xa1, 0xce, 0xc8, 0x14, 0xa1, 0x2e, 0x3d, 0x2e, 0x8a, 0xb2, 0x55, 0x0d, 0xcf,
0xe4, 0x58, 0x6a, 0x35, 0x5f, 0xf8, 0x62, 0x31, 0x73, 0xd7, 0xc4, 0x74, 0xa4, 0xfc, 0xd0, 0x2e,
0xb1, 0x2a, 0x36, 0x25, 0x9e, 0xb6, 0x8d, 0x0d, 0x13, 0x7b, 0xd1, 0xdc, 0xa2, 0x6f, 0x22, 0x55,
0xec, 0xb7, 0x4e, 0x76, 0x1e, 0x5c, 0x9b, 0x03, 0x03, 0x91, 0x4d, 0x09, 0x7a, 0x0a, 0xa6, 0xcd,
0x6e, 0xec, 0xca, 0x64, 0xe8, 0x8b, 0x9b, 0x5d, 0xe1, 0xae, 0x64, 0x0c, 0xa1, 0x5c, 0x1c, 0xa1,
0x6f, 0x0d, 0x2e, 0xa1, 0x7b, 0xd8, 0xc4, 0x4e, 0x60, 0x19, 0xf6, 0xfd, 0xf3, 0x64, 0x0b, 0x4a,
0x7d, 0x1f, 0x7b, 0x82, 0xf1, 0x89, 0xbe, 0x49, 0x59, 0xcf, 0xf0, 0xfd, 0x3d, 0xd7, 0x33, 0x39,
0x96, 0xd1, 0xf7, 0x88, 0x04, 0x59, 0x76, 0x71, 0x59, 0x9e, 0x20, 0x7b, 0x01, 0x16, 0xbb, 0xae,
0x69, 0x6d, 0x5b, 0xb2, 0xbc, 0x5a, 0xd2, 0x6c, 0x3e, 0x2c, 0x8e, 0xb5, 0x0b, 0xaf, 0xfc, 0xcc,
0x8a, 0x57, 0x7e, 0x7e, 0x90, 0x81, 0xc5, 0x77, 0x7a, 0xe6, 0x17, 0x40, 0x87, 0x25, 0xa8, 0xb8,
0xb6, 0xb9, 0x11, 0x27, 0x85, 0x08, 0x22, 0x35, 0x1c, 0xbc, 0x17, 0xd5, 0x60, 0x61, 0x08, 0x11,
0x34, 0x32, 0xa1, 0xf8, 0xbe, 0xe8, 0x55, 0x18, 0x45, 0xaf, 0xf2, 0x67, 0xaf, 0x15, 0x4a, 0x99,
0xc6, 0x5c, 0x33, 0xa3, 0xfe, 0x1c, 0x2c, 0xb2, 0xd4, 0x84, 0x07, 0x4c, 0xa5, 0x70, 0x8d, 0xe6,
0xc5, 0x35, 0xfa, 0x10, 0xe6, 0x89, 0x36, 0x27, 0x43, 0xbf, 0xe3, 0x63, 0x6f, 0x42, 0x25, 0x75,
0x1c, 0xca, 0xe1, 0x68, 0x61, 0x2a, 0xf8, 0x00, 0xa0, 0xfe, 0x2c, 0xcc, 0x25, 0xc6, 0xba, 0xcf,
0x59, 0x86, 0x33, 0x59, 0x10, 0x67, 0xb2, 0x04, 0xa0, 0xb9, 0x36, 0x7e, 0xd3, 0x09, 0xac, 0x60,
0x9f, 0x78, 0x1f, 0x82, 0x69, 0xa3, 0xbf, 0x49, 0x0d, 0x32, 0xee, 0x88, 0x1a, 0xbf, 0xa2, 0xc0,
0x0c, 0x93, 0x5c, 0xd2, 0xd5, 0xfd, 0xaf, 0xc2, 0x4b, 0x50, 0xc0, 0x74, 0x14, 0x7e, 0x9a, 0x71,
0x52, 0xae, 0xaa, 0x23, 0x74, 0x35, 0x5e, 0x5d, 0x2a, 0x46, 0x01, 0x4c, 0xaf, 0x79, 0x6e, 0x6f,
0x32, 0x8c, 0xa8, 0xc7, 0x63, 0x63, 0xd1, 0x87, 0x2d, 0x11, 0xc0, 0xad, 0x34, 0xc6, 0xf8, 0x7b,
0x05, 0x16, 0x6e, 0xf7, 0xb0, 0x67, 0x04, 0x98, 0x10, 0x6d, 0xb2, 0xd1, 0x47, 0xc9, 0x6e, 0x0c,
0xb3, 0x6c, 0x1c, 0x33, 0xf4, 0x6a, 0xec, 0x9e, 0xa2, 0x7c, 0x9f, 0x93, 0xc0, 0x72, 0x70, 0xdf,
0x21, 0x9c, 0xd7, 0xa2, 0x38, 0xaf, 0x1f, 0x29, 0x30, 0xb3, 0x89, 0x89, 0x1d, 0x9b, 0x6c, 0x4a,
0xe7, 0x21, 0x47, 0xb0, 0x1c, 0x77, 0x81, 0x69, 0x65, 0x74, 0x06, 0x66, 0x2c, 0xa7, 0x6d, 0xf7,
0x4d, 0xac, 0x93, 0xf9, 0xeb, 0xc4, 0x3d, 0xe4, 0xce, 0xc3, 0x34, 0x2f, 0x20, 0xd3, 0x20, 0x26,
0x5a, 0xca, 0xe3, 0xf7, 0x18, 0x8f, 0x47, 0x09, 0x61, 0x0c, 0x05, 0xe5, 0x30, 0x28, 0xbc, 0x08,
0x79, 0x32, 0x74, 0xe8, 0x44, 0xc8, 0x5b, 0x0d, 0xc4, 0x44, 0x63, 0xb5, 0xd5, 0x9f, 0x57, 0x00,
0x89, 0x64, 0x9b, 0x44, 0x4b, 0xbc, 0x2c, 0x26, 0x82, 0x64, 0x47, 0xa2, 0xce, 0x66, 0x1a, 0xa5,
0x80, 0xa8, 0x9f, 0x46, 0xab, 0x47, 0x97, 0x7b, 0x92, 0xd5, 0x23, 0xf3, 0x1a, 0xb9, 0x7a, 0x02,
0x11, 0x68, 0x65, 0x71, 0xf5, 0x28, 0xc7, 0x4a, 0x56, 0x8f, 0xe0, 0x4c, 0x57, 0x8f, 0xeb, 0xf7,
0x66, 0x33, 0x43, 0x16, 0x8d, 0x21, 0x1b, 0x2e, 0x1a, 0x1d, 0x59, 0x39, 0xcc, 0xc8, 0x2f, 0x42,
0x9e, 0x8c, 0x78, 0x30, 0xbd, 0xc2, 0x45, 0xa3, 0xb5, 0x85, 0x45, 0xe3, 0x08, 0x3c, 0xf8, 0x45,
0x1b, 0xcc, 0x74, 0xb0, 0x68, 0x2a, 0x54, 0x6f, 0x6f, 0x7d, 0x88, 0xdb, 0xc1, 0x08, 0xcd, 0x7b,
0x1a, 0xa6, 0x37, 0x3c, 0x6b, 0xd7, 0xb2, 0x71, 0x67, 0x94, 0x0a, 0xff, 0x8e, 0x02, 0xb5, 0x6b,
0x9e, 0xe1, 0x04, 0x6e, 0xa8, 0xc6, 0xef, 0x8b, 0x9e, 0x97, 0xa1, 0xdc, 0x0b, 0x47, 0xe3, 0x3c,
0xf0, 0xa4, 0x3c, 0xe2, 0x13, 0xc7, 0x49, 0x1b, 0x34, 0x53, 0xdf, 0x85, 0x39, 0x8a, 0x49, 0x12,
0xed, 0xd7, 0xa0, 0x44, 0x95, 0xb9, 0xc5, 0x0f, 0x50, 0x2a, 0xab, 0xaa, 0x7c, 0x4b, 0x23, 0x4e,
0x43, 0x8b, 0xda, 0xa8, 0xff, 0xac, 0x40, 0x85, 0x96, 0x0d, 0x26, 0x78, 0x78, 0x29, 0x7f, 0x19,
0x0a, 0x2e, 0x25, 0xf9, 0xc8, 0xc0, 0xb0, 0xb8, 0x2a, 0x1a, 0x6f, 0x40, 0x3c, 0x64, 0xf6, 0x4b,
0xd4, 0xc8, 0xc0, 0x40, 0x5c, 0x27, 0x17, 0x3b, 0x0c, 0x77, 0xaa, 0x96, 0xc7, 0x9b, 0x5f, 0xd8,
0x84, 0xee, 0xd5, 0x18, 0x4f, 0xd2, 0x0a, 0xf7, 0x2f, 0xc2, 0x5f, 0x4d, 0xd8, 0xd8, 0xa5, 0x74,
0x2c, 0xe4, 0x46, 0x36, 0xa6, 0x59, 0xc9, 0x5e, 0x2d, 0x86, 0xd6, 0x84, 0x7b, 0xb5, 0x88, 0x05,
0x46, 0xed, 0xd5, 0x44, 0xe4, 0x06, 0x0c, 0xf0, 0x8f, 0x0a, 0x2c, 0x72, 0x9b, 0x16, 0xf1, 0xd6,
0x43, 0x20, 0x13, 0xfa, 0x1a, 0xb7, 0xbd, 0x59, 0x6a, 0x7b, 0x9f, 0x19, 0x65, 0x7b, 0x23, 0x3c,
0x0f, 0x30, 0xbe, 0x7f, 0xa7, 0xc0, 0x3c, 0xf3, 0xaf, 0xae, 0xf6, 0x9d, 0x09, 0x1f, 0x0f, 0x79,
0x02, 0x6a, 0xdb, 0xbc, 0x13, 0xd1, 0xab, 0xa9, 0x86, 0x40, 0x1e, 0xd8, 0x9b, 0xde, 0x33, 0x02,
0x7d, 0xcb, 0x35, 0xf7, 0xe9, 0xc1, 0xdb, 0x85, 0x17, 0xc2, 0xdd, 0xdc, 0x9e, 0x11, 0x5c, 0x76,
0xcd, 0xfd, 0xcb, 0x14, 0x88, 0x2e, 0x42, 0xd9, 0xf0, 0x3a, 0x34, 0x64, 0xc6, 0xb6, 0x73, 0xf5,
0x94, 0x44, 0x82, 0x35, 0x23, 0x30, 0xe8, 0x24, 0x4b, 0x86, 0xd7, 0x21, 0x3f, 0x7c, 0xd5, 0x86,
0x59, 0xe2, 0x9f, 0x7d, 0x31, 0x33, 0x52, 0x4f, 0x43, 0xf9, 0x26, 0xed, 0xe9, 0xcd, 0x7b, 0x01,
0x6a, 0x42, 0x71, 0x17, 0x7b, 0xbe, 0xe5, 0x3a, 0x5c, 0x4b, 0x86, 0x9f, 0x67, 0x4e, 0x41, 0x29,
0xbc, 0xfc, 0x89, 0x8a, 0x90, 0xbd, 0x64, 0xdb, 0x8d, 0x29, 0x54, 0x85, 0xd2, 0x3a, 0xbf, 0xe1,
0xd8, 0x50, 0xce, 0xbc, 0x01, 0xb3, 0x12, 0xd7, 0x09, 0xcd, 0x40, 0xed, 0x92, 0x49, 0x1d, 0xf4,
0x3b, 0x2e, 0x01, 0x36, 0xa6, 0xd0, 0x02, 0x20, 0x0d, 0x77, 0xdd, 0x5d, 0x5a, 0xf1, 0xaa, 0xe7,
0x76, 0x29, 0x5c, 0x39, 0xf3, 0x2c, 0xcc, 0xc9, 0x18, 0x00, 0x95, 0x21, 0x4f, 0x19, 0xaa, 0x31,
0x85, 0x00, 0x0a, 0x1a, 0xde, 0x75, 0xef, 0xe2, 0x86, 0xb2, 0xfa, 0xef, 0x67, 0xa1, 0xc6, 0x70,
0xe7, 0x4f, 0x15, 0x20, 0x1d, 0x1a, 0xc9, 0xd7, 0xda, 0xd0, 0x57, 0xe4, 0x87, 0xd9, 0xf2, 0x47,
0xdd, 0x5a, 0xa3, 0xe4, 0x51, 0x9d, 0x42, 0xef, 0x43, 0x3d, 0xfe, 0xbe, 0x19, 0x92, 0x47, 0xf6,
0xa5, 0x8f, 0xa0, 0x1d, 0xd4, 0xb9, 0x0e, 0xb5, 0xd8, 0xd3, 0x64, 0x48, 0x2e, 0x23, 0xb2, 0xe7,
0xcb, 0x5a, 0x72, 0x85, 0x2c, 0x3e, 0x1f, 0xc6, 0xb0, 0x8f, 0xbf, 0x15, 0x94, 0x82, 0xbd, 0xf4,
0x41, 0xa1, 0x83, 0xb0, 0x37, 0x60, 0x66, 0xe8, 0x29, 0x1f, 0xf4, 0x6c, 0xca, 0x99, 0x92, 0xfc,
0xc9, 0x9f, 0x83, 0x86, 0xd8, 0x03, 0x34, 0xfc, 0xdc, 0x16, 0x5a, 0x91, 0xaf, 0x40, 0xda, 0x03,
0x64, 0xad, 0x73, 0x63, 0xd7, 0x8f, 0x08, 0xf7, 0x6d, 0x05, 0x16, 0x53, 0x5e, 0x7d, 0x41, 0xe7,
0xd3, 0x0e, 0x18, 0x47, 0xbc, 0x61, 0xd3, 0x7a, 0xe1, 0x70, 0x8d, 0x22, 0x44, 0x1c, 0x98, 0x4e,
0x3c, 0x7a, 0x82, 0xce, 0xa6, 0xde, 0xd4, 0x1e, 0x7e, 0x11, 0xa6, 0xf5, 0x95, 0xf1, 0x2a, 0x47,
0xe3, 0x7d, 0x00, 0xd3, 0x89, 0x17, 0x3f, 0x52, 0xc6, 0x93, 0xbf, 0x0b, 0x72, 0xd0, 0x82, 0x7e,
0x1d, 0x6a, 0xb1, 0xa7, 0x39, 0x52, 0x38, 0x5e, 0xf6, 0x7c, 0xc7, 0x41, 0x5d, 0x7f, 0x00, 0x55,
0xf1, 0x05, 0x0d, 0xb4, 0x9c, 0x26, 0x4b, 0x43, 0x1d, 0x1f, 0x46, 0x94, 0x06, 0x37, 0xdf, 0x47,
0x88, 0xd2, 0xd0, 0x63, 0x01, 0xe3, 0x8b, 0x92, 0xd0, 0xff, 0x48, 0x51, 0x3a, 0xf4, 0x10, 0xdf,
0x54, 0x68, 0xe4, 0x44, 0xf2, 0xb2, 0x02, 0x5a, 0x4d, 0xe3, 0xcd, 0xf4, 0x37, 0x24, 0x5a, 0xe7,
0x0f, 0xd5, 0x26, 0xa2, 0xe2, 0x5d, 0xa8, 0xc7, 0xdf, 0x0f, 0x48, 0xa1, 0xa2, 0xf4, 0xc9, 0x85,
0xd6, 0xd9, 0xb1, 0xea, 0x46, 0x83, 0xbd, 0x03, 0x15, 0xe1, 0x01, 0x56, 0xf4, 0xf4, 0x08, 0x3e,
0x16, 0x5f, 0x23, 0x3d, 0x88, 0x92, 0x6f, 0x43, 0x39, 0x7a, 0x37, 0x15, 0x9d, 0x4e, 0xe5, 0xdf,
0xc3, 0x74, 0xb9, 0x09, 0x30, 0x78, 0x14, 0x15, 0x3d, 0x25, 0xed, 0x73, 0xe8, 0xd5, 0xd4, 0x83,
0x3a, 0x8d, 0xa6, 0xcf, 0x2e, 0x58, 0x8d, 0x9a, 0xbe, 0x78, 0x47, 0xf0, 0xa0, 0x6e, 0x77, 0xa0,
0x16, 0xbb, 0xeb, 0x9b, 0x26, 0xc2, 0x92, 0xbb, 0xd8, 0xad, 0x33, 0xe3, 0x54, 0x8d, 0xd6, 0x6f,
0x07, 0x6a, 0xb1, 0x7b, 0x96, 0x29, 0x23, 0xc9, 0xee, 0x97, 0xa6, 0x8c, 0x24, 0xbd, 0xb6, 0xa9,
0x4e, 0xa1, 0x6f, 0x08, 0x57, 0x3a, 0x63, 0xf7, 0x67, 0xd1, 0xf3, 0x23, 0xfb, 0x91, 0xdd, 0x23,
0x6e, 0xad, 0x1e, 0xa6, 0x49, 0x84, 0x02, 0xe7, 0x2a, 0x46, 0xd2, 0x74, 0xae, 0x3a, 0xcc, 0x4a,
0x6d, 0x42, 0x81, 0x5d, 0x98, 0x44, 0x6a, 0xca, 0xad, 0x69, 0xe1, 0x36, 0x65, 0xeb, 0x09, 0x69,
0x9d, 0xf8, 0x15, 0x42, 0xd6, 0x29, 0x3b, 0x6c, 0x4e, 0xe9, 0x34, 0x76, 0x49, 0x6e, 0xdc, 0x4e,
0x35, 0x28, 0xb0, 0x5b, 0x3b, 0x29, 0x9d, 0xc6, 0xae, 0xa4, 0xb5, 0x46, 0xd7, 0x61, 0x47, 0x06,
0x53, 0x68, 0x03, 0xf2, 0x34, 0x33, 0x00, 0x9d, 0x1a, 0x75, 0x13, 0x64, 0x54, 0x8f, 0xb1, 0xcb,
0x22, 0xea, 0x14, 0xba, 0x0d, 0x79, 0x9a, 0x45, 0x97, 0xd2, 0xa3, 0x78, 0x45, 0xa2, 0x35, 0xb2,
0x4a, 0x88, 0xa2, 0x09, 0x55, 0x31, 0x91, 0x39, 0xc5, 0x64, 0x49, 0x52, 0xbd, 0x5b, 0xe3, 0xd4,
0x0c, 0x47, 0x61, 0x62, 0x34, 0xc8, 0x92, 0x48, 0x17, 0xa3, 0xa1, 0x0c, 0x8c, 0x74, 0x31, 0x1a,
0x4e, 0xba, 0x50, 0xa7, 0xd0, 0x2f, 0x28, 0xd0, 0x4c, 0xcb, 0xae, 0x45, 0xa9, 0x1e, 0xd0, 0xa8,
0x14, 0xe1, 0xd6, 0x8b, 0x87, 0x6c, 0x15, 0xe1, 0xf2, 0x31, 0x0d, 0x9d, 0x0e, 0xe5, 0xd3, 0x9e,
0x4b, 0xeb, 0x2f, 0x25, 0x47, 0xb4, 0xf5, 0xdc, 0xf8, 0x0d, 0xa2, 0xb1, 0xb7, 0xa0, 0x22, 0x84,
0x6d, 0x53, 0x34, 0xef, 0x70, 0xbc, 0x39, 0x65, 0x55, 0x25, 0x11, 0x60, 0xc6, 0xde, 0x34, 0x09,
0x33, 0x85, 0x19, 0xc5, 0x9c, 0xce, 0x14, 0xf6, 0x8e, 0xe5, 0x70, 0xaa, 0x53, 0x08, 0x43, 0x55,
0xcc, 0xc8, 0x4c, 0xe1, 0x46, 0x49, 0x32, 0x67, 0xeb, 0x99, 0x31, 0x6a, 0x46, 0xc3, 0xe8, 0x00,
0x83, 0x8c, 0xc8, 0x14, 0x5b, 0x37, 0x94, 0x94, 0xd9, 0x7a, 0xfa, 0xc0, 0x7a, 0xa2, 0xd9, 0x17,
0x72, 0x1c, 0x53, 0xa8, 0x3f, 0x9c, 0x05, 0x39, 0xc6, 0x5e, 0x64, 0x38, 0x6b, 0x2e, 0x65, 0x2f,
0x92, 0x9a, 0xa0, 0xd7, 0x3a, 0x37, 0x76, 0xfd, 0x68, 0x3e, 0x1f, 0x41, 0x23, 0x99, 0x65, 0x98,
0xb2, 0xc7, 0x4d, 0x49, 0x7a, 0x6c, 0x3d, 0x3b, 0x66, 0x6d, 0xd1, 0x1e, 0x1e, 0x1b, 0xc6, 0xe9,
0x3d, 0x2b, 0xd8, 0xa1, 0xc9, 0x6b, 0xe3, 0xcc, 0x5a, 0xcc, 0x93, 0x1b, 0x67, 0xd6, 0xb1, 0xac,
0x38, 0x6e, 0xbc, 0x68, 0xc2, 0x46, 0x9a, 0xf1, 0x12, 0xf3, 0xb1, 0x52, 0xec, 0x4c, 0x3c, 0x69,
0x89, 0xb9, 0x9f, 0xf1, 0x44, 0x10, 0x74, 0x66, 0xac, 0x6c, 0x91, 0x51, 0xee, 0xa7, 0x3c, 0xb3,
0x84, 0x6d, 0xdd, 0x12, 0x79, 0x2e, 0x29, 0x5b, 0x29, 0x79, 0x9e, 0x4d, 0xca, 0xd6, 0x2d, 0x25,
0x75, 0x86, 0x0a, 0x56, 0x23, 0x99, 0x34, 0x30, 0xfa, 0x2c, 0x24, 0x19, 0x2d, 0x3e, 0xf8, 0xb8,
0xa2, 0x91, 0x8c, 0xc6, 0xa7, 0x0c, 0x90, 0x12, 0xb4, 0x1f, 0x63, 0x80, 0x64, 0x20, 0x3b, 0x65,
0x80, 0x94, 0x78, 0xf7, 0x18, 0xbe, 0x6b, 0x2c, 0x80, 0x9c, 0x62, 0x0a, 0x65, 0x41, 0xe6, 0x14,
0x53, 0x28, 0x8d, 0x7d, 0x33, 0x8f, 0x7e, 0x10, 0x07, 0x4e, 0xd1, 0x72, 0x43, 0x81, 0xe2, 0x83,
0xd0, 0xbf, 0x0d, 0xa5, 0x30, 0x90, 0x8b, 0x9e, 0x4c, 0x75, 0x11, 0x0f, 0xd1, 0xe1, 0x07, 0x30,
0x9d, 0x38, 0xc1, 0x4b, 0x61, 0x51, 0x79, 0x20, 0xf7, 0xe0, 0xf5, 0x84, 0x41, 0xc8, 0x2f, 0x85,
0x08, 0x43, 0xa1, 0xd4, 0x14, 0x55, 0x3f, 0x1c, 0x3b, 0x14, 0x07, 0x20, 0x88, 0x8d, 0x1c, 0x40,
0x88, 0xf6, 0x8d, 0x1c, 0x40, 0x8c, 0x73, 0x31, 0x8e, 0x4c, 0x1e, 0x50, 0xa6, 0x70, 0x64, 0xca,
0x81, 0xfb, 0x41, 0x24, 0xda, 0x82, 0x8a, 0x10, 0x35, 0x40, 0xa3, 0x50, 0x13, 0xc3, 0x1d, 0x29,
0xae, 0x82, 0x24, 0x00, 0xc1, 0x8e, 0x2e, 0xe2, 0x67, 0xe6, 0x29, 0x5a, 0x4f, 0x7a, 0xb0, 0x7e,
0xd0, 0x04, 0xde, 0x83, 0xaa, 0x78, 0x78, 0x9d, 0xe2, 0x35, 0x48, 0xce, 0xb7, 0x0f, 0xe8, 0x78,
0xb5, 0x0f, 0xd5, 0x0d, 0xcf, 0xbd, 0x17, 0xbe, 0x4a, 0xfb, 0x05, 0xb9, 0x27, 0x17, 0xdb, 0x50,
0x67, 0x15, 0x74, 0x7c, 0x2f, 0xd0, 0xdd, 0xad, 0x0f, 0xd1, 0xf1, 0x15, 0xf6, 0xbf, 0x5e, 0x56,
0xc2, 0xff, 0xf5, 0xb2, 0x72, 0xd5, 0xb2, 0xf1, 0x6d, 0x9e, 0x56, 0xfb, 0x6f, 0xc5, 0x11, 0x57,
0x41, 0xa3, 0x83, 0x76, 0x8d, 0xff, 0xbb, 0x99, 0x37, 0xef, 0x05, 0xb7, 0xb7, 0x3e, 0xbc, 0xfc,
0xee, 0x67, 0xaf, 0x15, 0x21, 0xbf, 0xba, 0xf2, 0xfc, 0xca, 0x73, 0x50, 0xb7, 0xa2, 0xea, 0x1d,
0xaf, 0xd7, 0xbe, 0x5c, 0x61, 0x8d, 0x36, 0x48, 0x3f, 0x1b, 0xca, 0xcf, 0x2c, 0x77, 0xac, 0x60,
0xa7, 0xbf, 0x45, 0xc8, 0x73, 0x8e, 0x55, 0x7b, 0xd6, 0x72, 0xf9, 0xaf, 0x73, 0x46, 0xcf, 0xe2,
0x3f, 0x7b, 0x5b, 0xbf, 0xab, 0x28, 0x5b, 0x05, 0x3a, 0xfa, 0xf9, 0xff, 0x0f, 0x00, 0x00, 0xff,
0xff, 0xe2, 0x63, 0x2f, 0x59, 0xdd, 0x66, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -7512,6 +7635,8 @@ type MilvusServiceClient interface {
SelectUser(ctx context.Context, in *SelectUserRequest, opts ...grpc.CallOption) (*SelectUserResponse, error)
OperatePrivilege(ctx context.Context, in *OperatePrivilegeRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
SelectGrant(ctx context.Context, in *SelectGrantRequest, opts ...grpc.CallOption) (*SelectGrantResponse, error)
CreateFunction(ctx context.Context, in *CreateFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
DropFunction(ctx context.Context, in *DropFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
}
type milvusServiceClient struct {
@ -8008,6 +8133,24 @@ func (c *milvusServiceClient) SelectGrant(ctx context.Context, in *SelectGrantRe
return out, nil
}
func (c *milvusServiceClient) CreateFunction(ctx context.Context, in *CreateFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/CreateFunction", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *milvusServiceClient) DropFunction(ctx context.Context, in *DropFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/DropFunction", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// MilvusServiceServer is the server API for MilvusService service.
type MilvusServiceServer interface {
CreateCollection(context.Context, *CreateCollectionRequest) (*commonpb.Status, error)
@ -8069,6 +8212,8 @@ type MilvusServiceServer interface {
SelectUser(context.Context, *SelectUserRequest) (*SelectUserResponse, error)
OperatePrivilege(context.Context, *OperatePrivilegeRequest) (*commonpb.Status, error)
SelectGrant(context.Context, *SelectGrantRequest) (*SelectGrantResponse, error)
CreateFunction(context.Context, *CreateFunctionRequest) (*commonpb.Status, error)
DropFunction(context.Context, *DropFunctionRequest) (*commonpb.Status, error)
}
// UnimplementedMilvusServiceServer can be embedded to have forward compatible implementations.
@ -8237,6 +8382,12 @@ func (*UnimplementedMilvusServiceServer) OperatePrivilege(ctx context.Context, r
func (*UnimplementedMilvusServiceServer) SelectGrant(ctx context.Context, req *SelectGrantRequest) (*SelectGrantResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SelectGrant not implemented")
}
func (*UnimplementedMilvusServiceServer) CreateFunction(ctx context.Context, req *CreateFunctionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateFunction not implemented")
}
func (*UnimplementedMilvusServiceServer) DropFunction(ctx context.Context, req *DropFunctionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method DropFunction not implemented")
}
func RegisterMilvusServiceServer(s *grpc.Server, srv MilvusServiceServer) {
s.RegisterService(&_MilvusService_serviceDesc, srv)
@ -9214,6 +9365,42 @@ func _MilvusService_SelectGrant_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _MilvusService_CreateFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateFunctionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MilvusServiceServer).CreateFunction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.milvus.MilvusService/CreateFunction",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MilvusServiceServer).CreateFunction(ctx, req.(*CreateFunctionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _MilvusService_DropFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DropFunctionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MilvusServiceServer).DropFunction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.milvus.MilvusService/DropFunction",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MilvusServiceServer).DropFunction(ctx, req.(*DropFunctionRequest))
}
return interceptor(ctx, in, info, handler)
}
var _MilvusService_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.milvus.MilvusService",
HandlerType: (*MilvusServiceServer)(nil),
@ -9434,6 +9621,14 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
MethodName: "SelectGrant",
Handler: _MilvusService_SelectGrant_Handler,
},
{
MethodName: "CreateFunction",
Handler: _MilvusService_CreateFunction_Handler,
},
{
MethodName: "DropFunction",
Handler: _MilvusService_DropFunction_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "milvus.proto",

1
internal/core/src/CMakeLists.txt
View File

@ -29,3 +29,4 @@ add_subdirectory( index )
add_subdirectory( query )
add_subdirectory( segcore )
add_subdirectory( indexbuilder )
add_subdirectory( wasm )

96
internal/core/src/pb/common.pb.cc
View File

@ -398,7 +398,7 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"Sealed\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005\022\013\n\007D"
"ropped\020\006\022\r\n\tImporting\020\007*>\n\017PlaceholderTy"
"pe\022\010\n\004None\020\000\022\020\n\014BinaryVector\020d\022\017\n\013FloatV"
"ector\020e*\370\014\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cr"
"ector\020e*\266\r\n\007MsgType\022\r\n\tUndefined\020\000\022\024\n\020Cr"
"eateCollection\020d\022\022\n\016DropCollection\020e\022\021\n\r"
"HasCollection\020f\022\026\n\022DescribeCollection\020g\022"
"\023\n\017ShowCollections\020h\022\024\n\020GetSystemConfigs"
@ -427,50 +427,51 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"\004\022\023\n\016UnsubDmChannel\020\204\004\022\024\n\017GetDistributio"
"n\020\205\004\022\025\n\020SyncDistribution\020\206\004\022\020\n\013SegmentIn"
"fo\020\330\004\022\017\n\nSystemInfo\020\331\004\022\024\n\017GetRecoveryInf"
"o\020\332\004\022\024\n\017GetSegmentState\020\333\004\022\r\n\010TimeTick\020\260"
"\t\022\023\n\016QueryNodeStats\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016"
"\n\tRequestID\020\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017Alloc"
"ateSegment\020\265\t\022\026\n\021SegmentStatistics\020\266\t\022\025\n"
"\020SegmentFlushDone\020\267\t\022\017\n\nDataNodeTt\020\270\t\022\025\n"
"\020CreateCredential\020\334\013\022\022\n\rGetCredential\020\335\013"
"\022\025\n\020DeleteCredential\020\336\013\022\025\n\020UpdateCredent"
"ial\020\337\013\022\026\n\021ListCredUsernames\020\340\013\022\017\n\nCreate"
"Role\020\300\014\022\r\n\010DropRole\020\301\014\022\024\n\017OperateUserRol"
"e\020\302\014\022\017\n\nSelectRole\020\303\014\022\017\n\nSelectUser\020\304\014\022\023"
"\n\016SelectResource\020\305\014\022\025\n\020OperatePrivilege\020"
"\306\014\022\020\n\013SelectGrant\020\307\014\022\033\n\026RefreshPolicyInf"
"oCache\020\310\014\022\017\n\nListPolicy\020\311\014*\"\n\007DslType\022\007\n"
"\003Dsl\020\000\022\016\n\nBoolExprV1\020\001*B\n\017CompactionStat"
"e\022\021\n\rUndefiedState\020\000\022\r\n\tExecuting\020\001\022\r\n\tC"
"ompleted\020\002*X\n\020ConsistencyLevel\022\n\n\006Strong"
"\020\000\022\013\n\007Session\020\001\022\013\n\007Bounded\020\002\022\016\n\nEventual"
"ly\020\003\022\016\n\nCustomized\020\004*\213\001\n\013ImportState\022\021\n\r"
"ImportPending\020\000\022\020\n\014ImportFailed\020\001\022\021\n\rImp"
"ortStarted\020\002\022\023\n\017ImportPersisted\020\005\022\023\n\017Imp"
"ortCompleted\020\006\022\032\n\026ImportFailedAndCleaned"
"\020\007*2\n\nObjectType\022\016\n\nCollection\020\000\022\n\n\006Glob"
"al\020\001\022\010\n\004User\020\002*\206\005\n\017ObjectPrivilege\022\020\n\014Pr"
"ivilegeAll\020\000\022\035\n\031PrivilegeCreateCollectio"
"n\020\001\022\033\n\027PrivilegeDropCollection\020\002\022\037\n\033Priv"
"ilegeDescribeCollection\020\003\022\034\n\030PrivilegeSh"
"owCollections\020\004\022\021\n\rPrivilegeLoad\020\005\022\024\n\020Pr"
"ivilegeRelease\020\006\022\027\n\023PrivilegeCompaction\020"
"\007\022\023\n\017PrivilegeInsert\020\010\022\023\n\017PrivilegeDelet"
"e\020\t\022\032\n\026PrivilegeGetStatistics\020\n\022\030\n\024Privi"
"legeCreateIndex\020\013\022\030\n\024PrivilegeIndexDetai"
"l\020\014\022\026\n\022PrivilegeDropIndex\020\r\022\023\n\017Privilege"
"Search\020\016\022\022\n\016PrivilegeFlush\020\017\022\022\n\016Privileg"
"eQuery\020\020\022\030\n\024PrivilegeLoadBalance\020\021\022\023\n\017Pr"
"ivilegeImport\020\022\022\034\n\030PrivilegeCreateOwners"
"hip\020\023\022\027\n\023PrivilegeUpdateUser\020\024\022\032\n\026Privil"
"egeDropOwnership\020\025\022\034\n\030PrivilegeSelectOwn"
"ership\020\026\022\034\n\030PrivilegeManageOwnership\020\027\022\027"
"\n\023PrivilegeSelectUser\020\030:^\n\021privilege_ext"
"_obj\022\037.google.protobuf.MessageOptions\030\351\007"
" \001(\0132!.milvus.proto.common.PrivilegeExtB"
"L\n\016io.milvus.grpcB\013CommonProtoP\001Z(github"
".com/milvus-io/milvus/api/commonpb\240\001\001b\006p"
"roto3"
"o\020\332\004\022\024\n\017GetSegmentState\020\333\004\022\023\n\016CreateFunc"
"tion\020\274\005\022\021\n\014DropFunction\020\275\005\022\024\n\017GetFunctio"
"nInfo\020\276\005\022\r\n\010TimeTick\020\260\t\022\023\n\016QueryNodeStat"
"s\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016\n\tRequestID\020\263\t\022\017\n\n"
"RequestTSO\020\264\t\022\024\n\017AllocateSegment\020\265\t\022\026\n\021S"
"egmentStatistics\020\266\t\022\025\n\020SegmentFlushDone\020"
"\267\t\022\017\n\nDataNodeTt\020\270\t\022\025\n\020CreateCredential\020"
"\334\013\022\022\n\rGetCredential\020\335\013\022\025\n\020DeleteCredenti"
"al\020\336\013\022\025\n\020UpdateCredential\020\337\013\022\026\n\021ListCred"
"Usernames\020\340\013\022\017\n\nCreateRole\020\300\014\022\r\n\010DropRol"
"e\020\301\014\022\024\n\017OperateUserRole\020\302\014\022\017\n\nSelectRole"
"\020\303\014\022\017\n\nSelectUser\020\304\014\022\023\n\016SelectResource\020\305"
"\014\022\025\n\020OperatePrivilege\020\306\014\022\020\n\013SelectGrant\020"
"\307\014\022\033\n\026RefreshPolicyInfoCache\020\310\014\022\017\n\nListP"
"olicy\020\311\014*\"\n\007DslType\022\007\n\003Dsl\020\000\022\016\n\nBoolExpr"
"V1\020\001*B\n\017CompactionState\022\021\n\rUndefiedState"
"\020\000\022\r\n\tExecuting\020\001\022\r\n\tCompleted\020\002*X\n\020Cons"
"istencyLevel\022\n\n\006Strong\020\000\022\013\n\007Session\020\001\022\013\n"
"\007Bounded\020\002\022\016\n\nEventually\020\003\022\016\n\nCustomized"
"\020\004*\213\001\n\013ImportState\022\021\n\rImportPending\020\000\022\020\n"
"\014ImportFailed\020\001\022\021\n\rImportStarted\020\002\022\023\n\017Im"
"portPersisted\020\005\022\023\n\017ImportCompleted\020\006\022\032\n\026"
"ImportFailedAndCleaned\020\007*2\n\nObjectType\022\016"
"\n\nCollection\020\000\022\n\n\006Global\020\001\022\010\n\004User\020\002*\206\005\n"
"\017ObjectPrivilege\022\020\n\014PrivilegeAll\020\000\022\035\n\031Pr"
"ivilegeCreateCollection\020\001\022\033\n\027PrivilegeDr"
"opCollection\020\002\022\037\n\033PrivilegeDescribeColle"
"ction\020\003\022\034\n\030PrivilegeShowCollections\020\004\022\021\n"
"\rPrivilegeLoad\020\005\022\024\n\020PrivilegeRelease\020\006\022\027"
"\n\023PrivilegeCompaction\020\007\022\023\n\017PrivilegeInse"
"rt\020\010\022\023\n\017PrivilegeDelete\020\t\022\032\n\026PrivilegeGe"
"tStatistics\020\n\022\030\n\024PrivilegeCreateIndex\020\013\022"
"\030\n\024PrivilegeIndexDetail\020\014\022\026\n\022PrivilegeDr"
"opIndex\020\r\022\023\n\017PrivilegeSearch\020\016\022\022\n\016Privil"
"egeFlush\020\017\022\022\n\016PrivilegeQuery\020\020\022\030\n\024Privil"
"egeLoadBalance\020\021\022\023\n\017PrivilegeImport\020\022\022\034\n"
"\030PrivilegeCreateOwnership\020\023\022\027\n\023Privilege"
"UpdateUser\020\024\022\032\n\026PrivilegeDropOwnership\020\025"
"\022\034\n\030PrivilegeSelectOwnership\020\026\022\034\n\030Privil"
"egeManageOwnership\020\027\022\027\n\023PrivilegeSelectU"
"ser\020\030:^\n\021privilege_ext_obj\022\037.google.prot"
"obuf.MessageOptions\030\351\007 \001(\0132!.milvus.prot"
"o.common.PrivilegeExtBL\n\016io.milvus.grpcB"
"\013CommonProtoP\001Z(github.com/milvus-io/mil"
"vus/api/commonpb\240\001\001b\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
&::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
@ -491,7 +492,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 5245,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 5307,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 11, 1,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 11, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -680,6 +681,9 @@ bool MsgType_IsValid(int value) {
case 601:
case 602:
case 603:
case 700:
case 701:
case 702:
case 1200:
case 1201:
case 1202:

3
internal/core/src/pb/common.pb.h
View File

@ -329,6 +329,9 @@ enum MsgType : int {
SystemInfo = 601,
GetRecoveryInfo = 602,
GetSegmentState = 603,
CreateFunction = 700,
DropFunction = 701,
GetFunctionInfo = 702,
TimeTick = 1200,
QueryNodeStats = 1201,
LoadIndex = 1202,

1097
internal/core/src/pb/plan.pb.cc
View File

File diff suppressed because it is too large Load Diff

671
internal/core/src/pb/plan.pb.h
View File

@ -49,7 +49,7 @@ struct TableStruct_plan_2eproto {
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[17]
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[19]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@ -98,6 +98,12 @@ extern QueryInfoDefaultTypeInternal _QueryInfo_default_instance_;
class TermExpr;
class TermExprDefaultTypeInternal;
extern TermExprDefaultTypeInternal _TermExpr_default_instance_;
class UdfExpr;
class UdfExprDefaultTypeInternal;
extern UdfExprDefaultTypeInternal _UdfExpr_default_instance_;
class UdfParams;
class UdfParamsDefaultTypeInternal;
extern UdfParamsDefaultTypeInternal _UdfParams_default_instance_;
class UnaryExpr;
class UnaryExprDefaultTypeInternal;
extern UnaryExprDefaultTypeInternal _UnaryExpr_default_instance_;
@ -127,6 +133,8 @@ template<> ::milvus::proto::plan::GenericValue* Arena::CreateMaybeMessage<::milv
template<> ::milvus::proto::plan::PlanNode* Arena::CreateMaybeMessage<::milvus::proto::plan::PlanNode>(Arena*);
template<> ::milvus::proto::plan::QueryInfo* Arena::CreateMaybeMessage<::milvus::proto::plan::QueryInfo>(Arena*);
template<> ::milvus::proto::plan::TermExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::TermExpr>(Arena*);
template<> ::milvus::proto::plan::UdfExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::UdfExpr>(Arena*);
template<> ::milvus::proto::plan::UdfParams* Arena::CreateMaybeMessage<::milvus::proto::plan::UdfParams>(Arena*);
template<> ::milvus::proto::plan::UnaryExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::UnaryExpr>(Arena*);
template<> ::milvus::proto::plan::UnaryRangeExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::UnaryRangeExpr>(Arena*);
template<> ::milvus::proto::plan::ValueExpr* Arena::CreateMaybeMessage<::milvus::proto::plan::ValueExpr>(Arena*);
@ -2471,6 +2479,343 @@ class BinaryArithOpEvalRangeExpr :
};
// -------------------------------------------------------------------
class UdfParams :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.UdfParams) */ {
public:
UdfParams();
virtual ~UdfParams();
UdfParams(const UdfParams& from);
UdfParams(UdfParams&& from) noexcept
: UdfParams() {
*this = ::std::move(from);
}
inline UdfParams& operator=(const UdfParams& from) {
CopyFrom(from);
return *this;
}
inline UdfParams& operator=(UdfParams&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const UdfParams& default_instance();
enum ValCase {
kValue = 1,
kColumnInfo = 2,
VAL_NOT_SET = 0,
};
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const UdfParams* internal_default_instance() {
return reinterpret_cast<const UdfParams*>(
&_UdfParams_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
friend void swap(UdfParams& a, UdfParams& b) {
a.Swap(&b);
}
inline void Swap(UdfParams* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline UdfParams* New() const final {
return CreateMaybeMessage<UdfParams>(nullptr);
}
UdfParams* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<UdfParams>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const UdfParams& from);
void MergeFrom(const UdfParams& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(UdfParams* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.plan.UdfParams";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_plan_2eproto);
return ::descriptor_table_plan_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kValueFieldNumber = 1,
kColumnInfoFieldNumber = 2,
};
// .milvus.proto.plan.GenericValue value = 1;
bool has_value() const;
void clear_value();
const ::milvus::proto::plan::GenericValue& value() const;
::milvus::proto::plan::GenericValue* release_value();
::milvus::proto::plan::GenericValue* mutable_value();
void set_allocated_value(::milvus::proto::plan::GenericValue* value);
// .milvus.proto.plan.ColumnInfo column_info = 2;
bool has_column_info() const;
void clear_column_info();
const ::milvus::proto::plan::ColumnInfo& column_info() const;
::milvus::proto::plan::ColumnInfo* release_column_info();
::milvus::proto::plan::ColumnInfo* mutable_column_info();
void set_allocated_column_info(::milvus::proto::plan::ColumnInfo* column_info);
void clear_val();
ValCase val_case() const;
// @@protoc_insertion_point(class_scope:milvus.proto.plan.UdfParams)
private:
class _Internal;
void set_has_value();
void set_has_column_info();
inline bool has_val() const;
inline void clear_has_val();
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
union ValUnion {
ValUnion() {}
::milvus::proto::plan::GenericValue* value_;
::milvus::proto::plan::ColumnInfo* column_info_;
} val_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------
class UdfExpr :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.UdfExpr) */ {
public:
UdfExpr();
virtual ~UdfExpr();
UdfExpr(const UdfExpr& from);
UdfExpr(UdfExpr&& from) noexcept
: UdfExpr() {
*this = ::std::move(from);
}
inline UdfExpr& operator=(const UdfExpr& from) {
CopyFrom(from);
return *this;
}
inline UdfExpr& operator=(UdfExpr&& from) noexcept {
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
if (this != &from) InternalSwap(&from);
} else {
CopyFrom(from);
}
return *this;
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
return GetDescriptor();
}
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
return GetMetadataStatic().descriptor;
}
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
return GetMetadataStatic().reflection;
}
static const UdfExpr& default_instance();
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
static inline const UdfExpr* internal_default_instance() {
return reinterpret_cast<const UdfExpr*>(
&_UdfExpr_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
friend void swap(UdfExpr& a, UdfExpr& b) {
a.Swap(&b);
}
inline void Swap(UdfExpr* other) {
if (other == this) return;
InternalSwap(other);
}
// implements Message ----------------------------------------------
inline UdfExpr* New() const final {
return CreateMaybeMessage<UdfExpr>(nullptr);
}
UdfExpr* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
return CreateMaybeMessage<UdfExpr>(arena);
}
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
void CopyFrom(const UdfExpr& from);
void MergeFrom(const UdfExpr& from);
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
bool IsInitialized() const final;
size_t ByteSizeLong() const final;
#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
#else
bool MergePartialFromCodedStream(
::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
#endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
void SerializeWithCachedSizes(
::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
int GetCachedSize() const final { return _cached_size_.Get(); }
private:
inline void SharedCtor();
inline void SharedDtor();
void SetCachedSize(int size) const final;
void InternalSwap(UdfExpr* other);
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "milvus.proto.plan.UdfExpr";
}
private:
inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
return nullptr;
}
inline void* MaybeArenaPtr() const {
return nullptr;
}
public:
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
private:
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_plan_2eproto);
return ::descriptor_table_plan_2eproto.file_level_metadata[kIndexInFileMessages];
}
public:
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kUdfParamsFieldNumber = 2,
kArgTypesFieldNumber = 4,
kUdfFuncNameFieldNumber = 1,
kWasmBodyFieldNumber = 3,
};
// repeated .milvus.proto.plan.UdfParams udf_params = 2;
int udf_params_size() const;
void clear_udf_params();
::milvus::proto::plan::UdfParams* mutable_udf_params(int index);
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::UdfParams >*
mutable_udf_params();
const ::milvus::proto::plan::UdfParams& udf_params(int index) const;
::milvus::proto::plan::UdfParams* add_udf_params();
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::UdfParams >&
udf_params() const;
// repeated .milvus.proto.schema.DataType arg_types = 4;
int arg_types_size() const;
void clear_arg_types();
::milvus::proto::schema::DataType arg_types(int index) const;
void set_arg_types(int index, ::milvus::proto::schema::DataType value);
void add_arg_types(::milvus::proto::schema::DataType value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& arg_types() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_arg_types();
// string udf_func_name = 1;
void clear_udf_func_name();
const std::string& udf_func_name() const;
void set_udf_func_name(const std::string& value);
void set_udf_func_name(std::string&& value);
void set_udf_func_name(const char* value);
void set_udf_func_name(const char* value, size_t size);
std::string* mutable_udf_func_name();
std::string* release_udf_func_name();
void set_allocated_udf_func_name(std::string* udf_func_name);
// string wasm_body = 3;
void clear_wasm_body();
const std::string& wasm_body() const;
void set_wasm_body(const std::string& value);
void set_wasm_body(std::string&& value);
void set_wasm_body(const char* value);
void set_wasm_body(const char* value, size_t size);
std::string* mutable_wasm_body();
std::string* release_wasm_body();
void set_allocated_wasm_body(std::string* wasm_body);
// @@protoc_insertion_point(class_scope:milvus.proto.plan.UdfExpr)
private:
class _Internal;
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::UdfParams > udf_params_;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> arg_types_;
mutable std::atomic<int> _arg_types_cached_byte_size_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr udf_func_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr wasm_body_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_plan_2eproto;
};
// -------------------------------------------------------------------
class Expr :
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.plan.Expr) */ {
public:
@ -2518,6 +2863,7 @@ class Expr :
kBinaryArithExpr = 8,
kValueExpr = 9,
kColumnExpr = 10,
kUdfExpr = 11,
EXPR_NOT_SET = 0,
};
@ -2527,7 +2873,7 @@ class Expr :
&_Expr_default_instance_);
}
static constexpr int kIndexInFileMessages =
14;
16;
friend void swap(Expr& a, Expr& b) {
a.Swap(&b);
@ -2608,6 +2954,7 @@ class Expr :
kBinaryArithExprFieldNumber = 8,
kValueExprFieldNumber = 9,
kColumnExprFieldNumber = 10,
kUdfExprFieldNumber = 11,
};
// .milvus.proto.plan.TermExpr term_expr = 1;
bool has_term_expr() const;
@ -2689,6 +3036,14 @@ class Expr :
::milvus::proto::plan::ColumnExpr* mutable_column_expr();
void set_allocated_column_expr(::milvus::proto::plan::ColumnExpr* column_expr);
// .milvus.proto.plan.UdfExpr udf_expr = 11;
bool has_udf_expr() const;
void clear_udf_expr();
const ::milvus::proto::plan::UdfExpr& udf_expr() const;
::milvus::proto::plan::UdfExpr* release_udf_expr();
::milvus::proto::plan::UdfExpr* mutable_udf_expr();
void set_allocated_udf_expr(::milvus::proto::plan::UdfExpr* udf_expr);
void clear_expr();
ExprCase expr_case() const;
// @@protoc_insertion_point(class_scope:milvus.proto.plan.Expr)
@ -2704,6 +3059,7 @@ class Expr :
void set_has_binary_arith_expr();
void set_has_value_expr();
void set_has_column_expr();
void set_has_udf_expr();
inline bool has_expr() const;
inline void clear_has_expr();
@ -2721,6 +3077,7 @@ class Expr :
::milvus::proto::plan::BinaryArithExpr* binary_arith_expr_;
::milvus::proto::plan::ValueExpr* value_expr_;
::milvus::proto::plan::ColumnExpr* column_expr_;
::milvus::proto::plan::UdfExpr* udf_expr_;
} expr_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
@ -2771,7 +3128,7 @@ class VectorANNS :
&_VectorANNS_default_instance_);
}
static constexpr int kIndexInFileMessages =
15;
17;
friend void swap(VectorANNS& a, VectorANNS& b) {
a.Swap(&b);
@ -2948,7 +3305,7 @@ class PlanNode :
&_PlanNode_default_instance_);
}
static constexpr int kIndexInFileMessages =
16;
18;
friend void swap(PlanNode& a, PlanNode& b) {
a.Swap(&b);
@ -4701,6 +5058,267 @@ inline void BinaryArithOpEvalRangeExpr::set_allocated_value(::milvus::proto::pla
// -------------------------------------------------------------------
// UdfParams
// .milvus.proto.plan.GenericValue value = 1;
inline bool UdfParams::has_value() const {
return val_case() == kValue;
}
inline void UdfParams::set_has_value() {
_oneof_case_[0] = kValue;
}
inline void UdfParams::clear_value() {
if (has_value()) {
delete val_.value_;
clear_has_val();
}
}
inline ::milvus::proto::plan::GenericValue* UdfParams::release_value() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.UdfParams.value)
if (has_value()) {
clear_has_val();
::milvus::proto::plan::GenericValue* temp = val_.value_;
val_.value_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::milvus::proto::plan::GenericValue& UdfParams::value() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfParams.value)
return has_value()
? *val_.value_
: *reinterpret_cast< ::milvus::proto::plan::GenericValue*>(&::milvus::proto::plan::_GenericValue_default_instance_);
}
inline ::milvus::proto::plan::GenericValue* UdfParams::mutable_value() {
if (!has_value()) {
clear_val();
set_has_value();
val_.value_ = CreateMaybeMessage< ::milvus::proto::plan::GenericValue >(
GetArenaNoVirtual());
}
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.UdfParams.value)
return val_.value_;
}
// .milvus.proto.plan.ColumnInfo column_info = 2;
inline bool UdfParams::has_column_info() const {
return val_case() == kColumnInfo;
}
inline void UdfParams::set_has_column_info() {
_oneof_case_[0] = kColumnInfo;
}
inline void UdfParams::clear_column_info() {
if (has_column_info()) {
delete val_.column_info_;
clear_has_val();
}
}
inline ::milvus::proto::plan::ColumnInfo* UdfParams::release_column_info() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.UdfParams.column_info)
if (has_column_info()) {
clear_has_val();
::milvus::proto::plan::ColumnInfo* temp = val_.column_info_;
val_.column_info_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::milvus::proto::plan::ColumnInfo& UdfParams::column_info() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfParams.column_info)
return has_column_info()
? *val_.column_info_
: *reinterpret_cast< ::milvus::proto::plan::ColumnInfo*>(&::milvus::proto::plan::_ColumnInfo_default_instance_);
}
inline ::milvus::proto::plan::ColumnInfo* UdfParams::mutable_column_info() {
if (!has_column_info()) {
clear_val();
set_has_column_info();
val_.column_info_ = CreateMaybeMessage< ::milvus::proto::plan::ColumnInfo >(
GetArenaNoVirtual());
}
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.UdfParams.column_info)
return val_.column_info_;
}
inline bool UdfParams::has_val() const {
return val_case() != VAL_NOT_SET;
}
inline void UdfParams::clear_has_val() {
_oneof_case_[0] = VAL_NOT_SET;
}
inline UdfParams::ValCase UdfParams::val_case() const {
return UdfParams::ValCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
// UdfExpr
// string udf_func_name = 1;
inline void UdfExpr::clear_udf_func_name() {
udf_func_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& UdfExpr::udf_func_name() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfExpr.udf_func_name)
return udf_func_name_.GetNoArena();
}
inline void UdfExpr::set_udf_func_name(const std::string& value) {
udf_func_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.plan.UdfExpr.udf_func_name)
}
inline void UdfExpr::set_udf_func_name(std::string&& value) {
udf_func_name_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.plan.UdfExpr.udf_func_name)
}
inline void UdfExpr::set_udf_func_name(const char* value) {
GOOGLE_DCHECK(value != nullptr);
udf_func_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.plan.UdfExpr.udf_func_name)
}
inline void UdfExpr::set_udf_func_name(const char* value, size_t size) {
udf_func_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.plan.UdfExpr.udf_func_name)
}
inline std::string* UdfExpr::mutable_udf_func_name() {
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.UdfExpr.udf_func_name)
return udf_func_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* UdfExpr::release_udf_func_name() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.UdfExpr.udf_func_name)
return udf_func_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void UdfExpr::set_allocated_udf_func_name(std::string* udf_func_name) {
if (udf_func_name != nullptr) {
} else {
}
udf_func_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), udf_func_name);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.UdfExpr.udf_func_name)
}
// repeated .milvus.proto.plan.UdfParams udf_params = 2;
inline int UdfExpr::udf_params_size() const {
return udf_params_.size();
}
inline void UdfExpr::clear_udf_params() {
udf_params_.Clear();
}
inline ::milvus::proto::plan::UdfParams* UdfExpr::mutable_udf_params(int index) {
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.UdfExpr.udf_params)
return udf_params_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::UdfParams >*
UdfExpr::mutable_udf_params() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.plan.UdfExpr.udf_params)
return &udf_params_;
}
inline const ::milvus::proto::plan::UdfParams& UdfExpr::udf_params(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfExpr.udf_params)
return udf_params_.Get(index);
}
inline ::milvus::proto::plan::UdfParams* UdfExpr::add_udf_params() {
// @@protoc_insertion_point(field_add:milvus.proto.plan.UdfExpr.udf_params)
return udf_params_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::plan::UdfParams >&
UdfExpr::udf_params() const {
// @@protoc_insertion_point(field_list:milvus.proto.plan.UdfExpr.udf_params)
return udf_params_;
}
// string wasm_body = 3;
inline void UdfExpr::clear_wasm_body() {
wasm_body_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& UdfExpr::wasm_body() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfExpr.wasm_body)
return wasm_body_.GetNoArena();
}
inline void UdfExpr::set_wasm_body(const std::string& value) {
wasm_body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
// @@protoc_insertion_point(field_set:milvus.proto.plan.UdfExpr.wasm_body)
}
inline void UdfExpr::set_wasm_body(std::string&& value) {
wasm_body_.SetNoArena(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
// @@protoc_insertion_point(field_set_rvalue:milvus.proto.plan.UdfExpr.wasm_body)
}
inline void UdfExpr::set_wasm_body(const char* value) {
GOOGLE_DCHECK(value != nullptr);
wasm_body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
// @@protoc_insertion_point(field_set_char:milvus.proto.plan.UdfExpr.wasm_body)
}
inline void UdfExpr::set_wasm_body(const char* value, size_t size) {
wasm_body_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
::std::string(reinterpret_cast<const char*>(value), size));
// @@protoc_insertion_point(field_set_pointer:milvus.proto.plan.UdfExpr.wasm_body)
}
inline std::string* UdfExpr::mutable_wasm_body() {
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.UdfExpr.wasm_body)
return wasm_body_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* UdfExpr::release_wasm_body() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.UdfExpr.wasm_body)
return wasm_body_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void UdfExpr::set_allocated_wasm_body(std::string* wasm_body) {
if (wasm_body != nullptr) {
} else {
}
wasm_body_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), wasm_body);
// @@protoc_insertion_point(field_set_allocated:milvus.proto.plan.UdfExpr.wasm_body)
}
// repeated .milvus.proto.schema.DataType arg_types = 4;
inline int UdfExpr::arg_types_size() const {
return arg_types_.size();
}
inline void UdfExpr::clear_arg_types() {
arg_types_.Clear();
}
inline ::milvus::proto::schema::DataType UdfExpr::arg_types(int index) const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.UdfExpr.arg_types)
return static_cast< ::milvus::proto::schema::DataType >(arg_types_.Get(index));
}
inline void UdfExpr::set_arg_types(int index, ::milvus::proto::schema::DataType value) {
arg_types_.Set(index, value);
// @@protoc_insertion_point(field_set:milvus.proto.plan.UdfExpr.arg_types)
}
inline void UdfExpr::add_arg_types(::milvus::proto::schema::DataType value) {
arg_types_.Add(value);
// @@protoc_insertion_point(field_add:milvus.proto.plan.UdfExpr.arg_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
UdfExpr::arg_types() const {
// @@protoc_insertion_point(field_list:milvus.proto.plan.UdfExpr.arg_types)
return arg_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
UdfExpr::mutable_arg_types() {
// @@protoc_insertion_point(field_mutable_list:milvus.proto.plan.UdfExpr.arg_types)
return &arg_types_;
}
// -------------------------------------------------------------------
// Expr
// .milvus.proto.plan.TermExpr term_expr = 1;
@ -5113,6 +5731,47 @@ inline ::milvus::proto::plan::ColumnExpr* Expr::mutable_column_expr() {
return expr_.column_expr_;
}
// .milvus.proto.plan.UdfExpr udf_expr = 11;
inline bool Expr::has_udf_expr() const {
return expr_case() == kUdfExpr;
}
inline void Expr::set_has_udf_expr() {
_oneof_case_[0] = kUdfExpr;
}
inline void Expr::clear_udf_expr() {
if (has_udf_expr()) {
delete expr_.udf_expr_;
clear_has_expr();
}
}
inline ::milvus::proto::plan::UdfExpr* Expr::release_udf_expr() {
// @@protoc_insertion_point(field_release:milvus.proto.plan.Expr.udf_expr)
if (has_udf_expr()) {
clear_has_expr();
::milvus::proto::plan::UdfExpr* temp = expr_.udf_expr_;
expr_.udf_expr_ = nullptr;
return temp;
} else {
return nullptr;
}
}
inline const ::milvus::proto::plan::UdfExpr& Expr::udf_expr() const {
// @@protoc_insertion_point(field_get:milvus.proto.plan.Expr.udf_expr)
return has_udf_expr()
? *expr_.udf_expr_
: *reinterpret_cast< ::milvus::proto::plan::UdfExpr*>(&::milvus::proto::plan::_UdfExpr_default_instance_);
}
inline ::milvus::proto::plan::UdfExpr* Expr::mutable_udf_expr() {
if (!has_udf_expr()) {
clear_expr();
set_has_udf_expr();
expr_.udf_expr_ = CreateMaybeMessage< ::milvus::proto::plan::UdfExpr >(
GetArenaNoVirtual());
}
// @@protoc_insertion_point(field_mutable:milvus.proto.plan.Expr.udf_expr)
return expr_.udf_expr_;
}
inline bool Expr::has_expr() const {
return expr_case() != EXPR_NOT_SET;
}
@ -5467,6 +6126,10 @@ inline PlanNode::NodeCase PlanNode::node_case() const {
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)

3
internal/core/src/query/CMakeLists.txt
View File

@ -31,4 +31,5 @@ set(MILVUS_QUERY_SRCS
PlanProto.cpp
)
add_library(milvus_query ${MILVUS_QUERY_SRCS})
target_link_libraries(milvus_query milvus_index)
target_link_libraries(milvus_query milvus_index milvus_wasm)

34
internal/core/src/query/Expr.h
View File

@ -23,6 +23,7 @@
#include <string>
#include <utility>
#include <vector>
#include <boost/variant.hpp>
#include "common/Schema.h"
#include "pb/plan.pb.h"
@ -200,4 +201,37 @@ struct CompareExpr : Expr {
accept(ExprVisitor&) override;
};
struct UdfExpr : Expr {
// Term: d in [1, 2],
// parameter contains fieldID, data_type.
// Udf : UDF "funcName" [Int8Field, 2, Int16Field, 4],
// parameter contains func_name, udf_args, wasm_body
// udf_args don't need to check field_id and data_type
using param = boost::variant<bool, int8_t, int16_t, int32_t, int64_t, float, double, FieldId>;
// function name
const std::string func_name_;
// function parameter
const std::vector<param> values_;
const std::vector<bool> is_field_;
// function body
const std::string wasm_body_;
// function argument types
const std::vector<DataType> arg_types_;
UdfExpr(const std::string func_name,
const std::vector<param>& values,
const std::vector<bool>& is_field,
const std::string wasm_body,
const std::vector<DataType>& arg_types)
: func_name_(func_name),
values_(values),
is_field_(is_field),
wasm_body_(wasm_body),
arg_types_(arg_types) {
}
public:
void
accept(ExprVisitor&) override;
};
} // namespace milvus::query

1
internal/core/src/query/ExprImpl.h
View File

@ -75,5 +75,4 @@ struct BinaryRangeExprImpl : BinaryRangeExpr {
upper_value_(upper_value) {
}
};
} // namespace milvus::query

57
internal/core/src/query/PlanProto.cpp
View File

@ -12,6 +12,7 @@
#include <google/protobuf/text_format.h>
#include <string>
#include <boost/variant.hpp>
#include "ExprImpl.h"
#include "PlanProto.h"
@ -411,6 +412,59 @@ ProtoParser::ParseBinaryArithOpEvalRangeExpr(const proto::plan::BinaryArithOpEva
return result;
}
ExprPtr
ProtoParser::ParseUdfExpr(const proto::plan::UdfExpr &expr_pb) {
using param = boost::variant<bool, int8_t, int16_t, int32_t, int64_t, float, double, FieldId>;
auto func_name = expr_pb.udf_func_name();
auto udf_params = expr_pb.udf_params();
auto size = udf_params.size();
std::vector<param> values;
auto wasm_body = expr_pb.wasm_body();
auto expr_args = expr_pb.arg_types();
std::vector<DataType> arg_types;
std::vector<bool> is_field;
for (int i = 0; i < size; ++i) {
arg_types.emplace_back(static_cast<DataType>(expr_args[i]));
}
// TODO(wang ziyu): Add assert check about data_type transformer between values and arg_types
for (int i = 0; i < size; ++i) {
if (udf_params[i].has_column_info()) {
auto& column_info = udf_params[i].column_info();
auto field_id = FieldId(column_info.field_id());
auto data_type = schema[field_id].get_data_type();
Assert(data_type == static_cast<DataType>(column_info.data_type()));
AssertInfo(arg_types[i] == data_type,
"[ExecExprVisitor]Column data type not equal to argument type");
values.emplace_back(field_id);
is_field.emplace_back(true);
} else if (udf_params[i].has_value()) {
auto& value_proto = udf_params[i].value();
is_field.emplace_back(false);
switch (value_proto.val_case()) {
case proto::plan::GenericValue::kBoolVal:
values.emplace_back(value_proto.bool_val());
break;
case proto::plan::GenericValue::kInt64Val:
values.emplace_back(value_proto.int64_val());
break;
case proto::plan::GenericValue::kFloatVal:
values.emplace_back(value_proto.float_val());
break;
default: {
PanicInfo("unsupported data type");
}
}
} else {
PanicInfo("unsupported data type");
}
}
return std::make_unique<UdfExpr>(func_name, values, is_field, wasm_body, arg_types);
}
ExprPtr
ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) {
using ppe = proto::plan::Expr;
@ -436,6 +490,9 @@ ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) {
case ppe::kBinaryArithOpEvalRangeExpr: {
return ParseBinaryArithOpEvalRangeExpr(expr_pb.binary_arith_op_eval_range_expr());
}
case ppe::kUdfExpr: {
return ParseUdfExpr(expr_pb.udf_expr());
}
default:
PanicInfo("unsupported expr proto node");
}

3
internal/core/src/query/PlanProto.h
View File

@ -50,6 +50,9 @@ class ProtoParser {
ExprPtr
ParseBinaryExpr(const proto::plan::BinaryExpr& expr_pb);
ExprPtr
ParseUdfExpr(const proto::plan::UdfExpr& expr_pb);
ExprPtr
ParseExpr(const proto::plan::Expr& expr_pb);

6
internal/core/src/query/generated/ExecExprVisitor.h
View File

@ -44,6 +44,9 @@ class ExecExprVisitor : public ExprVisitor {
void
visit(CompareExpr& expr) override;
void
visit(UdfExpr& expr) override;
public:
ExecExprVisitor(const segcore::SegmentInternalInterface& segment, int64_t row_count, Timestamp timestamp)
: segment_(segment), row_count_(row_count), timestamp_(timestamp) {
@ -88,6 +91,9 @@ class ExecExprVisitor : public ExprVisitor {
auto
ExecCompareExprDispatcher(CompareExpr& expr, CmpFunc cmp_func) -> BitsetType;
auto
ExecUdfVisitorDispatcher(UdfExpr& expr_raw) -> BitsetType;
private:
const segcore::SegmentInternalInterface& segment_;
Timestamp timestamp_;

5
internal/core/src/query/generated/Expr.cpp
View File

@ -49,4 +49,9 @@ CompareExpr::accept(ExprVisitor& visitor) {
visitor.visit(*this);
}
void
UdfExpr::accept(ExprVisitor& visitor) {
visitor.visit(*this);
}
} // namespace milvus::query

3
internal/core/src/query/generated/ExprVisitor.h
View File

@ -39,5 +39,8 @@ class ExprVisitor {
virtual void
visit(CompareExpr&) = 0;
virtual void
visit(UdfExpr&) = 0;
};
} // namespace milvus::query

3
internal/core/src/query/generated/ExtractInfoExprVisitor.h
View File

@ -39,6 +39,9 @@ class ExtractInfoExprVisitor : public ExprVisitor {
void
visit(CompareExpr& expr) override;
void
visit(UdfExpr& expr) override;
public:
explicit ExtractInfoExprVisitor(ExtractedPlanInfo& plan_info) : plan_info_(plan_info) {
}

3
internal/core/src/query/generated/ShowExprVisitor.h
View File

@ -40,6 +40,9 @@ class ShowExprVisitor : public ExprVisitor {
void
visit(CompareExpr& expr) override;
void
visit(UdfExpr& expr) override;
public:
Json

3
internal/core/src/query/generated/VerifyExprVisitor.h
View File

@ -44,6 +44,9 @@ class VerifyExprVisitor : public ExprVisitor {
void
visit(CompareExpr& expr) override;
void
visit(UdfExpr& expr) override;
public:
};
} // namespace milvus::query

174
internal/core/src/query/visitors/ExecExprVisitor.cpp
View File

@ -20,6 +20,7 @@
#include "segcore/SegmentGrowingImpl.h"
#include "query/Utils.h"
#include "query/Relational.h"
#include "wasm/WasmFunctionManager.h"
namespace milvus::query {
// THIS CONTAINS EXTRA BODY FOR VISITOR
@ -66,6 +67,14 @@ class ExecExprVisitor : ExprVisitor {
auto
ExecCompareExprDispatcher(CompareExpr& expr, CmpFunc cmp_func) -> BitsetType;
template <typename T, typename IndexFunc, typename ElementFunc>
auto
ExecUdfVisitorImpl(FieldId field_id, IndexFunc index_func, ElementFunc element_func) -> BitsetType;
template <typename T>
auto
ExecUdfVisitorDispatcher(UdfExpr& expr_raw) -> BitsetType;
private:
const segcore::SegmentInternalInterface& segment_;
int64_t row_count_;
@ -884,4 +893,169 @@ ExecExprVisitor::visit(TermExpr& expr) {
AssertInfo(res.size() == row_count_, "[ExecExprVisitor]Size of results not equal row count");
bitset_opt_ = std::move(res);
}
#pragma clang diagnostic push
#pragma ide diagnostic ignored "Simplify"
auto
ExecExprVisitor::ExecUdfVisitorDispatcher(UdfExpr& expr) -> BitsetType {
using param = boost::variant<bool, int8_t, int16_t, int32_t, int64_t, float, double, FieldId>;
using number = boost::variant<bool, int8_t, int16_t, int32_t, int64_t, float, double, std::string>;
// function name
const std::string func_name = expr.func_name_;
// function body
const std::string wasm_body = expr.wasm_body_;
WasmFunctionManager& wasmFunctionManager = WasmFunctionManager::getInstance();
wasmFunctionManager.RegisterFunction(func_name, func_name, wasm_body);
// function parameter
const std::vector<param> values = expr.values_;
const std::vector<DataType> value_types = expr.arg_types_;
const std::vector<bool> is_field = expr.is_field_;
auto params_size = values.size();
std::vector<wasmtime::Val> params;
params.reserve(params_size);
std::deque<BitsetType> bitsets;
auto size_per_chunk = segment_.size_per_chunk();
auto num_chunk = upper_div(row_count_, size_per_chunk);
for (int i = 0; i < params_size; ++i) {
if (is_field[i]) {
auto field_id = boost::get<FieldId>(values[i]);
auto data_barrier = segment_.num_chunk_data(field_id);
AssertInfo(data_barrier == num_chunk, "data_barrier not equal to num_chunk");
}
}
for (int64_t chunk_id = 0; chunk_id < num_chunk; ++chunk_id) {
auto size = chunk_id == num_chunk - 1 ? row_count_ - chunk_id * size_per_chunk : size_per_chunk;
auto getChunkData = [&, chunk_id](DataType type, FieldId field_id) -> std::function<const number(int)> {
switch (type) {
case DataType::BOOL: {
auto chunk_data = segment_.chunk_data<bool>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::INT8: {
auto chunk_data = segment_.chunk_data<int8_t>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::INT16: {
auto chunk_data = segment_.chunk_data<int16_t>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::INT32: {
auto chunk_data = segment_.chunk_data<int32_t>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::INT64: {
auto chunk_data = segment_.chunk_data<int64_t>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::FLOAT: {
auto chunk_data = segment_.chunk_data<float>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
case DataType::DOUBLE: {
auto chunk_data = segment_.chunk_data<double>(field_id, chunk_id).data();
return [chunk_data](int i) -> const number { return chunk_data[i]; };
}
default:
PanicInfo("unsupported datatype");
}
};
BitsetType bitset(size);
for (int i = 0; i < size; ++i) {
for (int param_index = 0; param_index < params_size; ++param_index) {
if (is_field[param_index]) {
auto field_id = boost::get<FieldId>(values[param_index]);
auto data_barrier = segment_.num_chunk_data(field_id);
auto data_type = value_types[param_index];
auto chunkData = getChunkData(data_type, field_id);
switch (data_type) {
case DataType::BOOL:
params.emplace_back(boost::get<bool>(chunkData(i)));
break;
case DataType::INT8:
params.emplace_back(boost::get<int8_t>(chunkData(i)));
break;
case DataType::INT16:
params.emplace_back(boost::get<int16_t>(chunkData(i)));
break;
case DataType::INT32:
params.emplace_back(boost::get<int32_t>(chunkData(i)));
break;
case DataType::INT64:
params.emplace_back(boost::get<int64_t>(chunkData(i)));
break;
case DataType::FLOAT:
params.emplace_back(boost::get<float>(chunkData(i)));
break;
case DataType::DOUBLE:
params.emplace_back(boost::get<double>(chunkData(i)));
break;
default: {
PanicInfo("unsupported data type");
}
}
} else {
auto data_type = value_types[param_index];
auto value = values[param_index];
switch (data_type) {
case DataType::BOOL:
params.emplace_back(boost::get<bool>(value));
break;
case DataType::INT8:
params.emplace_back(boost::get<int8_t>(value));
break;
case DataType::INT16:
params.emplace_back(boost::get<int16_t>(value));
break;
case DataType::INT32:
params.emplace_back(boost::get<int32_t>(value));
break;
case DataType::INT64:
params.emplace_back(boost::get<int64_t>(value));
break;
case DataType::FLOAT:
params.emplace_back(boost::get<float>(value));
break;
case DataType::DOUBLE:
params.emplace_back(boost::get<double>(value));
break;
default: {
PanicInfo("unsupported data type");
}
}
}
}
bool is_in = wasmFunctionManager.runElemFunc(func_name, params);
bitset[i] = is_in;
params.clear();
}
bitsets.emplace_back(std::move(bitset));
}
auto final_result = Assemble(bitsets);
AssertInfo(final_result.size() == row_count_, "[ExecExprVisitor]Final result size not equal to row count");
return final_result;
}
#pragma clang diagnostic pop
void
ExecExprVisitor::visit(UdfExpr& expr) {
auto& schema = segment_.get_schema();
auto values = expr.values_;
auto is_field = expr.is_field_;
auto arg_types = expr.arg_types_;
auto size = values.size();
for (int i = 0; i < size; ++i) {
if (is_field[i]) {
auto field_id = boost::get<FieldId>(values[i]);
auto &field_meta = schema[field_id];
AssertInfo(arg_types[i] == field_meta.get_data_type(),
"[ExecExprVisitor]field Data type not equal to field mata type");
}
}
BitsetType res;
res = ExecUdfVisitorDispatcher(expr);
AssertInfo(res.size() == row_count_, "[ExecExprVisitor]Size of results not equal row count");
bitset_opt_ = std::move(res);
}
} // namespace milvus::query

11
internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp
View File

@ -64,4 +64,15 @@ ExtractInfoExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) {
plan_info_.add_involved_field(expr.field_id_);
}
void
ExtractInfoExprVisitor::visit(UdfExpr& expr) {
auto value = expr.values_;
auto size = value.size();
for (int i = 0; i < size; ++i) {
if (expr.is_field_[i]) {
plan_info_.add_involved_field(boost::get<FieldId>(value[i]));
}
}
}
} // namespace milvus::query

5
internal/core/src/query/visitors/ShowExprVisitor.cpp
View File

@ -297,4 +297,9 @@ ShowExprVisitor::visit(BinaryArithOpEvalRangeExpr& expr) {
}
}
void
ShowExprVisitor::visit(UdfExpr& expr) {
// TODO
}
} // namespace milvus::query

5
internal/core/src/query/visitors/VerifyExprVisitor.cpp
View File

@ -47,4 +47,9 @@ VerifyExprVisitor::visit(CompareExpr& expr) {
// TODO
}
void
VerifyExprVisitor::visit(UdfExpr& expr) {
// TODO
}
} // namespace milvus::query

25
internal/core/src/wasm/CMakeLists.txt Normal file
View File

@ -0,0 +1,25 @@
# Copyright (C) 2019-2020 Zilliz. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software distributed under the License
# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
# or implied. See the License for the specific language governing permissions and limitations under the License
option( EMBEDDED_MILVUS "Enable embedded Milvus" OFF )
if ( EMBEDDED_MILVUS )
add_compile_definitions( EMBEDDED_MILVUS )
endif()
#WasmFunctionManager
set(MILVUS_WASM_SRCS
WasmFunctionManager.cpp
)
add_library(milvus_wasm ${MILVUS_WASM_SRCS})
target_link_libraries(milvus_wasm PUBLIC wasmtime)

63
internal/core/src/wasm/WasmFunctionManager.cpp Normal file
View File

@ -0,0 +1,63 @@
// Copyright (C) 2019-2020 Zilliz. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations under the License
//
// Created by wzy on 22-8-6.
//
#include <fstream>
#include <iostream>
#include <sstream>
#include "WasmFunctionManager.h"
namespace milvus {
bool WasmFunctionManager::RegisterFunction(std::string functionName,
std::string functionHandler,
const std::string &base64OrOtherString) {
auto funcBody = funcMap.find(functionName);
if (funcBody != funcMap.end()) {
return false;
}
auto watString = myBase64Decode(base64OrOtherString);
auto wasmRuntime = createInstanceAndFunction(watString, functionHandler);
modules.emplace(functionName, wasmRuntime);
funcMap.emplace(functionName, base64OrOtherString);
return true;
}
WasmtimeRunInstance WasmFunctionManager::createInstanceAndFunction(const std::string &watString,
const std::string &functionHandler) {
auto module = wasmtime::Module::compile(*engine, watString).unwrap();
auto instance = wasmtime::Instance::create(store, module, {}).unwrap();
auto function_obj = instance.get(store, functionHandler);
wasmtime::Func *func = std::get_if<wasmtime::Func>(&*function_obj);
return WasmtimeRunInstance(*func, instance);
}
bool WasmFunctionManager::runElemFunc(const std::string functionName, std::vector<wasmtime::Val> args) {
auto module = modules.at(functionName);
auto results = module.func.call(store, args).unwrap();
return results[0].i32();
}
bool WasmFunctionManager::DeleteFunction(std::string functionName) {
auto funcBody = funcMap.find(functionName);
if (funcBody == funcMap.end()) {
return false;
}
modules.erase(functionName);
return true;
}
} // namespace milvus

160
internal/core/src/wasm/WasmFunctionManager.h Normal file
View File

@ -0,0 +1,160 @@
// Copyright (C) 2019-2020 Zilliz. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations under the License
//
// Created by wzy on 22-8-6.
//
#ifndef MILVUS_WASMFUNCTION_H
#define MILVUS_WASMFUNCTION_H
#include <wasmtime/wasmtime.hh>
#include <unordered_map>
#include <cassert>
#include <boost/variant.hpp>
#include <limits>
#include <string>
#include <vector>
namespace milvus {
enum class WasmFunctionParamType {
INT32 = 1,
INT64 = 2,
FLOAT = 3,
STRING = 4,
};
struct WasmtimeRunInstance {
wasmtime::Func func;
wasmtime::Instance instance;
WasmtimeRunInstance(const wasmtime::Func &func, const wasmtime::Instance &instance)
: func(func), instance(instance) {}
};
class WasmFunctionManager {
private:
// wasmtime
wasmtime::Engine *engine;
wasmtime::Store *store;
std::unordered_map<std::string, std::string> funcMap;
std::unordered_map<std::string, WasmtimeRunInstance> modules;
WasmFunctionManager() {
engine = new wasmtime::Engine;
store = new wasmtime::Store(*engine);
}
~WasmFunctionManager() {
delete (store);
delete (engine);
}
WasmFunctionManager(const WasmFunctionManager&);
WasmFunctionManager& operator=(const WasmFunctionManager&);
// base64 tool
constexpr static const char b64_table[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
constexpr static const char reverse_table[128] = {
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64
};
public:
static WasmFunctionManager& getInstance() {
static WasmFunctionManager instance;
return instance;
}
WasmtimeRunInstance createInstanceAndFunction(const std::string &watString,
const std::string &functionHandler);
bool RegisterFunction(std::string functionName,
std::string functionHandler,
const std::string &base64OrOtherString);
bool runElemFunc(const std::string functionName, std::vector<wasmtime::Val> args);
bool DeleteFunction(std::string functionName);
// base64 tool
static std::string myBase64Encode(const ::std::string &bindata) {
using ::std::string;
using ::std::numeric_limits;
if (bindata.size() > (numeric_limits<string::size_type>::max() / 4u) * 3u) {
throw ::std::length_error("Converting too large a string to base64.");
}
const ::std::size_t binlen = bindata.size();
// Use = signs so the end is properly padded.
string retval((((binlen + 2) / 3) * 4), '=');
::std::size_t outpos = 0;
int bits_collected = 0;
unsigned int accumulator = 0;
const string::const_iterator binend = bindata.end();
for (string::const_iterator i = bindata.begin(); i != binend; ++i) {
accumulator = (accumulator << 8) | (*i & 0xffu);
bits_collected += 8;
while (bits_collected >= 6) {
bits_collected -= 6;
retval[outpos++] = b64_table[(accumulator >> bits_collected) & 0x3fu];
}
}
if (bits_collected > 0) { // Any trailing bits that are missing.
assert(bits_collected < 6);
accumulator <<= 6 - bits_collected;
retval[outpos++] = b64_table[accumulator & 0x3fu];
}
assert(outpos >= (retval.size() - 2));
assert(outpos <= retval.size());
return retval;
}
static std::string myBase64Decode(const ::std::string &ascdata) {
using ::std::string;
string retval;
const string::const_iterator last = ascdata.end();
int bits_collected = 0;
unsigned int accumulator = 0;
for (string::const_iterator i = ascdata.begin(); i != last; ++i) {
const int c = *i;
if (::std::isspace(c) || c == '=') {
// Skip whitespace and padding. Be liberal in what you accept.
continue;
}
if ((c > 127) || (c < 0) || (reverse_table[c] > 63)) {
throw ::std::invalid_argument("This contains characters not legal in a base64 encoded string.");
}
accumulator = (accumulator << 6) | reverse_table[c];
bits_collected += 6;
if (bits_collected >= 8) {
bits_collected -= 8;
retval += static_cast<char>((accumulator >> bits_collected) & 0xffu);
}
}
return retval;
}
};
} // namespace milvus
#endif //MILVUS_WASMFUNCTION_H

4
internal/core/thirdparty/CMakeLists.txt vendored
View File

@ -84,3 +84,7 @@ endif()
#if ( LINUX )
# add_subdirectory( rapidxml )
#endif()
# ******************************* Thirdparty wasmtime ********************************
add_subdirectory( wasmtime )

167
internal/core/thirdparty/wasmtime/CMakeLists.txt vendored Normal file
View File

@ -0,0 +1,167 @@
# Licensed to the LF AI & Data foundation under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set(WASMTIME_VERSION "v1.0.0")
set(WASMTIME_GIT_URL "git@github.com:bytecodealliance/wasmtime.git")
set(WASMTIME_GIT_COMMIT_HASH "9db8498faecf32dfc5c3fa923ac09250656d8f04")
macro(build_wasmtime)
message(STATUS "Building wasmtime-${WASMTIME_VERSION} from source")
option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
set (WASMTIME_DIR "${CMAKE_CURRENT_BINARY_DIR}/src")
message (${WASMTIME_DIR})
message (wasmtime-crate CMAKE_CURRENT_SOURCE_DIR: ${CMAKE_CURRENT_SOURCE_DIR})
if(CMAKE_BUILD_TYPE STREQUAL "Release")
set(WASMTIME_BUILD_TYPE_FLAG "--release")
set(WASMTIME_BUILD_TYPE "release")
else()
set(WASMTIME_BUILD_TYPE "debug")
endif()
if(BUILD_SHARED_LIBS)
if(WIN32)
set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/wasmtime.dll
${CMAKE_BINARY_DIR})
elseif(APPLE)
set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/libwasmtime.dylib
${CMAKE_BINARY_DIR})
else()
set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/libwasmtime.so
${CMAKE_BINARY_DIR})
endif()
else()
set(WASMTIME_INSTALL_COMMAND "")
endif()
if(BUILD_SHARED_LIBS)
if(WIN32)
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/wasmtime.dll.lib)
elseif(APPLE)
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/libwasmtime.dylib)
else()
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/libwasmtime.so)
endif()
else()
if(WIN32)
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/wasmtime.lib)
elseif(ANDROID)
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${ANDROID_TARGET}/${WASMTIME_BUILD_TYPE}/libwasmtime.a)
else()
set(WASMTIME_BUILD_PRODUCT
${WASMTIME_DIR}/target/${WASMTIME_BUILD_TYPE}/libwasmtime.a)
endif()
endif()
set (WASMTIME_BUILD_COMMAND cargo build ${WASMTIME_BUILD_TYPE_FLAG})
ExternalProject_Add(
wasmtime-crate
GIT_REPOSITORY ${WASMTIME_GIT_URL}
GIT_TAG ${WASMTIME_GIT_COMMIT_HASH}
DOWNLOAD_DIR ${THIRDPARTY_DOWNLOAD_PATH}
SOURCE_DIR ${WASMTIME_DIR}
SOURCE_SUBDIR "crates/c-api"
CONFIGURE_COMMAND ""
BUILD_IN_SOURCE 1
BUILD_COMMAND ${WASMTIME_BUILD_COMMAND}
BUILD_BYPRODUCTS ${WASMTIME_BUILD_PRODUCT}
INSTALL_COMMAND "${WASMTIME_INSTALL_COMMAND}"
${EP_LOG_OPTIONS}
)
ExternalProject_Get_Property(
wasmtime-crate
DOWNLOAD_DIR
CONFIGURE_COMMAND
BUILD_IN_SOURCE
BUILD_COMMAND
BUILD_BYPRODUCTS
INSTALL_COMMAND
GIT_REPOSITORY
GIT_TAG
SOURCE_DIR
SOURCE_SUBDIR
)
MESSAGE("wasmtime-crate DOWNLOAD_DIR ${DOWNLOAD_DIR}")
MESSAGE("wasmtime-crate CONFIGURE_COMMAND ${CONFIGURE_COMMAND}")
MESSAGE("wasmtime-crate BUILD_IN_SOURCE ${BUILD_IN_SOURCE}")
MESSAGE("wasmtime-crate BUILD_COMMAND ${BUILD_COMMAND}")
MESSAGE("wasmtime-crate BUILD_BYPRODUCTS ${BUILD_BYPRODUCTS}")
MESSAGE("wasmtime-crate INSTALL_COMMAND ${INSTALL_COMMAND}")
MESSAGE("wasmtime-crate GIT_REPOSITORY ${GIT_REPOSITORY}")
MESSAGE("wasmtime-crate GIT_TAG ${GIT_TAG}")
MESSAGE("wasmtime-crate SOURCE_DIR ${SOURCE_DIR}")
MESSAGE("wasmtime-crate SOURCE_SUBDIR ${SOURCE_SUBDIR}")
add_library(wasmtime INTERFACE)
add_dependencies(wasmtime wasmtime-crate)
if (BUILD_SHARED_LIBS)
if (NOT WIN32)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath='$ORIGIN'")
endif ()
target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT})
else ()
if (WIN32)
target_compile_options(wasmtime INTERFACE -DWASM_API_EXTERN= -DWASI_API_EXTERN=)
target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT}
ws2_32 advapi32 userenv ntdll shell32 ole32 bcrypt)
elseif (APPLE OR ANDROID)
target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT})
else ()
target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT}
pthread dl m)
endif ()
endif ()
target_include_directories(wasmtime INTERFACE
${WASMTIME_DIR}/crates/c-api/include ${WASMTIME_DIR}/crates/c-api/wasm-c-api/include
)
get_target_property(WASMTIME_INTERFACE_INCLUDE_DIRECTORIES wasmtime INTERFACE_INCLUDE_DIRECTORIES)
endmacro()
set(WASMTIME_SOURCE "AUTO")
if (WASMTIME_SOURCE STREQUAL "AUTO")
message(STATUS "Using wasmtime form system")
find_package(wasmtime)
message(STATUS "wasmtime libraries: ${WASMTIME_LIBRARIES}")
message(STATUS "wasmtime found: ${WASMTIME_FOUND}")
if (WASMTIME_FOUND)
add_library(wasmtime)
else ()
build_wasmtime()
endif ()
elseif (WASMTIME_SOURCE STREQUAL "BUNDLED")
message(STATUS "build wasmtime")
build_wasmtime()
elseif (WASMTIME_SOURCE STREQUAL "SYSTEM")
find_package(wasmtime)
add_library(wasmtime)
endif ()

3095
internal/core/thirdparty/wasmtime/wasmtime.hh vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
internal/core/unittest/CMakeLists.txt
View File

@ -96,6 +96,7 @@ target_link_libraries(all_tests
milvus_segcore
milvus_indexbuilder
pthread
wasmtime
)
install(TARGETS all_tests DESTINATION unittest)

170
internal/core/unittest/test_expr.cpp
View File

@ -1438,3 +1438,173 @@ TEST(Expr, TestBinaryArithOpEvalRangeWithScalarSortIndex) {
}
}
}
TEST(Expr, TestUdfExpr) {
using namespace milvus::query;
using namespace milvus::segcore;
// Add test cases for UdfExpr EQ of various data types
std::tuple<std::string, std::function<bool(int64_t, int64_t)>, std::string> testcase1 =
{R"(
udf_func_name: "less_than"
udf_params: <
column_info: <
field_id: %2%
data_type: Int64
>
>
udf_params: <
value: <
int64_val: 2000
>
>
wasm_body: "KG1vZHVsZQogICh0eXBlICg7MDspIChmdW5jIChwYXJhbSBpNjQgaTY0KSAocmVzdWx0IGkzMikpKQogIChmdW5jICRsZXNzX3RoYW4gKHR5cGUgMCkgKHBhcmFtIGk2NCBpNjQpIChyZXN1bHQgaTMyKQogICAgKGxvY2FsIGkzMiBpMzIgaTMyIGk2NCBpNjQgaTMyIGkzMiBpMzIpCiAgICBnbG9iYWwuZ2V0ICRfX3N0YWNrX3BvaW50ZXIKICAgIGxvY2FsLnNldCAyCiAgICBpMzIuY29uc3QgMTYKICAgIGxvY2FsLnNldCAzCiAgICBsb2NhbC5nZXQgMgogICAgbG9jYWwuZ2V0IDMKICAgIGkzMi5zdWIKICAgIGxvY2FsLnNldCA0CiAgICBsb2NhbC5nZXQgNAogICAgbG9jYWwuZ2V0IDAKICAgIGk2NC5zdG9yZQogICAgbG9jYWwuZ2V0IDQKICAgIGxvY2FsLmdldCAxCiAgICBpNjQuc3RvcmUgb2Zmc2V0PTgKICAgIGxvY2FsLmdldCAwCiAgICBsb2NhbC5zZXQgNQogICAgbG9jYWwuZ2V0IDEKICAgIGxvY2FsLnNldCA2CiAgICBsb2NhbC5nZXQgNQogICAgbG9jYWwuZ2V0IDYKICAgIGk2NC5sdF9zCiAgICBsb2NhbC5zZXQgNwogICAgaTMyLmNvbnN0IDEKICAgIGxvY2FsLnNldCA4CiAgICBsb2NhbC5nZXQgNwogICAgbG9jYWwuZ2V0IDgKICAgIGkzMi5hbmQKICAgIGxvY2FsLnNldCA5CiAgICBsb2NhbC5nZXQgOQogICAgcmV0dXJuKQogICh0YWJsZSAoOzA7KSAxIDEgZnVuY3JlZikKICAobWVtb3J5ICg7MDspIDE2KQogIChnbG9iYWwgJF9fc3RhY2tfcG9pbnRlciAobXV0IGkzMikgKGkzMi5jb25zdCAxMDQ4NTc2KSkKICAoZ2xvYmFsICg7MTspIGkzMiAoaTMyLmNvbnN0IDEwNDg1NzYpKQogIChnbG9iYWwgKDsyOykgaTMyIChpMzIuY29uc3QgMTA0ODU3NikpCiAgKGV4cG9ydCAibWVtb3J5IiAobWVtb3J5IDApKQogIChleHBvcnQgImxlc3NfdGhhbiIgKGZ1bmMgJGxlc3NfdGhhbikpCiAgKGV4cG9ydCAiX19kYXRhX2VuZCIgKGdsb2JhbCAxKSkKICAoZXhwb3J0ICJfX2hlYXBfYmFzZSIgKGdsb2JhbCAyKSkpCg=="
arg_types: Int64
arg_types: Int64
)", [](int64_t a, int64_t b) { return a < b; }, "less_than"};
std::tuple<std::string, std::function<bool(int8_t, int16_t, int32_t, int64_t, int64_t)>, std::string> testcase2 =
{R"(
udf_func_name: "multiple_columns"
udf_params: <
column_info: <
field_id: %2%
data_type: Int8
>
>
udf_params: <
column_info: <
field_id: %3%
data_type: Int16
>
>
udf_params: <
column_info: <
field_id: %4%
data_type: Int32
>
>
udf_params: <
column_info: <
field_id: %5%
data_type: Int64
>
>
udf_params: <
value: <
int64_val: 2000
>
>
wasm_body: "KG1vZHVsZQogICh0eXBlICg7MDspIChmdW5jIChwYXJhbSBpMzIgaTMyIGkzMiBpNjQgaTY0KSAocmVzdWx0IGkzMikpKQogIChmdW5jICRtdWx0aXBsZV9jb2x1bW5zICh0eXBlIDApIChwYXJhbSBpMzIgaTMyIGkzMiBpNjQgaTY0KSAocmVzdWx0IGkzMikKICAgIGxvY2FsLmdldCAxCiAgICBpNjQuZXh0ZW5kX2kzMl91CiAgICBpNjQuY29uc3QgNDgKICAgIGk2NC5zaGwKICAgIGk2NC5jb25zdCA0OAogICAgaTY0LnNocl9zCiAgICBsb2NhbC5nZXQgMAogICAgaTY0LmV4dGVuZF9pMzJfdQogICAgaTY0LmNvbnN0IDU2CiAgICBpNjQuc2hsCiAgICBpNjQuY29uc3QgNTYKICAgIGk2NC5zaHJfcwogICAgaTY0LmFkZAogICAgbG9jYWwuZ2V0IDIKICAgIGk2NC5leHRlbmRfaTMyX3MKICAgIGk2NC5hZGQKICAgIGxvY2FsLmdldCAzCiAgICBpNjQuYWRkCiAgICBsb2NhbC5nZXQgNAogICAgaTY0Lmd0X3MpCiAgKHRhYmxlICg7MDspIDEgMSBmdW5jcmVmKQogIChtZW1vcnkgKDswOykgMTYpCiAgKGdsb2JhbCAkX19zdGFja19wb2ludGVyIChtdXQgaTMyKSAoaTMyLmNvbnN0IDEwNDg1NzYpKQogIChnbG9iYWwgKDsxOykgaTMyIChpMzIuY29uc3QgMTA0ODU3NikpCiAgKGdsb2JhbCAoOzI7KSBpMzIgKGkzMi5jb25zdCAxMDQ4NTc2KSkKICAoZXhwb3J0ICJtZW1vcnkiIChtZW1vcnkgMCkpCiAgKGV4cG9ydCAibXVsdGlwbGVfY29sdW1ucyIgKGZ1bmMgJG11bHRpcGxlX2NvbHVtbnMpKQogIChleHBvcnQgIl9fZGF0YV9lbmQiIChnbG9iYWwgMSkpCiAgKGV4cG9ydCAiX19oZWFwX2Jhc2UiIChnbG9iYWwgMikpKQ=="
arg_types: Int8
arg_types: Int16
arg_types: Int32
arg_types: Int64
arg_types: Int64
)", [](int8_t a, int16_t b, int32_t c, int64_t d, int64_t e) { return a + b + c + d > e; }, "multi_columns"};
std::string serialized_expr_plan = R"(
vector_anns: <
field_id: %1%
predicates: <
udf_expr: <
@@@@@
>
>
query_info: <
topk: 10
round_decimal: 3
metric_type: "L2"
search_params: "{\"nprobe\": 10}"
>
placeholder_tag: "$0"
>)";
auto schema = std::make_shared<Schema>();
auto vec_fid = schema->AddDebugField("fakevec", DataType::VECTOR_FLOAT, 16, knowhere::metric::L2);
auto i8_fid = schema->AddDebugField("age8", DataType::INT8);
auto i16_fid = schema->AddDebugField("age16", DataType::INT16);
auto i32_fid = schema->AddDebugField("age32", DataType::INT32);
auto i64_fid = schema->AddDebugField("age64", DataType::INT64);
auto float_fid = schema->AddDebugField("age_float", DataType::FLOAT);
auto double_fid = schema->AddDebugField("age_double", DataType::DOUBLE);
schema->set_primary_field_id(i64_fid);
auto seg = CreateGrowingSegment(schema);
int N = 1000;
std::vector<int8_t> age8_col;
std::vector<int16_t> age16_col;
std::vector<int32_t> age32_col;
std::vector<int64_t> age64_col;
std::vector<float> age_float_col;
std::vector<double> age_double_col;
int num_iters = 100;
for (int iter = 0; iter < num_iters; ++iter) {
auto raw_data = DataGen(schema, N, iter);
auto new_age8_col = raw_data.get_col<int8_t>(i8_fid);
auto new_age16_col = raw_data.get_col<int16_t>(i16_fid);
auto new_age32_col = raw_data.get_col<int32_t>(i32_fid);
auto new_age64_col = raw_data.get_col<int64_t>(i64_fid);
auto new_age_float_col = raw_data.get_col<float>(float_fid);
auto new_age_double_col = raw_data.get_col<double>(double_fid);
age8_col.insert(age8_col.end(), new_age8_col.begin(), new_age8_col.end());
age16_col.insert(age16_col.end(), new_age16_col.begin(), new_age16_col.end());
age32_col.insert(age32_col.end(), new_age32_col.begin(), new_age32_col.end());
age64_col.insert(age64_col.end(), new_age64_col.begin(), new_age64_col.end());
age_float_col.insert(age_float_col.end(), new_age_float_col.begin(), new_age_float_col.end());
age_double_col.insert(age_double_col.end(), new_age_double_col.begin(), new_age_double_col.end());
seg->PreInsert(N);
seg->Insert(iter * N, N, raw_data.row_ids_.data(), raw_data.timestamps_.data(), raw_data.raw_);
}
auto seg_promote = dynamic_cast<SegmentGrowingImpl*>(seg.get());
ExecExprVisitor visitor(*seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP);
// testcase1
auto clause1 = std::get<0>(testcase1);
auto ref_func1 = std::get<1>(testcase1);
auto udf_name1 = std::get<2>(testcase1);
auto loc = serialized_expr_plan.find("@@@@@");
auto expr_plan = serialized_expr_plan;
expr_plan.replace(loc, 5, clause1);
boost::format expr = boost::format(expr_plan) % vec_fid.get() % i64_fid.get();
auto binary_plan = translate_text_plan_to_binary_plan(expr.str().data());
auto plan = CreateSearchPlanByExpr(*schema, binary_plan.data(), binary_plan.size());
auto final = visitor.call_child(*plan->plan_node_->predicate_.value());
EXPECT_EQ(final.size(), N * num_iters);
for (int i = 0; i < N * num_iters; ++i) {
auto ans = final[i];
auto val1 = age64_col[i];
auto val2 = 2000;
auto ref = ref_func1(val1, val2);
ASSERT_EQ(ans, ref) << clause1 << "@" << udf_name1 << "@" << i << "!!" <<
boost::format("[%1%, %2%]") % val1 % val2;
}
// testcase2
auto clause2= std::get<0>(testcase2);
auto ref_func2 = std::get<1>(testcase2);
auto udf_name2 = std::get<2>(testcase2);
loc = serialized_expr_plan.find("@@@@@");
expr_plan = serialized_expr_plan;
expr_plan.replace(loc, 5, clause2);
boost::format expr2 = boost::format(expr_plan) % vec_fid.get() % i8_fid.get() % i16_fid.get() % i32_fid.get() % i64_fid.get();
binary_plan = translate_text_plan_to_binary_plan(expr2.str().data());
plan = CreateSearchPlanByExpr(*schema, binary_plan.data(), binary_plan.size());
final = visitor.call_child(*plan->plan_node_->predicate_.value());
EXPECT_EQ(final.size(), N * num_iters);
for (int i = 0; i < N * num_iters; ++i) {
auto ans = final[i];
auto val1 = age8_col[i];
auto val2 = age16_col[i];
auto val3 = age32_col[i];
auto val4 = age64_col[i];
auto val5 = 2000;
auto ref = ref_func2(val1, val2, val3, val4, val5);
ASSERT_EQ(ans, ref) << clause2 << "@" << i << "!!" <<
boost::format("[%1%, %2%, %3%, %4%, %5%]") % val1 % val2 % val3 % val4 % val5;
}
}

55
internal/core/unittest/test_plan_proto.cpp
View File

@ -107,7 +107,7 @@ vector_anns: <
auto proto_text = fmt1.str();
planpb::PlanNode node_proto;
google::protobuf::TextFormat::ParseFromString(proto_text, &node_proto);
// std::cout << node_proto.DebugString();
// std::cout << node_proto.DebugString();
auto plan = ProtoParser(*schema).CreatePlan(node_proto);
ShowPlanNodeVisitor visitor;
@ -148,6 +148,59 @@ vector_anns: <
plan->check_identical(*ref_plan);
}
TEST_P(PlanProtoTest, UdfExpr) {
FieldName vec_field_name = FieldName("FloatVectorField");
FieldId vec_float_field_id = schema->get_field_id(vec_field_name);
auto field_name = std::get<0>(GetParam());
auto field_id = schema->get_field_id(FieldName(field_name));
auto data_type = schema->operator[](field_id).get_data_type();
auto data_type_str = spb::DataType_Name(int(data_type));
string value_tag = "bool_val";
if (datatype_is_floating(data_type)) {
value_tag = "float_val";
} else if (datatype_is_integer(data_type)) {
value_tag = "int64_val";
}
auto proto_text = R"(
vector_anns: <
field_id: 102
predicates: <
udf_expr: <
udf_func_name: "larger_than"
udf_params: <
column_info: <
field_id: 101
data_type: Double
>
>
udf_params: <
value: <
int64_val: 2000
>
>
wasm_body: "not implemented"
arg_types: Int16
arg_types: Double
>
>
query_info: <
topk: 3
metric_type: "L2"
search_params: "{\"nprobe\":10}"
round_decimal: -1
>
placeholder_tag: "$0"
>
output_field_ids: 101
)";
planpb::PlanNode node_proto;
google::protobuf::TextFormat::ParseFromString(proto_text, &node_proto);
// TODO (ziyu wang): Add udf plan proto unittest
}
TEST_P(PlanProtoTest, TermExpr) {
// xxx.query(predicates = "int64field in [1, 2, 3]", topk = 10, ...)
FieldName vec_field_name = FieldName("FloatVectorField");

12
internal/datacoord/mock_test.go
View File

@ -266,6 +266,18 @@ type mockRootCoordService struct {
cnt int64
}
func (m *mockRootCoordService) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoordService) DropFunction(ctx context.Context, req *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (m *mockRootCoordService) GetFunctionInfo(ctx context.Context, req *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
panic("implement me")
}
func (m *mockRootCoordService) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
panic("implement me")
}

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

@ -709,6 +709,16 @@ func (s *Server) LoadBalance(ctx context.Context, request *milvuspb.LoadBalanceR
return s.proxy.LoadBalance(ctx, request)
}
// CreateFunction notifies Proxy to create function
func (s *Server) CreateFunction(ctx context.Context, request *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
return s.proxy.CreateFunction(ctx, request)
}
// DropFunction notifies Proxy to drop function
func (s *Server) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
return s.proxy.DropFunction(ctx, request)
}
// CreateAlias notifies Proxy to create alias
func (s *Server) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
return s.proxy.CreateAlias(ctx, request)

20
internal/distributed/proxy/service_test.go
View File

@ -432,6 +432,18 @@ func (m *MockQueryCoord) ShowConfigurations(ctx context.Context, req *internalpb
return nil, nil
}
func (m *MockRootCoord) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
return nil, nil
}
func (m *MockRootCoord) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
return nil, nil
}
func (m *MockRootCoord) GetFunctionInfo(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
return nil, nil
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockDataCoord struct {
MockBase
@ -868,6 +880,14 @@ func (m *MockProxy) RefreshPolicyInfoCache(ctx context.Context, req *proxypb.Ref
return nil, nil
}
func (m *MockProxy) CreateFunction(ctx context.Context, request *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
return nil, nil
}
func (m *MockProxy) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
return nil, nil
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type WaitOption struct {

39
internal/distributed/rootcoord/client/client.go
View File

@ -652,3 +652,42 @@ func (c *Client) ListPolicy(ctx context.Context, req *internalpb.ListPolicyReque
}
return ret.(*internalpb.ListPolicyResponse), err
}
func (c *Client) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(rootcoordpb.RootCoordClient).CreateFunction(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*commonpb.Status), err
}
func (c *Client) DropFunction(ctx context.Context, req *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(rootcoordpb.RootCoordClient).DropFunction(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*commonpb.Status), err
}
func (c *Client) GetFunctionInfo(ctx context.Context, req *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(rootcoordpb.RootCoordClient).GetFunctionInfo(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*rootcoordpb.GetFunctionInfoResponse), err
}

5
internal/distributed/rootcoord/client/client_test.go
View File

@ -212,6 +212,10 @@ func Test_NewClient(t *testing.T) {
r, err := client.ShowConfigurations(ctx, nil)
retCheck(retNotNil, r, err)
}
{
r, err := client.CreateFunction(ctx, nil)
retCheck(retNotNil, r, err)
}
}
client.grpcClient = &mock.GRPCClientBase{
@ -410,6 +414,7 @@ func Test_NewClient(t *testing.T) {
rTimeout, err := client.ListPolicy(shortCtx, nil)
retCheck(rTimeout, err)
}
// clean up
err = client.Stop()
assert.Nil(t, err)

12
internal/distributed/rootcoord/service.go
View File

@ -491,3 +491,15 @@ func (s *Server) SelectGrant(ctx context.Context, request *milvuspb.SelectGrantR
func (s *Server) ListPolicy(ctx context.Context, request *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
return s.rootCoord.ListPolicy(ctx, request)
}
func (s *Server) CreateFunction(ctx context.Context, request *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
return s.rootCoord.CreateFunction(ctx, request)
}
func (s *Server) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
return s.rootCoord.DropFunction(ctx, request)
}
func (s *Server) GetFunctionInfo(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
return s.rootCoord.GetFunctionInfo(ctx, request)
}

141
internal/mocks/mock_rootcoord.go
View File

@ -313,6 +313,53 @@ func (_c *RootCoord_CreateCredential_Call) Return(_a0 *commonpb.Status, _a1 erro
return _c
}
// CreateFunction provides a mock function with given fields: ctx, req
func (_m *RootCoord) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.CreateFunctionRequest) *commonpb.Status); ok {
r0 = rf(ctx, req)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*commonpb.Status)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.CreateFunctionRequest) error); ok {
r1 = rf(ctx, req)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RootCoord_CreateFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFunction'
type RootCoord_CreateFunction_Call struct {
*mock.Call
}
// CreateFunction is a helper method to define mock.On call
// - ctx context.Context
// - req *milvuspb.CreateFunctionRequest
func (_e *RootCoord_Expecter) CreateFunction(ctx interface{}, req interface{}) *RootCoord_CreateFunction_Call {
return &RootCoord_CreateFunction_Call{Call: _e.mock.On("CreateFunction", ctx, req)}
}
func (_c *RootCoord_CreateFunction_Call) Run(run func(ctx context.Context, req *milvuspb.CreateFunctionRequest)) *RootCoord_CreateFunction_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.CreateFunctionRequest))
})
return _c
}
func (_c *RootCoord_CreateFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_CreateFunction_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// CreatePartition provides a mock function with given fields: ctx, req
func (_m *RootCoord) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
@ -595,6 +642,53 @@ func (_c *RootCoord_DropCollection_Call) Return(_a0 *commonpb.Status, _a1 error)
return _c
}
// DropFunction provides a mock function with given fields: ctx, request
func (_m *RootCoord) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, request)
var r0 *commonpb.Status
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.DropFunctionRequest) *commonpb.Status); ok {
r0 = rf(ctx, request)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*commonpb.Status)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.DropFunctionRequest) error); ok {
r1 = rf(ctx, request)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RootCoord_DropFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DropFunction'
type RootCoord_DropFunction_Call struct {
*mock.Call
}
// DropFunction is a helper method to define mock.On call
// - ctx context.Context
// - request *milvuspb.DropFunctionRequest
func (_e *RootCoord_Expecter) DropFunction(ctx interface{}, request interface{}) *RootCoord_DropFunction_Call {
return &RootCoord_DropFunction_Call{Call: _e.mock.On("DropFunction", ctx, request)}
}
func (_c *RootCoord_DropFunction_Call) Run(run func(ctx context.Context, request *milvuspb.DropFunctionRequest)) *RootCoord_DropFunction_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*milvuspb.DropFunctionRequest))
})
return _c
}
func (_c *RootCoord_DropFunction_Call) Return(_a0 *commonpb.Status, _a1 error) *RootCoord_DropFunction_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// DropPartition provides a mock function with given fields: ctx, req
func (_m *RootCoord) DropPartition(ctx context.Context, req *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
ret := _m.Called(ctx, req)
@ -782,6 +876,53 @@ func (_c *RootCoord_GetCredential_Call) Return(_a0 *rootcoordpb.GetCredentialRes
return _c
}
// GetFunctionInfo provides a mock function with given fields: ctx, request
func (_m *RootCoord) GetFunctionInfo(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
ret := _m.Called(ctx, request)
var r0 *rootcoordpb.GetFunctionInfoResponse
if rf, ok := ret.Get(0).(func(context.Context, *rootcoordpb.GetFunctionInfoRequest) *rootcoordpb.GetFunctionInfoResponse); ok {
r0 = rf(ctx, request)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*rootcoordpb.GetFunctionInfoResponse)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *rootcoordpb.GetFunctionInfoRequest) error); ok {
r1 = rf(ctx, request)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// RootCoord_GetFunctionInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFunctionInfo'
type RootCoord_GetFunctionInfo_Call struct {
*mock.Call
}
// GetFunctionInfo is a helper method to define mock.On call
// - ctx context.Context
// - request *rootcoordpb.GetFunctionInfoRequest
func (_e *RootCoord_Expecter) GetFunctionInfo(ctx interface{}, request interface{}) *RootCoord_GetFunctionInfo_Call {
return &RootCoord_GetFunctionInfo_Call{Call: _e.mock.On("GetFunctionInfo", ctx, request)}
}
func (_c *RootCoord_GetFunctionInfo_Call) Run(run func(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest)) *RootCoord_GetFunctionInfo_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*rootcoordpb.GetFunctionInfoRequest))
})
return _c
}
func (_c *RootCoord_GetFunctionInfo_Call) Return(_a0 *rootcoordpb.GetFunctionInfoResponse, _a1 error) *RootCoord_GetFunctionInfo_Call {
_c.Call.Return(_a0, _a1)
return _c
}
// GetImportState provides a mock function with given fields: ctx, req
func (_m *RootCoord) GetImportState(ctx context.Context, req *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error) {
ret := _m.Called(ctx, req)

6
internal/parser/planparserv2/Plan.g4
View File

@ -7,6 +7,7 @@ expr:
| StringLiteral # String
| Identifier # Identifier
| '(' expr ')' # Parens
| UDF StringLiteral ('[' expr (',' expr)* ','? ']') # Udf
| expr LIKE StringLiteral # Like
| expr POW expr # Power
| op = (ADD | SUB | BNOT | NOT) expr # Unary
@ -24,7 +25,8 @@ expr:
| expr BXOR expr # BitXor
| expr BOR expr # BitOr
| expr AND expr # LogicalAnd
| expr OR expr # LogicalOr;
| expr OR expr # LogicalOr
;
// typeName: ty = (BOOL | INT8 | INT16 | INT32 | INT64 | FLOAT | DOUBLE);
@ -45,6 +47,8 @@ NE: '!=';
LIKE: 'like' | 'LIKE';
UDF: 'udf' | 'UDF';
ADD: '+';
SUB: '-';
MUL: '*';

4
internal/parser/planparserv2/generated/Plan.interp
View File

@ -12,6 +12,7 @@ null
'=='
'!='
null
null
'+'
'-'
'*'
@ -52,6 +53,7 @@ GE
EQ
NE
LIKE
UDF
ADD
SUB
MUL
@ -83,4 +85,4 @@ expr
atn:
[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 39, 89, 4, 2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 17, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 71, 10, 2, 12, 2, 14, 2, 74, 11, 2, 3, 2, 5, 2, 77, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 84, 10, 2, 12, 2, 14, 2, 87, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 11, 4, 2, 15, 16, 28, 29, 3, 2, 17, 19, 3, 2, 15, 16, 3, 2, 21, 22, 3, 2, 8, 9, 3, 2, 10, 11, 3, 2, 8, 11, 3, 2, 12, 13, 3, 2, 30, 31, 2, 111, 2, 16, 3, 2, 2, 2, 4, 5, 8, 2, 1, 2, 5, 17, 7, 34, 2, 2, 6, 17, 7, 35, 2, 2, 7, 17, 7, 33, 2, 2, 8, 17, 7, 37, 2, 2, 9, 17, 7, 36, 2, 2, 10, 11, 7, 3, 2, 2, 11, 12, 5, 2, 2, 2, 12, 13, 7, 4, 2, 2, 13, 17, 3, 2, 2, 2, 14, 15, 9, 2, 2, 2, 15, 17, 5, 2, 2, 17, 16, 4, 3, 2, 2, 2, 16, 6, 3, 2, 2, 2, 16, 7, 3, 2, 2, 2, 16, 8, 3, 2, 2, 2, 16, 9, 3, 2, 2, 2, 16, 10, 3, 2, 2, 2, 16, 14, 3, 2, 2, 2, 17, 85, 3, 2, 2, 2, 18, 19, 12, 18, 2, 2, 19, 20, 7, 20, 2, 2, 20, 84, 5, 2, 2, 19, 21, 22, 12, 16, 2, 2, 22, 23, 9, 3, 2, 2, 23, 84, 5, 2, 2, 17, 24, 25, 12, 15, 2, 2, 25, 26, 9, 4, 2, 2, 26, 84, 5, 2, 2, 16, 27, 28, 12, 14, 2, 2, 28, 29, 9, 5, 2, 2, 29, 84, 5, 2, 2, 15, 30, 31, 12, 11, 2, 2, 31, 32, 9, 6, 2, 2, 32, 33, 7, 36, 2, 2, 33, 34, 9, 6, 2, 2, 34, 84, 5, 2, 2, 12, 35, 36, 12, 10, 2, 2, 36, 37, 9, 7, 2, 2, 37, 38, 7, 36, 2, 2, 38, 39, 9, 7, 2, 2, 39, 84, 5, 2, 2, 11, 40, 41, 12, 9, 2, 2, 41, 42, 9, 8, 2, 2, 42, 84, 5, 2, 2, 10, 43, 44, 12, 8, 2, 2, 44, 45, 9, 9, 2, 2, 45, 84, 5, 2, 2, 9, 46, 47, 12, 7, 2, 2, 47, 48, 7, 23, 2, 2, 48, 84, 5, 2, 2, 8, 49, 50, 12, 6, 2, 2, 50, 51, 7, 25, 2, 2, 51, 84, 5, 2, 2, 7, 52, 53, 12, 5, 2, 2, 53, 54, 7, 24, 2, 2, 54, 84, 5, 2, 2, 6, 55, 56, 12, 4, 2, 2, 56, 57, 7, 26, 2, 2, 57, 84, 5, 2, 2, 5, 58, 59, 12, 3, 2, 2, 59, 60, 7, 27, 2, 2, 60, 84, 5, 2, 2, 4, 61, 62, 12, 19, 2, 2, 62, 63, 7, 14, 2, 2, 63, 84, 7, 37, 2, 2, 64, 65, 12, 13, 2, 2, 65, 66, 9, 10, 2, 2, 66, 67, 7, 5, 2, 2, 67, 72, 5, 2, 2, 2, 68, 69, 7, 6, 2, 2, 69, 71, 5, 2, 2, 2, 70, 68, 3, 2, 2, 2, 71, 74, 3, 2, 2, 2, 72, 70, 3, 2, 2, 2, 72, 73, 3, 2, 2, 2, 73, 76, 3, 2, 2, 2, 74, 72, 3, 2, 2, 2, 75, 77, 7, 6, 2, 2, 76, 75, 3, 2, 2, 2, 76, 77, 3, 2, 2, 2, 77, 78, 3, 2, 2, 2, 78, 79, 7, 7, 2, 2, 79, 84, 3, 2, 2, 2, 80, 81, 12, 12, 2, 2, 81, 82, 9, 10, 2, 2, 82, 84, 7, 32, 2, 2, 83, 18, 3, 2, 2, 2, 83, 21, 3, 2, 2, 2, 83, 24, 3, 2, 2, 2, 83, 27, 3, 2, 2, 2, 83, 30, 3, 2, 2, 2, 83, 35, 3, 2, 2, 2, 83, 40, 3, 2, 2, 2, 83, 43, 3, 2, 2, 2, 83, 46, 3, 2, 2, 2, 83, 49, 3, 2, 2, 2, 83, 52, 3, 2, 2, 2, 83, 55, 3, 2, 2, 2, 83, 58, 3, 2, 2, 2, 83, 61, 3, 2, 2, 2, 83, 64, 3, 2, 2, 2, 83, 80, 3, 2, 2, 2, 84, 87, 3, 2, 2, 2, 85, 83, 3, 2, 2, 2, 85, 86, 3, 2, 2, 2, 86, 3, 3, 2, 2, 2, 87, 85, 3, 2, 2, 2, 7, 16, 72, 76, 83, 85]
[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 40, 105, 4, 2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 21, 10, 2, 12, 2, 14, 2, 24, 11, 2, 3, 2, 5, 2, 27, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 33, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 87, 10, 2, 12, 2, 14, 2, 90, 11, 2, 3, 2, 5, 2, 93, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 100, 10, 2, 12, 2, 14, 2, 103, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 11, 4, 2, 16, 17, 29, 30, 3, 2, 18, 20, 3, 2, 16, 17, 3, 2, 22, 23, 3, 2, 8, 9, 3, 2, 10, 11, 3, 2, 8, 11, 3, 2, 12, 13, 3, 2, 31, 32, 2, 130, 2, 32, 3, 2, 2, 2, 4, 5, 8, 2, 1, 2, 5, 33, 7, 35, 2, 2, 6, 33, 7, 36, 2, 2, 7, 33, 7, 34, 2, 2, 8, 33, 7, 38, 2, 2, 9, 33, 7, 37, 2, 2, 10, 11, 7, 3, 2, 2, 11, 12, 5, 2, 2, 2, 12, 13, 7, 4, 2, 2, 13, 33, 3, 2, 2, 2, 14, 15, 7, 15, 2, 2, 15, 16, 7, 38, 2, 2, 16, 17, 7, 5, 2, 2, 17, 22, 5, 2, 2, 2, 18, 19, 7, 6, 2, 2, 19, 21, 5, 2, 2, 2, 20, 18, 3, 2, 2, 2, 21, 24, 3, 2, 2, 2, 22, 20, 3, 2, 2, 2, 22, 23, 3, 2, 2, 2, 23, 26, 3, 2, 2, 2, 24, 22, 3, 2, 2, 2, 25, 27, 7, 6, 2, 2, 26, 25, 3, 2, 2, 2, 26, 27, 3, 2, 2, 2, 27, 28, 3, 2, 2, 2, 28, 29, 7, 7, 2, 2, 29, 33, 3, 2, 2, 2, 30, 31, 9, 2, 2, 2, 31, 33, 5, 2, 2, 17, 32, 4, 3, 2, 2, 2, 32, 6, 3, 2, 2, 2, 32, 7, 3, 2, 2, 2, 32, 8, 3, 2, 2, 2, 32, 9, 3, 2, 2, 2, 32, 10, 3, 2, 2, 2, 32, 14, 3, 2, 2, 2, 32, 30, 3, 2, 2, 2, 33, 101, 3, 2, 2, 2, 34, 35, 12, 18, 2, 2, 35, 36, 7, 21, 2, 2, 36, 100, 5, 2, 2, 19, 37, 38, 12, 16, 2, 2, 38, 39, 9, 3, 2, 2, 39, 100, 5, 2, 2, 17, 40, 41, 12, 15, 2, 2, 41, 42, 9, 4, 2, 2, 42, 100, 5, 2, 2, 16, 43, 44, 12, 14, 2, 2, 44, 45, 9, 5, 2, 2, 45, 100, 5, 2, 2, 15, 46, 47, 12, 11, 2, 2, 47, 48, 9, 6, 2, 2, 48, 49, 7, 37, 2, 2, 49, 50, 9, 6, 2, 2, 50, 100, 5, 2, 2, 12, 51, 52, 12, 10, 2, 2, 52, 53, 9, 7, 2, 2, 53, 54, 7, 37, 2, 2, 54, 55, 9, 7, 2, 2, 55, 100, 5, 2, 2, 11, 56, 57, 12, 9, 2, 2, 57, 58, 9, 8, 2, 2, 58, 100, 5, 2, 2, 10, 59, 60, 12, 8, 2, 2, 60, 61, 9, 9, 2, 2, 61, 100, 5, 2, 2, 9, 62, 63, 12, 7, 2, 2, 63, 64, 7, 24, 2, 2, 64, 100, 5, 2, 2, 8, 65, 66, 12, 6, 2, 2, 66, 67, 7, 26, 2, 2, 67, 100, 5, 2, 2, 7, 68, 69, 12, 5, 2, 2, 69, 70, 7, 25, 2, 2, 70, 100, 5, 2, 2, 6, 71, 72, 12, 4, 2, 2, 72, 73, 7, 27, 2, 2, 73, 100, 5, 2, 2, 5, 74, 75, 12, 3, 2, 2, 75, 76, 7, 28, 2, 2, 76, 100, 5, 2, 2, 4, 77, 78, 12, 19, 2, 2, 78, 79, 7, 14, 2, 2, 79, 100, 7, 38, 2, 2, 80, 81, 12, 13, 2, 2, 81, 82, 9, 10, 2, 2, 82, 83, 7, 5, 2, 2, 83, 88, 5, 2, 2, 2, 84, 85, 7, 6, 2, 2, 85, 87, 5, 2, 2, 2, 86, 84, 3, 2, 2, 2, 87, 90, 3, 2, 2, 2, 88, 86, 3, 2, 2, 2, 88, 89, 3, 2, 2, 2, 89, 92, 3, 2, 2, 2, 90, 88, 3, 2, 2, 2, 91, 93, 7, 6, 2, 2, 92, 91, 3, 2, 2, 2, 92, 93, 3, 2, 2, 2, 93, 94, 3, 2, 2, 2, 94, 95, 7, 7, 2, 2, 95, 100, 3, 2, 2, 2, 96, 97, 12, 12, 2, 2, 97, 98, 9, 10, 2, 2, 98, 100, 7, 33, 2, 2, 99, 34, 3, 2, 2, 2, 99, 37, 3, 2, 2, 2, 99, 40, 3, 2, 2, 2, 99, 43, 3, 2, 2, 2, 99, 46, 3, 2, 2, 2, 99, 51, 3, 2, 2, 2, 99, 56, 3, 2, 2, 2, 99, 59, 3, 2, 2, 2, 99, 62, 3, 2, 2, 2, 99, 65, 3, 2, 2, 2, 99, 68, 3, 2, 2, 2, 99, 71, 3, 2, 2, 2, 99, 74, 3, 2, 2, 2, 99, 77, 3, 2, 2, 2, 99, 80, 3, 2, 2, 2, 99, 96, 3, 2, 2, 2, 100, 103, 3, 2, 2, 2, 101, 99, 3, 2, 2, 2, 101, 102, 3, 2, 2, 2, 102, 3, 3, 2, 2, 2, 103, 101, 3, 2, 2, 2, 9, 22, 26, 32, 88, 92, 99, 101]

79
internal/parser/planparserv2/generated/Plan.tokens
View File

@ -10,31 +10,32 @@ GE=9
EQ=10
NE=11
LIKE=12
ADD=13
SUB=14
MUL=15
DIV=16
MOD=17
POW=18
SHL=19
SHR=20
BAND=21
BOR=22
BXOR=23
AND=24
OR=25
BNOT=26
NOT=27
IN=28
NIN=29
EmptyTerm=30
BooleanConstant=31
IntegerConstant=32
FloatingConstant=33
Identifier=34
StringLiteral=35
Whitespace=36
Newline=37
UDF=13
ADD=14
SUB=15
MUL=16
DIV=17
MOD=18
POW=19
SHL=20
SHR=21
BAND=22
BOR=23
BXOR=24
AND=25
OR=26
BNOT=27
NOT=28
IN=29
NIN=30
EmptyTerm=31
BooleanConstant=32
IntegerConstant=33
FloatingConstant=34
Identifier=35
StringLiteral=36
Whitespace=37
Newline=38
'('=1
')'=2
'['=3
@ -46,17 +47,17 @@ Newline=37
'>='=9
'=='=10
'!='=11
'+'=13
'-'=14
'*'=15
'/'=16
'%'=17
'**'=18
'<<'=19
'>>'=20
'&'=21
'|'=22
'^'=23
'~'=26
'in'=28
'not in'=29
'+'=14
'-'=15
'*'=16
'/'=17
'%'=18
'**'=19
'<<'=20
'>>'=21
'&'=22
'|'=23
'^'=24
'~'=27
'in'=29
'not in'=30

5
internal/parser/planparserv2/generated/PlanLexer.interp
View File

File diff suppressed because one or more lines are too long

79
internal/parser/planparserv2/generated/PlanLexer.tokens
View File

@ -10,31 +10,32 @@ GE=9
EQ=10
NE=11
LIKE=12
ADD=13
SUB=14
MUL=15
DIV=16
MOD=17
POW=18
SHL=19
SHR=20
BAND=21
BOR=22
BXOR=23
AND=24
OR=25
BNOT=26
NOT=27
IN=28
NIN=29
EmptyTerm=30
BooleanConstant=31
IntegerConstant=32
FloatingConstant=33
Identifier=34
StringLiteral=35
Whitespace=36
Newline=37
UDF=13
ADD=14
SUB=15
MUL=16
DIV=17
MOD=18
POW=19
SHL=20
SHR=21
BAND=22
BOR=23
BXOR=24
AND=25
OR=26
BNOT=27
NOT=28
IN=29
NIN=30
EmptyTerm=31
BooleanConstant=32
IntegerConstant=33
FloatingConstant=34
Identifier=35
StringLiteral=36
Whitespace=37
Newline=38
'('=1
')'=2
'['=3
@ -46,17 +47,17 @@ Newline=37
'>='=9
'=='=10
'!='=11
'+'=13
'-'=14
'*'=15
'/'=16
'%'=17
'**'=18
'<<'=19
'>>'=20
'&'=21
'|'=22
'^'=23
'~'=26
'in'=28
'not in'=29
'+'=14
'-'=15
'*'=16
'/'=17
'%'=18
'**'=19
'<<'=20
'>>'=21
'&'=22
'|'=23
'^'=24
'~'=27
'in'=29
'not in'=30

4
internal/parser/planparserv2/generated/plan_base_visitor.go
View File

@ -75,6 +75,10 @@ func (v *BasePlanVisitor) VisitLike(ctx *LikeContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitUdf(ctx *UdfContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitBitAnd(ctx *BitAndContext) interface{} {
return v.VisitChildren(ctx)
}

469
internal/parser/planparserv2/generated/plan_lexer.go
View File

@ -14,7 +14,7 @@ var _ = fmt.Printf
var _ = unicode.IsLetter
var serializedLexerAtn = []uint16{
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 39, 444,
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 40, 454,
8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7,
9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12,
4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4,
@ -26,199 +26,203 @@ var serializedLexerAtn = []uint16{
9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9,
49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54,
4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4,
60, 9, 60, 4, 61, 9, 61, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5,
3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3,
10, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13,
3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 158, 10, 13, 3, 14, 3, 14, 3, 15, 3,
15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20,
3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 3,
24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 190, 10, 25, 3, 26, 3, 26,
3, 26, 3, 26, 5, 26, 196, 10, 26, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3,
28, 5, 28, 204, 10, 28, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30,
3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 7, 31, 219, 10, 31, 12, 31, 14,
31, 222, 11, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32,
3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3,
32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32,
5, 32, 253, 10, 32, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 259, 10, 33, 3,
34, 3, 34, 5, 34, 263, 10, 34, 3, 35, 3, 35, 3, 35, 7, 35, 268, 10, 35,
12, 35, 14, 35, 271, 11, 35, 3, 36, 5, 36, 274, 10, 36, 3, 36, 3, 36, 5,
36, 278, 10, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 5, 37, 285, 10, 37,
3, 38, 6, 38, 288, 10, 38, 13, 38, 14, 38, 289, 3, 39, 3, 39, 3, 39, 3,
39, 3, 39, 3, 39, 3, 39, 5, 39, 299, 10, 39, 3, 40, 3, 40, 3, 41, 3, 41,
3, 42, 3, 42, 3, 42, 6, 42, 308, 10, 42, 13, 42, 14, 42, 309, 3, 43, 3,
43, 7, 43, 314, 10, 43, 12, 43, 14, 43, 317, 11, 43, 3, 44, 3, 44, 7, 44,
321, 10, 44, 12, 44, 14, 44, 324, 11, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3,
46, 3, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49,
3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5,
50, 351, 10, 50, 3, 51, 3, 51, 5, 51, 355, 10, 51, 3, 51, 3, 51, 3, 51,
5, 51, 360, 10, 51, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 366, 10, 52, 3,
52, 3, 52, 3, 53, 5, 53, 371, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53,
5, 53, 378, 10, 53, 3, 54, 3, 54, 5, 54, 382, 10, 54, 3, 54, 3, 54, 3,
55, 6, 55, 387, 10, 55, 13, 55, 14, 55, 388, 3, 56, 5, 56, 392, 10, 56,
3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 399, 10, 56, 3, 57, 6, 57, 402,
10, 57, 13, 57, 14, 57, 403, 3, 58, 3, 58, 5, 58, 408, 10, 58, 3, 58, 3,
58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 417, 10, 59, 3, 59, 5, 59,
420, 10, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 427, 10, 59, 3,
60, 6, 60, 430, 10, 60, 13, 60, 14, 60, 431, 3, 60, 3, 60, 3, 61, 3, 61,
5, 61, 438, 10, 61, 3, 61, 5, 61, 441, 10, 61, 3, 61, 3, 61, 2, 2, 62,
3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23,
13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41,
22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59,
31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 2, 75, 2, 77, 2,
79, 2, 81, 2, 83, 2, 85, 2, 87, 2, 89, 2, 91, 2, 93, 2, 95, 2, 97, 2, 99,
2, 101, 2, 103, 2, 105, 2, 107, 2, 109, 2, 111, 2, 113, 2, 115, 2, 117,
2, 119, 38, 121, 39, 3, 2, 17, 5, 2, 78, 78, 87, 87, 119, 119, 6, 2, 12,
12, 15, 15, 36, 36, 94, 94, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59,
4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 4, 2, 90, 90, 122, 122, 3, 2, 51,
59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 71, 71, 103, 103,
4, 2, 45, 45, 47, 47, 4, 2, 82, 82, 114, 114, 12, 2, 36, 36, 41, 41, 65,
65, 94, 94, 99, 100, 104, 104, 112, 112, 116, 116, 118, 118, 120, 120,
4, 2, 11, 11, 34, 34, 2, 467, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7,
3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2,
15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2,
2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2,
2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2,
2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3,
2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53,
3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2,
61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2,
2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2,
2, 2, 3, 123, 3, 2, 2, 2, 5, 125, 3, 2, 2, 2, 7, 127, 3, 2, 2, 2, 9, 129,
3, 2, 2, 2, 11, 131, 3, 2, 2, 2, 13, 133, 3, 2, 2, 2, 15, 135, 3, 2, 2,
2, 17, 138, 3, 2, 2, 2, 19, 140, 3, 2, 2, 2, 21, 143, 3, 2, 2, 2, 23, 146,
3, 2, 2, 2, 25, 157, 3, 2, 2, 2, 27, 159, 3, 2, 2, 2, 29, 161, 3, 2, 2,
2, 31, 163, 3, 2, 2, 2, 33, 165, 3, 2, 2, 2, 35, 167, 3, 2, 2, 2, 37, 169,
3, 2, 2, 2, 39, 172, 3, 2, 2, 2, 41, 175, 3, 2, 2, 2, 43, 178, 3, 2, 2,
2, 45, 180, 3, 2, 2, 2, 47, 182, 3, 2, 2, 2, 49, 189, 3, 2, 2, 2, 51, 195,
3, 2, 2, 2, 53, 197, 3, 2, 2, 2, 55, 203, 3, 2, 2, 2, 57, 205, 3, 2, 2,
2, 59, 208, 3, 2, 2, 2, 61, 215, 3, 2, 2, 2, 63, 252, 3, 2, 2, 2, 65, 258,
3, 2, 2, 2, 67, 262, 3, 2, 2, 2, 69, 264, 3, 2, 2, 2, 71, 273, 3, 2, 2,
2, 73, 284, 3, 2, 2, 2, 75, 287, 3, 2, 2, 2, 77, 298, 3, 2, 2, 2, 79, 300,
3, 2, 2, 2, 81, 302, 3, 2, 2, 2, 83, 304, 3, 2, 2, 2, 85, 311, 3, 2, 2,
2, 87, 318, 3, 2, 2, 2, 89, 325, 3, 2, 2, 2, 91, 329, 3, 2, 2, 2, 93, 331,
3, 2, 2, 2, 95, 333, 3, 2, 2, 2, 97, 335, 3, 2, 2, 2, 99, 350, 3, 2, 2,
2, 101, 359, 3, 2, 2, 2, 103, 361, 3, 2, 2, 2, 105, 377, 3, 2, 2, 2, 107,
379, 3, 2, 2, 2, 109, 386, 3, 2, 2, 2, 111, 398, 3, 2, 2, 2, 113, 401,
3, 2, 2, 2, 115, 405, 3, 2, 2, 2, 117, 426, 3, 2, 2, 2, 119, 429, 3, 2,
2, 2, 121, 440, 3, 2, 2, 2, 123, 124, 7, 42, 2, 2, 124, 4, 3, 2, 2, 2,
125, 126, 7, 43, 2, 2, 126, 6, 3, 2, 2, 2, 127, 128, 7, 93, 2, 2, 128,
8, 3, 2, 2, 2, 129, 130, 7, 46, 2, 2, 130, 10, 3, 2, 2, 2, 131, 132, 7,
95, 2, 2, 132, 12, 3, 2, 2, 2, 133, 134, 7, 62, 2, 2, 134, 14, 3, 2, 2,
2, 135, 136, 7, 62, 2, 2, 136, 137, 7, 63, 2, 2, 137, 16, 3, 2, 2, 2, 138,
139, 7, 64, 2, 2, 139, 18, 3, 2, 2, 2, 140, 141, 7, 64, 2, 2, 141, 142,
7, 63, 2, 2, 142, 20, 3, 2, 2, 2, 143, 144, 7, 63, 2, 2, 144, 145, 7, 63,
2, 2, 145, 22, 3, 2, 2, 2, 146, 147, 7, 35, 2, 2, 147, 148, 7, 63, 2, 2,
148, 24, 3, 2, 2, 2, 149, 150, 7, 110, 2, 2, 150, 151, 7, 107, 2, 2, 151,
152, 7, 109, 2, 2, 152, 158, 7, 103, 2, 2, 153, 154, 7, 78, 2, 2, 154,
155, 7, 75, 2, 2, 155, 156, 7, 77, 2, 2, 156, 158, 7, 71, 2, 2, 157, 149,
3, 2, 2, 2, 157, 153, 3, 2, 2, 2, 158, 26, 3, 2, 2, 2, 159, 160, 7, 45,
2, 2, 160, 28, 3, 2, 2, 2, 161, 162, 7, 47, 2, 2, 162, 30, 3, 2, 2, 2,
163, 164, 7, 44, 2, 2, 164, 32, 3, 2, 2, 2, 165, 166, 7, 49, 2, 2, 166,
34, 3, 2, 2, 2, 167, 168, 7, 39, 2, 2, 168, 36, 3, 2, 2, 2, 169, 170, 7,
44, 2, 2, 170, 171, 7, 44, 2, 2, 171, 38, 3, 2, 2, 2, 172, 173, 7, 62,
2, 2, 173, 174, 7, 62, 2, 2, 174, 40, 3, 2, 2, 2, 175, 176, 7, 64, 2, 2,
176, 177, 7, 64, 2, 2, 177, 42, 3, 2, 2, 2, 178, 179, 7, 40, 2, 2, 179,
44, 3, 2, 2, 2, 180, 181, 7, 126, 2, 2, 181, 46, 3, 2, 2, 2, 182, 183,
7, 96, 2, 2, 183, 48, 3, 2, 2, 2, 184, 185, 7, 40, 2, 2, 185, 190, 7, 40,
2, 2, 186, 187, 7, 99, 2, 2, 187, 188, 7, 112, 2, 2, 188, 190, 7, 102,
2, 2, 189, 184, 3, 2, 2, 2, 189, 186, 3, 2, 2, 2, 190, 50, 3, 2, 2, 2,
191, 192, 7, 126, 2, 2, 192, 196, 7, 126, 2, 2, 193, 194, 7, 113, 2, 2,
194, 196, 7, 116, 2, 2, 195, 191, 3, 2, 2, 2, 195, 193, 3, 2, 2, 2, 196,
52, 3, 2, 2, 2, 197, 198, 7, 128, 2, 2, 198, 54, 3, 2, 2, 2, 199, 204,
7, 35, 2, 2, 200, 201, 7, 112, 2, 2, 201, 202, 7, 113, 2, 2, 202, 204,
7, 118, 2, 2, 203, 199, 3, 2, 2, 2, 203, 200, 3, 2, 2, 2, 204, 56, 3, 2,
2, 2, 205, 206, 7, 107, 2, 2, 206, 207, 7, 112, 2, 2, 207, 58, 3, 2, 2,
2, 208, 209, 7, 112, 2, 2, 209, 210, 7, 113, 2, 2, 210, 211, 7, 118, 2,
2, 211, 212, 7, 34, 2, 2, 212, 213, 7, 107, 2, 2, 213, 214, 7, 112, 2,
2, 214, 60, 3, 2, 2, 2, 215, 220, 7, 93, 2, 2, 216, 219, 5, 119, 60, 2,
217, 219, 5, 121, 61, 2, 218, 216, 3, 2, 2, 2, 218, 217, 3, 2, 2, 2, 219,
222, 3, 2, 2, 2, 220, 218, 3, 2, 2, 2, 220, 221, 3, 2, 2, 2, 221, 223,
3, 2, 2, 2, 222, 220, 3, 2, 2, 2, 223, 224, 7, 95, 2, 2, 224, 62, 3, 2,
2, 2, 225, 226, 7, 118, 2, 2, 226, 227, 7, 116, 2, 2, 227, 228, 7, 119,
2, 2, 228, 253, 7, 103, 2, 2, 229, 230, 7, 86, 2, 2, 230, 231, 7, 116,
2, 2, 231, 232, 7, 119, 2, 2, 232, 253, 7, 103, 2, 2, 233, 234, 7, 86,
2, 2, 234, 235, 7, 84, 2, 2, 235, 236, 7, 87, 2, 2, 236, 253, 7, 71, 2,
2, 237, 238, 7, 104, 2, 2, 238, 239, 7, 99, 2, 2, 239, 240, 7, 110, 2,
2, 240, 241, 7, 117, 2, 2, 241, 253, 7, 103, 2, 2, 242, 243, 7, 72, 2,
2, 243, 244, 7, 99, 2, 2, 244, 245, 7, 110, 2, 2, 245, 246, 7, 117, 2,
2, 246, 253, 7, 103, 2, 2, 247, 248, 7, 72, 2, 2, 248, 249, 7, 67, 2, 2,
249, 250, 7, 78, 2, 2, 250, 251, 7, 85, 2, 2, 251, 253, 7, 71, 2, 2, 252,
225, 3, 2, 2, 2, 252, 229, 3, 2, 2, 2, 252, 233, 3, 2, 2, 2, 252, 237,
3, 2, 2, 2, 252, 242, 3, 2, 2, 2, 252, 247, 3, 2, 2, 2, 253, 64, 3, 2,
2, 2, 254, 259, 5, 85, 43, 2, 255, 259, 5, 87, 44, 2, 256, 259, 5, 89,
45, 2, 257, 259, 5, 83, 42, 2, 258, 254, 3, 2, 2, 2, 258, 255, 3, 2, 2,
2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2, 259, 66, 3, 2, 2, 2, 260,
263, 5, 101, 51, 2, 261, 263, 5, 103, 52, 2, 262, 260, 3, 2, 2, 2, 262,
261, 3, 2, 2, 2, 263, 68, 3, 2, 2, 2, 264, 269, 5, 79, 40, 2, 265, 268,
5, 79, 40, 2, 266, 268, 5, 81, 41, 2, 267, 265, 3, 2, 2, 2, 267, 266, 3,
2, 2, 2, 268, 271, 3, 2, 2, 2, 269, 267, 3, 2, 2, 2, 269, 270, 3, 2, 2,
2, 270, 70, 3, 2, 2, 2, 271, 269, 3, 2, 2, 2, 272, 274, 5, 73, 37, 2, 273,
272, 3, 2, 2, 2, 273, 274, 3, 2, 2, 2, 274, 275, 3, 2, 2, 2, 275, 277,
7, 36, 2, 2, 276, 278, 5, 75, 38, 2, 277, 276, 3, 2, 2, 2, 277, 278, 3,
2, 2, 2, 278, 279, 3, 2, 2, 2, 279, 280, 7, 36, 2, 2, 280, 72, 3, 2, 2,
2, 281, 282, 7, 119, 2, 2, 282, 285, 7, 58, 2, 2, 283, 285, 9, 2, 2, 2,
284, 281, 3, 2, 2, 2, 284, 283, 3, 2, 2, 2, 285, 74, 3, 2, 2, 2, 286, 288,
5, 77, 39, 2, 287, 286, 3, 2, 2, 2, 288, 289, 3, 2, 2, 2, 289, 287, 3,
2, 2, 2, 289, 290, 3, 2, 2, 2, 290, 76, 3, 2, 2, 2, 291, 299, 10, 3, 2,
2, 292, 299, 5, 117, 59, 2, 293, 294, 7, 94, 2, 2, 294, 299, 7, 12, 2,
2, 295, 296, 7, 94, 2, 2, 296, 297, 7, 15, 2, 2, 297, 299, 7, 12, 2, 2,
298, 291, 3, 2, 2, 2, 298, 292, 3, 2, 2, 2, 298, 293, 3, 2, 2, 2, 298,
295, 3, 2, 2, 2, 299, 78, 3, 2, 2, 2, 300, 301, 9, 4, 2, 2, 301, 80, 3,
2, 2, 2, 302, 303, 9, 5, 2, 2, 303, 82, 3, 2, 2, 2, 304, 305, 7, 50, 2,
2, 305, 307, 9, 6, 2, 2, 306, 308, 9, 7, 2, 2, 307, 306, 3, 2, 2, 2, 308,
309, 3, 2, 2, 2, 309, 307, 3, 2, 2, 2, 309, 310, 3, 2, 2, 2, 310, 84, 3,
2, 2, 2, 311, 315, 5, 91, 46, 2, 312, 314, 5, 81, 41, 2, 313, 312, 3, 2,
2, 2, 314, 317, 3, 2, 2, 2, 315, 313, 3, 2, 2, 2, 315, 316, 3, 2, 2, 2,
316, 86, 3, 2, 2, 2, 317, 315, 3, 2, 2, 2, 318, 322, 7, 50, 2, 2, 319,
321, 5, 93, 47, 2, 320, 319, 3, 2, 2, 2, 321, 324, 3, 2, 2, 2, 322, 320,
3, 2, 2, 2, 322, 323, 3, 2, 2, 2, 323, 88, 3, 2, 2, 2, 324, 322, 3, 2,
2, 2, 325, 326, 7, 50, 2, 2, 326, 327, 9, 8, 2, 2, 327, 328, 5, 113, 57,
2, 328, 90, 3, 2, 2, 2, 329, 330, 9, 9, 2, 2, 330, 92, 3, 2, 2, 2, 331,
332, 9, 10, 2, 2, 332, 94, 3, 2, 2, 2, 333, 334, 9, 11, 2, 2, 334, 96,
3, 2, 2, 2, 335, 336, 5, 95, 48, 2, 336, 337, 5, 95, 48, 2, 337, 338, 5,
95, 48, 2, 338, 339, 5, 95, 48, 2, 339, 98, 3, 2, 2, 2, 340, 341, 7, 94,
2, 2, 341, 342, 7, 119, 2, 2, 342, 343, 3, 2, 2, 2, 343, 351, 5, 97, 49,
2, 344, 345, 7, 94, 2, 2, 345, 346, 7, 87, 2, 2, 346, 347, 3, 2, 2, 2,
347, 348, 5, 97, 49, 2, 348, 349, 5, 97, 49, 2, 349, 351, 3, 2, 2, 2, 350,
340, 3, 2, 2, 2, 350, 344, 3, 2, 2, 2, 351, 100, 3, 2, 2, 2, 352, 354,
5, 105, 53, 2, 353, 355, 5, 107, 54, 2, 354, 353, 3, 2, 2, 2, 354, 355,
3, 2, 2, 2, 355, 360, 3, 2, 2, 2, 356, 357, 5, 109, 55, 2, 357, 358, 5,
107, 54, 2, 358, 360, 3, 2, 2, 2, 359, 352, 3, 2, 2, 2, 359, 356, 3, 2,
2, 2, 360, 102, 3, 2, 2, 2, 361, 362, 7, 50, 2, 2, 362, 365, 9, 8, 2, 2,
363, 366, 5, 111, 56, 2, 364, 366, 5, 113, 57, 2, 365, 363, 3, 2, 2, 2,
365, 364, 3, 2, 2, 2, 366, 367, 3, 2, 2, 2, 367, 368, 5, 115, 58, 2, 368,
104, 3, 2, 2, 2, 369, 371, 5, 109, 55, 2, 370, 369, 3, 2, 2, 2, 370, 371,
3, 2, 2, 2, 371, 372, 3, 2, 2, 2, 372, 373, 7, 48, 2, 2, 373, 378, 5, 109,
55, 2, 374, 375, 5, 109, 55, 2, 375, 376, 7, 48, 2, 2, 376, 378, 3, 2,
2, 2, 377, 370, 3, 2, 2, 2, 377, 374, 3, 2, 2, 2, 378, 106, 3, 2, 2, 2,
379, 381, 9, 12, 2, 2, 380, 382, 9, 13, 2, 2, 381, 380, 3, 2, 2, 2, 381,
382, 3, 2, 2, 2, 382, 383, 3, 2, 2, 2, 383, 384, 5, 109, 55, 2, 384, 108,
3, 2, 2, 2, 385, 387, 5, 81, 41, 2, 386, 385, 3, 2, 2, 2, 387, 388, 3,
2, 2, 2, 388, 386, 3, 2, 2, 2, 388, 389, 3, 2, 2, 2, 389, 110, 3, 2, 2,
2, 390, 392, 5, 113, 57, 2, 391, 390, 3, 2, 2, 2, 391, 392, 3, 2, 2, 2,
392, 393, 3, 2, 2, 2, 393, 394, 7, 48, 2, 2, 394, 399, 5, 113, 57, 2, 395,
396, 5, 113, 57, 2, 396, 397, 7, 48, 2, 2, 397, 399, 3, 2, 2, 2, 398, 391,
3, 2, 2, 2, 398, 395, 3, 2, 2, 2, 399, 112, 3, 2, 2, 2, 400, 402, 5, 95,
48, 2, 401, 400, 3, 2, 2, 2, 402, 403, 3, 2, 2, 2, 403, 401, 3, 2, 2, 2,
403, 404, 3, 2, 2, 2, 404, 114, 3, 2, 2, 2, 405, 407, 9, 14, 2, 2, 406,
408, 9, 13, 2, 2, 407, 406, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 409,
3, 2, 2, 2, 409, 410, 5, 109, 55, 2, 410, 116, 3, 2, 2, 2, 411, 412, 7,
94, 2, 2, 412, 427, 9, 15, 2, 2, 413, 414, 7, 94, 2, 2, 414, 416, 5, 93,
47, 2, 415, 417, 5, 93, 47, 2, 416, 415, 3, 2, 2, 2, 416, 417, 3, 2, 2,
2, 417, 419, 3, 2, 2, 2, 418, 420, 5, 93, 47, 2, 419, 418, 3, 2, 2, 2,
419, 420, 3, 2, 2, 2, 420, 427, 3, 2, 2, 2, 421, 422, 7, 94, 2, 2, 422,
423, 7, 122, 2, 2, 423, 424, 3, 2, 2, 2, 424, 427, 5, 113, 57, 2, 425,
427, 5, 99, 50, 2, 426, 411, 3, 2, 2, 2, 426, 413, 3, 2, 2, 2, 426, 421,
3, 2, 2, 2, 426, 425, 3, 2, 2, 2, 427, 118, 3, 2, 2, 2, 428, 430, 9, 16,
2, 2, 429, 428, 3, 2, 2, 2, 430, 431, 3, 2, 2, 2, 431, 429, 3, 2, 2, 2,
431, 432, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 434, 8, 60, 2, 2, 434,
120, 3, 2, 2, 2, 435, 437, 7, 15, 2, 2, 436, 438, 7, 12, 2, 2, 437, 436,
3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 441, 3, 2, 2, 2, 439, 441, 7, 12,
2, 2, 440, 435, 3, 2, 2, 2, 440, 439, 3, 2, 2, 2, 441, 442, 3, 2, 2, 2,
442, 443, 8, 61, 2, 2, 443, 122, 3, 2, 2, 2, 40, 2, 157, 189, 195, 203,
218, 220, 252, 258, 262, 267, 269, 273, 277, 284, 289, 298, 309, 315, 322,
350, 354, 359, 365, 370, 377, 381, 388, 391, 398, 403, 407, 416, 419, 426,
431, 437, 440, 3, 8, 2, 2,
60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3,
4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3,
10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13,
3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 160, 10, 13, 3, 14, 3,
14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 168, 10, 14, 3, 15, 3, 15, 3, 16,
3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3,
21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 3, 24, 3, 25,
3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 5, 26, 200, 10, 26, 3, 27, 3,
27, 3, 27, 3, 27, 5, 27, 206, 10, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29,
3, 29, 5, 29, 214, 10, 29, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3,
31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 7, 32, 229, 10, 32, 12, 32,
14, 32, 232, 11, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3,
33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33,
3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3,
33, 5, 33, 263, 10, 33, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 269, 10, 34,
3, 35, 3, 35, 5, 35, 273, 10, 35, 3, 36, 3, 36, 3, 36, 7, 36, 278, 10,
36, 12, 36, 14, 36, 281, 11, 36, 3, 37, 5, 37, 284, 10, 37, 3, 37, 3, 37,
5, 37, 288, 10, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 5, 38, 295, 10,
38, 3, 39, 6, 39, 298, 10, 39, 13, 39, 14, 39, 299, 3, 40, 3, 40, 3, 40,
3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 309, 10, 40, 3, 41, 3, 41, 3, 42, 3,
42, 3, 43, 3, 43, 3, 43, 6, 43, 318, 10, 43, 13, 43, 14, 43, 319, 3, 44,
3, 44, 7, 44, 324, 10, 44, 12, 44, 14, 44, 327, 11, 44, 3, 45, 3, 45, 7,
45, 331, 10, 45, 12, 45, 14, 45, 334, 11, 45, 3, 46, 3, 46, 3, 46, 3, 46,
3, 47, 3, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3,
50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51,
5, 51, 361, 10, 51, 3, 52, 3, 52, 5, 52, 365, 10, 52, 3, 52, 3, 52, 3,
52, 5, 52, 370, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 376, 10, 53,
3, 53, 3, 53, 3, 54, 5, 54, 381, 10, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3,
54, 5, 54, 388, 10, 54, 3, 55, 3, 55, 5, 55, 392, 10, 55, 3, 55, 3, 55,
3, 56, 6, 56, 397, 10, 56, 13, 56, 14, 56, 398, 3, 57, 5, 57, 402, 10,
57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 5, 57, 409, 10, 57, 3, 58, 6, 58,
412, 10, 58, 13, 58, 14, 58, 413, 3, 59, 3, 59, 5, 59, 418, 10, 59, 3,
59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 427, 10, 60, 3, 60,
5, 60, 430, 10, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 437, 10,
60, 3, 61, 6, 61, 440, 10, 61, 13, 61, 14, 61, 441, 3, 61, 3, 61, 3, 62,
3, 62, 5, 62, 448, 10, 62, 3, 62, 5, 62, 451, 10, 62, 3, 62, 3, 62, 2,
2, 63, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21,
12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39,
21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57,
30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75,
2, 77, 2, 79, 2, 81, 2, 83, 2, 85, 2, 87, 2, 89, 2, 91, 2, 93, 2, 95, 2,
97, 2, 99, 2, 101, 2, 103, 2, 105, 2, 107, 2, 109, 2, 111, 2, 113, 2, 115,
2, 117, 2, 119, 2, 121, 39, 123, 40, 3, 2, 17, 5, 2, 78, 78, 87, 87, 119,
119, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 5, 2, 67, 92, 97, 97, 99, 124,
3, 2, 50, 59, 4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 4, 2, 90, 90, 122,
122, 3, 2, 51, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 71,
71, 103, 103, 4, 2, 45, 45, 47, 47, 4, 2, 82, 82, 114, 114, 12, 2, 36,
36, 41, 41, 65, 65, 94, 94, 99, 100, 104, 104, 112, 112, 116, 116, 118,
118, 120, 120, 4, 2, 11, 11, 34, 34, 2, 478, 2, 3, 3, 2, 2, 2, 2, 5, 3,
2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13,
3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2,
21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2,
2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2,
2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2,
2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3,
2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59,
3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2,
67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2,
2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 3, 125, 3, 2, 2, 2, 5, 127, 3,
2, 2, 2, 7, 129, 3, 2, 2, 2, 9, 131, 3, 2, 2, 2, 11, 133, 3, 2, 2, 2, 13,
135, 3, 2, 2, 2, 15, 137, 3, 2, 2, 2, 17, 140, 3, 2, 2, 2, 19, 142, 3,
2, 2, 2, 21, 145, 3, 2, 2, 2, 23, 148, 3, 2, 2, 2, 25, 159, 3, 2, 2, 2,
27, 167, 3, 2, 2, 2, 29, 169, 3, 2, 2, 2, 31, 171, 3, 2, 2, 2, 33, 173,
3, 2, 2, 2, 35, 175, 3, 2, 2, 2, 37, 177, 3, 2, 2, 2, 39, 179, 3, 2, 2,
2, 41, 182, 3, 2, 2, 2, 43, 185, 3, 2, 2, 2, 45, 188, 3, 2, 2, 2, 47, 190,
3, 2, 2, 2, 49, 192, 3, 2, 2, 2, 51, 199, 3, 2, 2, 2, 53, 205, 3, 2, 2,
2, 55, 207, 3, 2, 2, 2, 57, 213, 3, 2, 2, 2, 59, 215, 3, 2, 2, 2, 61, 218,
3, 2, 2, 2, 63, 225, 3, 2, 2, 2, 65, 262, 3, 2, 2, 2, 67, 268, 3, 2, 2,
2, 69, 272, 3, 2, 2, 2, 71, 274, 3, 2, 2, 2, 73, 283, 3, 2, 2, 2, 75, 294,
3, 2, 2, 2, 77, 297, 3, 2, 2, 2, 79, 308, 3, 2, 2, 2, 81, 310, 3, 2, 2,
2, 83, 312, 3, 2, 2, 2, 85, 314, 3, 2, 2, 2, 87, 321, 3, 2, 2, 2, 89, 328,
3, 2, 2, 2, 91, 335, 3, 2, 2, 2, 93, 339, 3, 2, 2, 2, 95, 341, 3, 2, 2,
2, 97, 343, 3, 2, 2, 2, 99, 345, 3, 2, 2, 2, 101, 360, 3, 2, 2, 2, 103,
369, 3, 2, 2, 2, 105, 371, 3, 2, 2, 2, 107, 387, 3, 2, 2, 2, 109, 389,
3, 2, 2, 2, 111, 396, 3, 2, 2, 2, 113, 408, 3, 2, 2, 2, 115, 411, 3, 2,
2, 2, 117, 415, 3, 2, 2, 2, 119, 436, 3, 2, 2, 2, 121, 439, 3, 2, 2, 2,
123, 450, 3, 2, 2, 2, 125, 126, 7, 42, 2, 2, 126, 4, 3, 2, 2, 2, 127, 128,
7, 43, 2, 2, 128, 6, 3, 2, 2, 2, 129, 130, 7, 93, 2, 2, 130, 8, 3, 2, 2,
2, 131, 132, 7, 46, 2, 2, 132, 10, 3, 2, 2, 2, 133, 134, 7, 95, 2, 2, 134,
12, 3, 2, 2, 2, 135, 136, 7, 62, 2, 2, 136, 14, 3, 2, 2, 2, 137, 138, 7,
62, 2, 2, 138, 139, 7, 63, 2, 2, 139, 16, 3, 2, 2, 2, 140, 141, 7, 64,
2, 2, 141, 18, 3, 2, 2, 2, 142, 143, 7, 64, 2, 2, 143, 144, 7, 63, 2, 2,
144, 20, 3, 2, 2, 2, 145, 146, 7, 63, 2, 2, 146, 147, 7, 63, 2, 2, 147,
22, 3, 2, 2, 2, 148, 149, 7, 35, 2, 2, 149, 150, 7, 63, 2, 2, 150, 24,
3, 2, 2, 2, 151, 152, 7, 110, 2, 2, 152, 153, 7, 107, 2, 2, 153, 154, 7,
109, 2, 2, 154, 160, 7, 103, 2, 2, 155, 156, 7, 78, 2, 2, 156, 157, 7,
75, 2, 2, 157, 158, 7, 77, 2, 2, 158, 160, 7, 71, 2, 2, 159, 151, 3, 2,
2, 2, 159, 155, 3, 2, 2, 2, 160, 26, 3, 2, 2, 2, 161, 162, 7, 119, 2, 2,
162, 163, 7, 102, 2, 2, 163, 168, 7, 104, 2, 2, 164, 165, 7, 87, 2, 2,
165, 166, 7, 70, 2, 2, 166, 168, 7, 72, 2, 2, 167, 161, 3, 2, 2, 2, 167,
164, 3, 2, 2, 2, 168, 28, 3, 2, 2, 2, 169, 170, 7, 45, 2, 2, 170, 30, 3,
2, 2, 2, 171, 172, 7, 47, 2, 2, 172, 32, 3, 2, 2, 2, 173, 174, 7, 44, 2,
2, 174, 34, 3, 2, 2, 2, 175, 176, 7, 49, 2, 2, 176, 36, 3, 2, 2, 2, 177,
178, 7, 39, 2, 2, 178, 38, 3, 2, 2, 2, 179, 180, 7, 44, 2, 2, 180, 181,
7, 44, 2, 2, 181, 40, 3, 2, 2, 2, 182, 183, 7, 62, 2, 2, 183, 184, 7, 62,
2, 2, 184, 42, 3, 2, 2, 2, 185, 186, 7, 64, 2, 2, 186, 187, 7, 64, 2, 2,
187, 44, 3, 2, 2, 2, 188, 189, 7, 40, 2, 2, 189, 46, 3, 2, 2, 2, 190, 191,
7, 126, 2, 2, 191, 48, 3, 2, 2, 2, 192, 193, 7, 96, 2, 2, 193, 50, 3, 2,
2, 2, 194, 195, 7, 40, 2, 2, 195, 200, 7, 40, 2, 2, 196, 197, 7, 99, 2,
2, 197, 198, 7, 112, 2, 2, 198, 200, 7, 102, 2, 2, 199, 194, 3, 2, 2, 2,
199, 196, 3, 2, 2, 2, 200, 52, 3, 2, 2, 2, 201, 202, 7, 126, 2, 2, 202,
206, 7, 126, 2, 2, 203, 204, 7, 113, 2, 2, 204, 206, 7, 116, 2, 2, 205,
201, 3, 2, 2, 2, 205, 203, 3, 2, 2, 2, 206, 54, 3, 2, 2, 2, 207, 208, 7,
128, 2, 2, 208, 56, 3, 2, 2, 2, 209, 214, 7, 35, 2, 2, 210, 211, 7, 112,
2, 2, 211, 212, 7, 113, 2, 2, 212, 214, 7, 118, 2, 2, 213, 209, 3, 2, 2,
2, 213, 210, 3, 2, 2, 2, 214, 58, 3, 2, 2, 2, 215, 216, 7, 107, 2, 2, 216,
217, 7, 112, 2, 2, 217, 60, 3, 2, 2, 2, 218, 219, 7, 112, 2, 2, 219, 220,
7, 113, 2, 2, 220, 221, 7, 118, 2, 2, 221, 222, 7, 34, 2, 2, 222, 223,
7, 107, 2, 2, 223, 224, 7, 112, 2, 2, 224, 62, 3, 2, 2, 2, 225, 230, 7,
93, 2, 2, 226, 229, 5, 121, 61, 2, 227, 229, 5, 123, 62, 2, 228, 226, 3,
2, 2, 2, 228, 227, 3, 2, 2, 2, 229, 232, 3, 2, 2, 2, 230, 228, 3, 2, 2,
2, 230, 231, 3, 2, 2, 2, 231, 233, 3, 2, 2, 2, 232, 230, 3, 2, 2, 2, 233,
234, 7, 95, 2, 2, 234, 64, 3, 2, 2, 2, 235, 236, 7, 118, 2, 2, 236, 237,
7, 116, 2, 2, 237, 238, 7, 119, 2, 2, 238, 263, 7, 103, 2, 2, 239, 240,
7, 86, 2, 2, 240, 241, 7, 116, 2, 2, 241, 242, 7, 119, 2, 2, 242, 263,
7, 103, 2, 2, 243, 244, 7, 86, 2, 2, 244, 245, 7, 84, 2, 2, 245, 246, 7,
87, 2, 2, 246, 263, 7, 71, 2, 2, 247, 248, 7, 104, 2, 2, 248, 249, 7, 99,
2, 2, 249, 250, 7, 110, 2, 2, 250, 251, 7, 117, 2, 2, 251, 263, 7, 103,
2, 2, 252, 253, 7, 72, 2, 2, 253, 254, 7, 99, 2, 2, 254, 255, 7, 110, 2,
2, 255, 256, 7, 117, 2, 2, 256, 263, 7, 103, 2, 2, 257, 258, 7, 72, 2,
2, 258, 259, 7, 67, 2, 2, 259, 260, 7, 78, 2, 2, 260, 261, 7, 85, 2, 2,
261, 263, 7, 71, 2, 2, 262, 235, 3, 2, 2, 2, 262, 239, 3, 2, 2, 2, 262,
243, 3, 2, 2, 2, 262, 247, 3, 2, 2, 2, 262, 252, 3, 2, 2, 2, 262, 257,
3, 2, 2, 2, 263, 66, 3, 2, 2, 2, 264, 269, 5, 87, 44, 2, 265, 269, 5, 89,
45, 2, 266, 269, 5, 91, 46, 2, 267, 269, 5, 85, 43, 2, 268, 264, 3, 2,
2, 2, 268, 265, 3, 2, 2, 2, 268, 266, 3, 2, 2, 2, 268, 267, 3, 2, 2, 2,
269, 68, 3, 2, 2, 2, 270, 273, 5, 103, 52, 2, 271, 273, 5, 105, 53, 2,
272, 270, 3, 2, 2, 2, 272, 271, 3, 2, 2, 2, 273, 70, 3, 2, 2, 2, 274, 279,
5, 81, 41, 2, 275, 278, 5, 81, 41, 2, 276, 278, 5, 83, 42, 2, 277, 275,
3, 2, 2, 2, 277, 276, 3, 2, 2, 2, 278, 281, 3, 2, 2, 2, 279, 277, 3, 2,
2, 2, 279, 280, 3, 2, 2, 2, 280, 72, 3, 2, 2, 2, 281, 279, 3, 2, 2, 2,
282, 284, 5, 75, 38, 2, 283, 282, 3, 2, 2, 2, 283, 284, 3, 2, 2, 2, 284,
285, 3, 2, 2, 2, 285, 287, 7, 36, 2, 2, 286, 288, 5, 77, 39, 2, 287, 286,
3, 2, 2, 2, 287, 288, 3, 2, 2, 2, 288, 289, 3, 2, 2, 2, 289, 290, 7, 36,
2, 2, 290, 74, 3, 2, 2, 2, 291, 292, 7, 119, 2, 2, 292, 295, 7, 58, 2,
2, 293, 295, 9, 2, 2, 2, 294, 291, 3, 2, 2, 2, 294, 293, 3, 2, 2, 2, 295,
76, 3, 2, 2, 2, 296, 298, 5, 79, 40, 2, 297, 296, 3, 2, 2, 2, 298, 299,
3, 2, 2, 2, 299, 297, 3, 2, 2, 2, 299, 300, 3, 2, 2, 2, 300, 78, 3, 2,
2, 2, 301, 309, 10, 3, 2, 2, 302, 309, 5, 119, 60, 2, 303, 304, 7, 94,
2, 2, 304, 309, 7, 12, 2, 2, 305, 306, 7, 94, 2, 2, 306, 307, 7, 15, 2,
2, 307, 309, 7, 12, 2, 2, 308, 301, 3, 2, 2, 2, 308, 302, 3, 2, 2, 2, 308,
303, 3, 2, 2, 2, 308, 305, 3, 2, 2, 2, 309, 80, 3, 2, 2, 2, 310, 311, 9,
4, 2, 2, 311, 82, 3, 2, 2, 2, 312, 313, 9, 5, 2, 2, 313, 84, 3, 2, 2, 2,
314, 315, 7, 50, 2, 2, 315, 317, 9, 6, 2, 2, 316, 318, 9, 7, 2, 2, 317,
316, 3, 2, 2, 2, 318, 319, 3, 2, 2, 2, 319, 317, 3, 2, 2, 2, 319, 320,
3, 2, 2, 2, 320, 86, 3, 2, 2, 2, 321, 325, 5, 93, 47, 2, 322, 324, 5, 83,
42, 2, 323, 322, 3, 2, 2, 2, 324, 327, 3, 2, 2, 2, 325, 323, 3, 2, 2, 2,
325, 326, 3, 2, 2, 2, 326, 88, 3, 2, 2, 2, 327, 325, 3, 2, 2, 2, 328, 332,
7, 50, 2, 2, 329, 331, 5, 95, 48, 2, 330, 329, 3, 2, 2, 2, 331, 334, 3,
2, 2, 2, 332, 330, 3, 2, 2, 2, 332, 333, 3, 2, 2, 2, 333, 90, 3, 2, 2,
2, 334, 332, 3, 2, 2, 2, 335, 336, 7, 50, 2, 2, 336, 337, 9, 8, 2, 2, 337,
338, 5, 115, 58, 2, 338, 92, 3, 2, 2, 2, 339, 340, 9, 9, 2, 2, 340, 94,
3, 2, 2, 2, 341, 342, 9, 10, 2, 2, 342, 96, 3, 2, 2, 2, 343, 344, 9, 11,
2, 2, 344, 98, 3, 2, 2, 2, 345, 346, 5, 97, 49, 2, 346, 347, 5, 97, 49,
2, 347, 348, 5, 97, 49, 2, 348, 349, 5, 97, 49, 2, 349, 100, 3, 2, 2, 2,
350, 351, 7, 94, 2, 2, 351, 352, 7, 119, 2, 2, 352, 353, 3, 2, 2, 2, 353,
361, 5, 99, 50, 2, 354, 355, 7, 94, 2, 2, 355, 356, 7, 87, 2, 2, 356, 357,
3, 2, 2, 2, 357, 358, 5, 99, 50, 2, 358, 359, 5, 99, 50, 2, 359, 361, 3,
2, 2, 2, 360, 350, 3, 2, 2, 2, 360, 354, 3, 2, 2, 2, 361, 102, 3, 2, 2,
2, 362, 364, 5, 107, 54, 2, 363, 365, 5, 109, 55, 2, 364, 363, 3, 2, 2,
2, 364, 365, 3, 2, 2, 2, 365, 370, 3, 2, 2, 2, 366, 367, 5, 111, 56, 2,
367, 368, 5, 109, 55, 2, 368, 370, 3, 2, 2, 2, 369, 362, 3, 2, 2, 2, 369,
366, 3, 2, 2, 2, 370, 104, 3, 2, 2, 2, 371, 372, 7, 50, 2, 2, 372, 375,
9, 8, 2, 2, 373, 376, 5, 113, 57, 2, 374, 376, 5, 115, 58, 2, 375, 373,
3, 2, 2, 2, 375, 374, 3, 2, 2, 2, 376, 377, 3, 2, 2, 2, 377, 378, 5, 117,
59, 2, 378, 106, 3, 2, 2, 2, 379, 381, 5, 111, 56, 2, 380, 379, 3, 2, 2,
2, 380, 381, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 383, 7, 48, 2, 2, 383,
388, 5, 111, 56, 2, 384, 385, 5, 111, 56, 2, 385, 386, 7, 48, 2, 2, 386,
388, 3, 2, 2, 2, 387, 380, 3, 2, 2, 2, 387, 384, 3, 2, 2, 2, 388, 108,
3, 2, 2, 2, 389, 391, 9, 12, 2, 2, 390, 392, 9, 13, 2, 2, 391, 390, 3,
2, 2, 2, 391, 392, 3, 2, 2, 2, 392, 393, 3, 2, 2, 2, 393, 394, 5, 111,
56, 2, 394, 110, 3, 2, 2, 2, 395, 397, 5, 83, 42, 2, 396, 395, 3, 2, 2,
2, 397, 398, 3, 2, 2, 2, 398, 396, 3, 2, 2, 2, 398, 399, 3, 2, 2, 2, 399,
112, 3, 2, 2, 2, 400, 402, 5, 115, 58, 2, 401, 400, 3, 2, 2, 2, 401, 402,
3, 2, 2, 2, 402, 403, 3, 2, 2, 2, 403, 404, 7, 48, 2, 2, 404, 409, 5, 115,
58, 2, 405, 406, 5, 115, 58, 2, 406, 407, 7, 48, 2, 2, 407, 409, 3, 2,
2, 2, 408, 401, 3, 2, 2, 2, 408, 405, 3, 2, 2, 2, 409, 114, 3, 2, 2, 2,
410, 412, 5, 97, 49, 2, 411, 410, 3, 2, 2, 2, 412, 413, 3, 2, 2, 2, 413,
411, 3, 2, 2, 2, 413, 414, 3, 2, 2, 2, 414, 116, 3, 2, 2, 2, 415, 417,
9, 14, 2, 2, 416, 418, 9, 13, 2, 2, 417, 416, 3, 2, 2, 2, 417, 418, 3,
2, 2, 2, 418, 419, 3, 2, 2, 2, 419, 420, 5, 111, 56, 2, 420, 118, 3, 2,
2, 2, 421, 422, 7, 94, 2, 2, 422, 437, 9, 15, 2, 2, 423, 424, 7, 94, 2,
2, 424, 426, 5, 95, 48, 2, 425, 427, 5, 95, 48, 2, 426, 425, 3, 2, 2, 2,
426, 427, 3, 2, 2, 2, 427, 429, 3, 2, 2, 2, 428, 430, 5, 95, 48, 2, 429,
428, 3, 2, 2, 2, 429, 430, 3, 2, 2, 2, 430, 437, 3, 2, 2, 2, 431, 432,
7, 94, 2, 2, 432, 433, 7, 122, 2, 2, 433, 434, 3, 2, 2, 2, 434, 437, 5,
115, 58, 2, 435, 437, 5, 101, 51, 2, 436, 421, 3, 2, 2, 2, 436, 423, 3,
2, 2, 2, 436, 431, 3, 2, 2, 2, 436, 435, 3, 2, 2, 2, 437, 120, 3, 2, 2,
2, 438, 440, 9, 16, 2, 2, 439, 438, 3, 2, 2, 2, 440, 441, 3, 2, 2, 2, 441,
439, 3, 2, 2, 2, 441, 442, 3, 2, 2, 2, 442, 443, 3, 2, 2, 2, 443, 444,
8, 61, 2, 2, 444, 122, 3, 2, 2, 2, 445, 447, 7, 15, 2, 2, 446, 448, 7,
12, 2, 2, 447, 446, 3, 2, 2, 2, 447, 448, 3, 2, 2, 2, 448, 451, 3, 2, 2,
2, 449, 451, 7, 12, 2, 2, 450, 445, 3, 2, 2, 2, 450, 449, 3, 2, 2, 2, 451,
452, 3, 2, 2, 2, 452, 453, 8, 62, 2, 2, 453, 124, 3, 2, 2, 2, 41, 2, 159,
167, 199, 205, 213, 228, 230, 262, 268, 272, 277, 279, 283, 287, 294, 299,
308, 319, 325, 332, 360, 364, 369, 375, 380, 387, 391, 398, 401, 408, 413,
417, 426, 429, 436, 441, 447, 450, 3, 8, 2, 2,
}
var lexerChannelNames = []string{
@ -231,29 +235,29 @@ var lexerModeNames = []string{
var lexerLiteralNames = []string{
"", "'('", "')'", "'['", "','", "']'", "'<'", "'<='", "'>'", "'>='", "'=='",
"'!='", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'",
"'!='", "", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'",
"'&'", "'|'", "'^'", "", "", "'~'", "", "'in'", "'not in'",
}
var lexerSymbolicNames = []string{
"", "", "", "", "", "", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "ADD",
"SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR",
"AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "BooleanConstant",
"", "", "", "", "", "", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "UDF",
"ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR",
"BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "BooleanConstant",
"IntegerConstant", "FloatingConstant", "Identifier", "StringLiteral", "Whitespace",
"Newline",
}
var lexerRuleNames = []string{
"T__0", "T__1", "T__2", "T__3", "T__4", "LT", "LE", "GT", "GE", "EQ", "NE",
"LIKE", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND",
"BOR", "BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "BooleanConstant",
"IntegerConstant", "FloatingConstant", "Identifier", "StringLiteral", "EncodingPrefix",
"SCharSequence", "SChar", "Nondigit", "Digit", "BinaryConstant", "DecimalConstant",
"OctalConstant", "HexadecimalConstant", "NonzeroDigit", "OctalDigit", "HexadecimalDigit",
"HexQuad", "UniversalCharacterName", "DecimalFloatingConstant", "HexadecimalFloatingConstant",
"FractionalConstant", "ExponentPart", "DigitSequence", "HexadecimalFractionalConstant",
"HexadecimalDigitSequence", "BinaryExponentPart", "EscapeSequence", "Whitespace",
"Newline",
"LIKE", "UDF", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR",
"BAND", "BOR", "BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm",
"BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier",
"StringLiteral", "EncodingPrefix", "SCharSequence", "SChar", "Nondigit",
"Digit", "BinaryConstant", "DecimalConstant", "OctalConstant", "HexadecimalConstant",
"NonzeroDigit", "OctalDigit", "HexadecimalDigit", "HexQuad", "UniversalCharacterName",
"DecimalFloatingConstant", "HexadecimalFloatingConstant", "FractionalConstant",
"ExponentPart", "DigitSequence", "HexadecimalFractionalConstant", "HexadecimalDigitSequence",
"BinaryExponentPart", "EscapeSequence", "Whitespace", "Newline",
}
type PlanLexer struct {
@ -305,29 +309,30 @@ const (
PlanLexerEQ = 10
PlanLexerNE = 11
PlanLexerLIKE = 12
PlanLexerADD = 13
PlanLexerSUB = 14
PlanLexerMUL = 15
PlanLexerDIV = 16
PlanLexerMOD = 17
PlanLexerPOW = 18
PlanLexerSHL = 19
PlanLexerSHR = 20
PlanLexerBAND = 21
PlanLexerBOR = 22
PlanLexerBXOR = 23
PlanLexerAND = 24
PlanLexerOR = 25
PlanLexerBNOT = 26
PlanLexerNOT = 27
PlanLexerIN = 28
PlanLexerNIN = 29
PlanLexerEmptyTerm = 30
PlanLexerBooleanConstant = 31
PlanLexerIntegerConstant = 32
PlanLexerFloatingConstant = 33
PlanLexerIdentifier = 34
PlanLexerStringLiteral = 35
PlanLexerWhitespace = 36
PlanLexerNewline = 37
PlanLexerUDF = 13
PlanLexerADD = 14
PlanLexerSUB = 15
PlanLexerMUL = 16
PlanLexerDIV = 17
PlanLexerMOD = 18
PlanLexerPOW = 19
PlanLexerSHL = 20
PlanLexerSHR = 21
PlanLexerBAND = 22
PlanLexerBOR = 23
PlanLexerBXOR = 24
PlanLexerAND = 25
PlanLexerOR = 26
PlanLexerBNOT = 27
PlanLexerNOT = 28
PlanLexerIN = 29
PlanLexerNIN = 30
PlanLexerEmptyTerm = 31
PlanLexerBooleanConstant = 32
PlanLexerIntegerConstant = 33
PlanLexerFloatingConstant = 34
PlanLexerIdentifier = 35
PlanLexerStringLiteral = 36
PlanLexerWhitespace = 37
PlanLexerNewline = 38
)

409
internal/parser/planparserv2/generated/plan_parser.go
View File

@ -15,58 +15,66 @@ var _ = reflect.Copy
var _ = strconv.Itoa
var parserATN = []uint16{
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 39, 89, 4,
2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 5, 2, 17, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 71, 10, 2, 12,
2, 14, 2, 74, 11, 2, 3, 2, 5, 2, 77, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 7, 2, 84, 10, 2, 12, 2, 14, 2, 87, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 11,
4, 2, 15, 16, 28, 29, 3, 2, 17, 19, 3, 2, 15, 16, 3, 2, 21, 22, 3, 2, 8,
9, 3, 2, 10, 11, 3, 2, 8, 11, 3, 2, 12, 13, 3, 2, 30, 31, 2, 111, 2, 16,
3, 2, 2, 2, 4, 5, 8, 2, 1, 2, 5, 17, 7, 34, 2, 2, 6, 17, 7, 35, 2, 2, 7,
17, 7, 33, 2, 2, 8, 17, 7, 37, 2, 2, 9, 17, 7, 36, 2, 2, 10, 11, 7, 3,
2, 2, 11, 12, 5, 2, 2, 2, 12, 13, 7, 4, 2, 2, 13, 17, 3, 2, 2, 2, 14, 15,
9, 2, 2, 2, 15, 17, 5, 2, 2, 17, 16, 4, 3, 2, 2, 2, 16, 6, 3, 2, 2, 2,
16, 7, 3, 2, 2, 2, 16, 8, 3, 2, 2, 2, 16, 9, 3, 2, 2, 2, 16, 10, 3, 2,
2, 2, 16, 14, 3, 2, 2, 2, 17, 85, 3, 2, 2, 2, 18, 19, 12, 18, 2, 2, 19,
20, 7, 20, 2, 2, 20, 84, 5, 2, 2, 19, 21, 22, 12, 16, 2, 2, 22, 23, 9,
3, 2, 2, 23, 84, 5, 2, 2, 17, 24, 25, 12, 15, 2, 2, 25, 26, 9, 4, 2, 2,
26, 84, 5, 2, 2, 16, 27, 28, 12, 14, 2, 2, 28, 29, 9, 5, 2, 2, 29, 84,
5, 2, 2, 15, 30, 31, 12, 11, 2, 2, 31, 32, 9, 6, 2, 2, 32, 33, 7, 36, 2,
2, 33, 34, 9, 6, 2, 2, 34, 84, 5, 2, 2, 12, 35, 36, 12, 10, 2, 2, 36, 37,
9, 7, 2, 2, 37, 38, 7, 36, 2, 2, 38, 39, 9, 7, 2, 2, 39, 84, 5, 2, 2, 11,
40, 41, 12, 9, 2, 2, 41, 42, 9, 8, 2, 2, 42, 84, 5, 2, 2, 10, 43, 44, 12,
8, 2, 2, 44, 45, 9, 9, 2, 2, 45, 84, 5, 2, 2, 9, 46, 47, 12, 7, 2, 2, 47,
48, 7, 23, 2, 2, 48, 84, 5, 2, 2, 8, 49, 50, 12, 6, 2, 2, 50, 51, 7, 25,
2, 2, 51, 84, 5, 2, 2, 7, 52, 53, 12, 5, 2, 2, 53, 54, 7, 24, 2, 2, 54,
84, 5, 2, 2, 6, 55, 56, 12, 4, 2, 2, 56, 57, 7, 26, 2, 2, 57, 84, 5, 2,
2, 5, 58, 59, 12, 3, 2, 2, 59, 60, 7, 27, 2, 2, 60, 84, 5, 2, 2, 4, 61,
62, 12, 19, 2, 2, 62, 63, 7, 14, 2, 2, 63, 84, 7, 37, 2, 2, 64, 65, 12,
13, 2, 2, 65, 66, 9, 10, 2, 2, 66, 67, 7, 5, 2, 2, 67, 72, 5, 2, 2, 2,
68, 69, 7, 6, 2, 2, 69, 71, 5, 2, 2, 2, 70, 68, 3, 2, 2, 2, 71, 74, 3,
2, 2, 2, 72, 70, 3, 2, 2, 2, 72, 73, 3, 2, 2, 2, 73, 76, 3, 2, 2, 2, 74,
72, 3, 2, 2, 2, 75, 77, 7, 6, 2, 2, 76, 75, 3, 2, 2, 2, 76, 77, 3, 2, 2,
2, 77, 78, 3, 2, 2, 2, 78, 79, 7, 7, 2, 2, 79, 84, 3, 2, 2, 2, 80, 81,
12, 12, 2, 2, 81, 82, 9, 10, 2, 2, 82, 84, 7, 32, 2, 2, 83, 18, 3, 2, 2,
2, 83, 21, 3, 2, 2, 2, 83, 24, 3, 2, 2, 2, 83, 27, 3, 2, 2, 2, 83, 30,
3, 2, 2, 2, 83, 35, 3, 2, 2, 2, 83, 40, 3, 2, 2, 2, 83, 43, 3, 2, 2, 2,
83, 46, 3, 2, 2, 2, 83, 49, 3, 2, 2, 2, 83, 52, 3, 2, 2, 2, 83, 55, 3,
2, 2, 2, 83, 58, 3, 2, 2, 2, 83, 61, 3, 2, 2, 2, 83, 64, 3, 2, 2, 2, 83,
80, 3, 2, 2, 2, 84, 87, 3, 2, 2, 2, 85, 83, 3, 2, 2, 2, 85, 86, 3, 2, 2,
2, 86, 3, 3, 2, 2, 2, 87, 85, 3, 2, 2, 2, 7, 16, 72, 76, 83, 85,
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 40, 105,
4, 2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 21, 10, 2, 12, 2, 14, 2, 24,
11, 2, 3, 2, 5, 2, 27, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 33, 10, 2,
3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2,
3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 87, 10, 2, 12, 2, 14, 2, 90, 11, 2, 3, 2,
5, 2, 93, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 100, 10, 2, 12, 2,
14, 2, 103, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 11, 4, 2, 16, 17, 29, 30, 3,
2, 18, 20, 3, 2, 16, 17, 3, 2, 22, 23, 3, 2, 8, 9, 3, 2, 10, 11, 3, 2,
8, 11, 3, 2, 12, 13, 3, 2, 31, 32, 2, 130, 2, 32, 3, 2, 2, 2, 4, 5, 8,
2, 1, 2, 5, 33, 7, 35, 2, 2, 6, 33, 7, 36, 2, 2, 7, 33, 7, 34, 2, 2, 8,
33, 7, 38, 2, 2, 9, 33, 7, 37, 2, 2, 10, 11, 7, 3, 2, 2, 11, 12, 5, 2,
2, 2, 12, 13, 7, 4, 2, 2, 13, 33, 3, 2, 2, 2, 14, 15, 7, 15, 2, 2, 15,
16, 7, 38, 2, 2, 16, 17, 7, 5, 2, 2, 17, 22, 5, 2, 2, 2, 18, 19, 7, 6,
2, 2, 19, 21, 5, 2, 2, 2, 20, 18, 3, 2, 2, 2, 21, 24, 3, 2, 2, 2, 22, 20,
3, 2, 2, 2, 22, 23, 3, 2, 2, 2, 23, 26, 3, 2, 2, 2, 24, 22, 3, 2, 2, 2,
25, 27, 7, 6, 2, 2, 26, 25, 3, 2, 2, 2, 26, 27, 3, 2, 2, 2, 27, 28, 3,
2, 2, 2, 28, 29, 7, 7, 2, 2, 29, 33, 3, 2, 2, 2, 30, 31, 9, 2, 2, 2, 31,
33, 5, 2, 2, 17, 32, 4, 3, 2, 2, 2, 32, 6, 3, 2, 2, 2, 32, 7, 3, 2, 2,
2, 32, 8, 3, 2, 2, 2, 32, 9, 3, 2, 2, 2, 32, 10, 3, 2, 2, 2, 32, 14, 3,
2, 2, 2, 32, 30, 3, 2, 2, 2, 33, 101, 3, 2, 2, 2, 34, 35, 12, 18, 2, 2,
35, 36, 7, 21, 2, 2, 36, 100, 5, 2, 2, 19, 37, 38, 12, 16, 2, 2, 38, 39,
9, 3, 2, 2, 39, 100, 5, 2, 2, 17, 40, 41, 12, 15, 2, 2, 41, 42, 9, 4, 2,
2, 42, 100, 5, 2, 2, 16, 43, 44, 12, 14, 2, 2, 44, 45, 9, 5, 2, 2, 45,
100, 5, 2, 2, 15, 46, 47, 12, 11, 2, 2, 47, 48, 9, 6, 2, 2, 48, 49, 7,
37, 2, 2, 49, 50, 9, 6, 2, 2, 50, 100, 5, 2, 2, 12, 51, 52, 12, 10, 2,
2, 52, 53, 9, 7, 2, 2, 53, 54, 7, 37, 2, 2, 54, 55, 9, 7, 2, 2, 55, 100,
5, 2, 2, 11, 56, 57, 12, 9, 2, 2, 57, 58, 9, 8, 2, 2, 58, 100, 5, 2, 2,
10, 59, 60, 12, 8, 2, 2, 60, 61, 9, 9, 2, 2, 61, 100, 5, 2, 2, 9, 62, 63,
12, 7, 2, 2, 63, 64, 7, 24, 2, 2, 64, 100, 5, 2, 2, 8, 65, 66, 12, 6, 2,
2, 66, 67, 7, 26, 2, 2, 67, 100, 5, 2, 2, 7, 68, 69, 12, 5, 2, 2, 69, 70,
7, 25, 2, 2, 70, 100, 5, 2, 2, 6, 71, 72, 12, 4, 2, 2, 72, 73, 7, 27, 2,
2, 73, 100, 5, 2, 2, 5, 74, 75, 12, 3, 2, 2, 75, 76, 7, 28, 2, 2, 76, 100,
5, 2, 2, 4, 77, 78, 12, 19, 2, 2, 78, 79, 7, 14, 2, 2, 79, 100, 7, 38,
2, 2, 80, 81, 12, 13, 2, 2, 81, 82, 9, 10, 2, 2, 82, 83, 7, 5, 2, 2, 83,
88, 5, 2, 2, 2, 84, 85, 7, 6, 2, 2, 85, 87, 5, 2, 2, 2, 86, 84, 3, 2, 2,
2, 87, 90, 3, 2, 2, 2, 88, 86, 3, 2, 2, 2, 88, 89, 3, 2, 2, 2, 89, 92,
3, 2, 2, 2, 90, 88, 3, 2, 2, 2, 91, 93, 7, 6, 2, 2, 92, 91, 3, 2, 2, 2,
92, 93, 3, 2, 2, 2, 93, 94, 3, 2, 2, 2, 94, 95, 7, 7, 2, 2, 95, 100, 3,
2, 2, 2, 96, 97, 12, 12, 2, 2, 97, 98, 9, 10, 2, 2, 98, 100, 7, 33, 2,
2, 99, 34, 3, 2, 2, 2, 99, 37, 3, 2, 2, 2, 99, 40, 3, 2, 2, 2, 99, 43,
3, 2, 2, 2, 99, 46, 3, 2, 2, 2, 99, 51, 3, 2, 2, 2, 99, 56, 3, 2, 2, 2,
99, 59, 3, 2, 2, 2, 99, 62, 3, 2, 2, 2, 99, 65, 3, 2, 2, 2, 99, 68, 3,
2, 2, 2, 99, 71, 3, 2, 2, 2, 99, 74, 3, 2, 2, 2, 99, 77, 3, 2, 2, 2, 99,
80, 3, 2, 2, 2, 99, 96, 3, 2, 2, 2, 100, 103, 3, 2, 2, 2, 101, 99, 3, 2,
2, 2, 101, 102, 3, 2, 2, 2, 102, 3, 3, 2, 2, 2, 103, 101, 3, 2, 2, 2, 9,
22, 26, 32, 88, 92, 99, 101,
}
var literalNames = []string{
"", "'('", "')'", "'['", "','", "']'", "'<'", "'<='", "'>'", "'>='", "'=='",
"'!='", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'",
"'!='", "", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'",
"'&'", "'|'", "'^'", "", "", "'~'", "", "'in'", "'not in'",
}
var symbolicNames = []string{
"", "", "", "", "", "", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "ADD",
"SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR", "BXOR",
"AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "BooleanConstant",
"", "", "", "", "", "", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "UDF",
"ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR",
"BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "BooleanConstant",
"IntegerConstant", "FloatingConstant", "Identifier", "StringLiteral", "Whitespace",
"Newline",
}
@ -119,31 +127,32 @@ const (
PlanParserEQ = 10
PlanParserNE = 11
PlanParserLIKE = 12
PlanParserADD = 13
PlanParserSUB = 14
PlanParserMUL = 15
PlanParserDIV = 16
PlanParserMOD = 17
PlanParserPOW = 18
PlanParserSHL = 19
PlanParserSHR = 20
PlanParserBAND = 21
PlanParserBOR = 22
PlanParserBXOR = 23
PlanParserAND = 24
PlanParserOR = 25
PlanParserBNOT = 26
PlanParserNOT = 27
PlanParserIN = 28
PlanParserNIN = 29
PlanParserEmptyTerm = 30
PlanParserBooleanConstant = 31
PlanParserIntegerConstant = 32
PlanParserFloatingConstant = 33
PlanParserIdentifier = 34
PlanParserStringLiteral = 35
PlanParserWhitespace = 36
PlanParserNewline = 37
PlanParserUDF = 13
PlanParserADD = 14
PlanParserSUB = 15
PlanParserMUL = 16
PlanParserDIV = 17
PlanParserMOD = 18
PlanParserPOW = 19
PlanParserSHL = 20
PlanParserSHR = 21
PlanParserBAND = 22
PlanParserBOR = 23
PlanParserBXOR = 24
PlanParserAND = 25
PlanParserOR = 26
PlanParserBNOT = 27
PlanParserNOT = 28
PlanParserIN = 29
PlanParserNIN = 30
PlanParserEmptyTerm = 31
PlanParserBooleanConstant = 32
PlanParserIntegerConstant = 33
PlanParserFloatingConstant = 34
PlanParserIdentifier = 35
PlanParserStringLiteral = 36
PlanParserWhitespace = 37
PlanParserNewline = 38
)
// PlanParserRULE_expr is the PlanParser rule.
@ -1129,6 +1138,65 @@ func (s *LikeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
}
}
type UdfContext struct {
*ExprContext
}
func NewUdfContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UdfContext {
var p = new(UdfContext)
p.ExprContext = NewEmptyExprContext()
p.parser = parser
p.CopyFrom(ctx.(*ExprContext))
return p
}
func (s *UdfContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *UdfContext) UDF() antlr.TerminalNode {
return s.GetToken(PlanParserUDF, 0)
}
func (s *UdfContext) StringLiteral() antlr.TerminalNode {
return s.GetToken(PlanParserStringLiteral, 0)
}
func (s *UdfContext) AllExpr() []IExprContext {
var ts = s.GetTypedRuleContexts(reflect.TypeOf((*IExprContext)(nil)).Elem())
var tst = make([]IExprContext, len(ts))
for i, t := range ts {
if t != nil {
tst[i] = t.(IExprContext)
}
}
return tst
}
func (s *UdfContext) Expr(i int) IExprContext {
var t = s.GetTypedRuleContext(reflect.TypeOf((*IExprContext)(nil)).Elem(), i)
if t == nil {
return nil
}
return t.(IExprContext)
}
func (s *UdfContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case PlanVisitor:
return t.VisitUdf(s)
default:
return t.VisitChildren(s)
}
}
type BitAndContext struct {
*ExprContext
}
@ -1478,7 +1546,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
var _alt int
p.EnterOuterAlt(localctx, 1)
p.SetState(14)
p.SetState(30)
p.GetErrorHandler().Sync(p)
switch p.GetTokenStream().LA(1) {
@ -1545,12 +1613,69 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
p.Match(PlanParserT__1)
}
case PlanParserUDF:
localctx = NewUdfContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(12)
p.Match(PlanParserUDF)
}
{
p.SetState(13)
p.Match(PlanParserStringLiteral)
}
{
p.SetState(14)
p.Match(PlanParserT__2)
}
{
p.SetState(15)
p.expr(0)
}
p.SetState(20)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext())
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
{
p.SetState(16)
p.Match(PlanParserT__3)
}
{
p.SetState(17)
p.expr(0)
}
}
p.SetState(22)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 0, p.GetParserRuleContext())
}
p.SetState(24)
p.GetErrorHandler().Sync(p)
_la = p.GetTokenStream().LA(1)
if _la == PlanParserT__3 {
{
p.SetState(23)
p.Match(PlanParserT__3)
}
}
{
p.SetState(26)
p.Match(PlanParserT__4)
}
case PlanParserADD, PlanParserSUB, PlanParserBNOT, PlanParserNOT:
localctx = NewUnaryContext(p, localctx)
p.SetParserRuleContext(localctx)
_prevctx = localctx
{
p.SetState(12)
p.SetState(28)
var _lt = p.GetTokenStream().LT(1)
@ -1568,7 +1693,7 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(13)
p.SetState(29)
p.expr(15)
}
@ -1576,9 +1701,9 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
panic(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil))
}
p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1))
p.SetState(83)
p.SetState(99)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
@ -1586,36 +1711,36 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
p.TriggerExitRuleEvent()
}
_prevctx = localctx
p.SetState(81)
p.SetState(97)
p.GetErrorHandler().Sync(p)
switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext()) {
switch p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 5, p.GetParserRuleContext()) {
case 1:
localctx = NewPowerContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(16)
p.SetState(32)
if !(p.Precpred(p.GetParserRuleContext(), 16)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", ""))
}
{
p.SetState(17)
p.SetState(33)
p.Match(PlanParserPOW)
}
{
p.SetState(18)
p.SetState(34)
p.expr(17)
}
case 2:
localctx = NewMulDivModContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(19)
p.SetState(35)
if !(p.Precpred(p.GetParserRuleContext(), 14)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", ""))
}
{
p.SetState(20)
p.SetState(36)
var _lt = p.GetTokenStream().LT(1)
@ -1633,20 +1758,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(21)
p.SetState(37)
p.expr(15)
}
case 3:
localctx = NewAddSubContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(22)
p.SetState(38)
if !(p.Precpred(p.GetParserRuleContext(), 13)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", ""))
}
{
p.SetState(23)
p.SetState(39)
var _lt = p.GetTokenStream().LT(1)
@ -1664,20 +1789,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(24)
p.SetState(40)
p.expr(14)
}
case 4:
localctx = NewShiftContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(25)
p.SetState(41)
if !(p.Precpred(p.GetParserRuleContext(), 12)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", ""))
}
{
p.SetState(26)
p.SetState(42)
var _lt = p.GetTokenStream().LT(1)
@ -1695,20 +1820,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(27)
p.SetState(43)
p.expr(13)
}
case 5:
localctx = NewRangeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(28)
p.SetState(44)
if !(p.Precpred(p.GetParserRuleContext(), 9)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", ""))
}
{
p.SetState(29)
p.SetState(45)
var _lt = p.GetTokenStream().LT(1)
@ -1726,11 +1851,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(30)
p.SetState(46)
p.Match(PlanParserIdentifier)
}
{
p.SetState(31)
p.SetState(47)
var _lt = p.GetTokenStream().LT(1)
@ -1748,20 +1873,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(32)
p.SetState(48)
p.expr(10)
}
case 6:
localctx = NewReverseRangeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(33)
p.SetState(49)
if !(p.Precpred(p.GetParserRuleContext(), 8)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", ""))
}
{
p.SetState(34)
p.SetState(50)
var _lt = p.GetTokenStream().LT(1)
@ -1779,11 +1904,11 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(35)
p.SetState(51)
p.Match(PlanParserIdentifier)
}
{
p.SetState(36)
p.SetState(52)
var _lt = p.GetTokenStream().LT(1)
@ -1801,20 +1926,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(37)
p.SetState(53)
p.expr(9)
}
case 7:
localctx = NewRelationalContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(38)
p.SetState(54)
if !(p.Precpred(p.GetParserRuleContext(), 7)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", ""))
}
{
p.SetState(39)
p.SetState(55)
var _lt = p.GetTokenStream().LT(1)
@ -1832,20 +1957,20 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(40)
p.SetState(56)
p.expr(8)
}
case 8:
localctx = NewEqualityContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(41)
p.SetState(57)
if !(p.Precpred(p.GetParserRuleContext(), 6)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", ""))
}
{
p.SetState(42)
p.SetState(58)
var _lt = p.GetTokenStream().LT(1)
@ -1863,122 +1988,122 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(43)
p.SetState(59)
p.expr(7)
}
case 9:
localctx = NewBitAndContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(44)
p.SetState(60)
if !(p.Precpred(p.GetParserRuleContext(), 5)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", ""))
}
{
p.SetState(45)
p.SetState(61)
p.Match(PlanParserBAND)
}
{
p.SetState(46)
p.SetState(62)
p.expr(6)
}
case 10:
localctx = NewBitXorContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(47)
p.SetState(63)
if !(p.Precpred(p.GetParserRuleContext(), 4)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", ""))
}
{
p.SetState(48)
p.SetState(64)
p.Match(PlanParserBXOR)
}
{
p.SetState(49)
p.SetState(65)
p.expr(5)
}
case 11:
localctx = NewBitOrContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(50)
p.SetState(66)
if !(p.Precpred(p.GetParserRuleContext(), 3)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", ""))
}
{
p.SetState(51)
p.SetState(67)
p.Match(PlanParserBOR)
}
{
p.SetState(52)
p.SetState(68)
p.expr(4)
}
case 12:
localctx = NewLogicalAndContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(53)
p.SetState(69)
if !(p.Precpred(p.GetParserRuleContext(), 2)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", ""))
}
{
p.SetState(54)
p.SetState(70)
p.Match(PlanParserAND)
}
{
p.SetState(55)
p.SetState(71)
p.expr(3)
}
case 13:
localctx = NewLogicalOrContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(56)
p.SetState(72)
if !(p.Precpred(p.GetParserRuleContext(), 1)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", ""))
}
{
p.SetState(57)
p.SetState(73)
p.Match(PlanParserOR)
}
{
p.SetState(58)
p.SetState(74)
p.expr(2)
}
case 14:
localctx = NewLikeContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(59)
p.SetState(75)
if !(p.Precpred(p.GetParserRuleContext(), 17)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", ""))
}
{
p.SetState(60)
p.SetState(76)
p.Match(PlanParserLIKE)
}
{
p.SetState(61)
p.SetState(77)
p.Match(PlanParserStringLiteral)
}
case 15:
localctx = NewTermContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(62)
p.SetState(78)
if !(p.Precpred(p.GetParserRuleContext(), 11)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 11)", ""))
}
{
p.SetState(63)
p.SetState(79)
var _lt = p.GetTokenStream().LT(1)
@ -1997,59 +2122,59 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
{
p.SetState(64)
p.SetState(80)
p.Match(PlanParserT__2)
}
{
p.SetState(65)
p.SetState(81)
p.expr(0)
}
p.SetState(70)
p.SetState(86)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext())
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext())
for _alt != 2 && _alt != antlr.ATNInvalidAltNumber {
if _alt == 1 {
{
p.SetState(66)
p.SetState(82)
p.Match(PlanParserT__3)
}
{
p.SetState(67)
p.SetState(83)
p.expr(0)
}
}
p.SetState(72)
p.SetState(88)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 1, p.GetParserRuleContext())
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 3, p.GetParserRuleContext())
}
p.SetState(74)
p.SetState(90)
p.GetErrorHandler().Sync(p)
_la = p.GetTokenStream().LA(1)
if _la == PlanParserT__3 {
{
p.SetState(73)
p.SetState(89)
p.Match(PlanParserT__3)
}
}
{
p.SetState(76)
p.SetState(92)
p.Match(PlanParserT__4)
}
case 16:
localctx = NewEmptyTermContext(p, NewExprContext(p, _parentctx, _parentState))
p.PushNewRecursionContext(localctx, _startState, PlanParserRULE_expr)
p.SetState(78)
p.SetState(94)
if !(p.Precpred(p.GetParserRuleContext(), 10)) {
panic(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", ""))
}
{
p.SetState(79)
p.SetState(95)
var _lt = p.GetTokenStream().LT(1)
@ -2067,16 +2192,16 @@ func (p *PlanParser) expr(_p int) (localctx IExprContext) {
}
}
{
p.SetState(80)
p.SetState(96)
p.Match(PlanParserEmptyTerm)
}
}
}
p.SetState(85)
p.SetState(101)
p.GetErrorHandler().Sync(p)
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 4, p.GetParserRuleContext())
_alt = p.GetInterpreter().AdaptivePredict(p.GetTokenStream(), 6, p.GetParserRuleContext())
}
return localctx

3
internal/parser/planparserv2/generated/plan_visitor.go
View File

@ -58,6 +58,9 @@ type PlanVisitor interface {
// Visit a parse tree produced by PlanParser#Like.
VisitLike(ctx *LikeContext) interface{}
// Visit a parse tree produced by PlanParser#Udf.
VisitUdf(ctx *UdfContext) interface{}
// Visit a parse tree produced by PlanParser#BitAnd.
VisitBitAnd(ctx *BitAndContext) interface{}

1
internal/parser/planparserv2/logical_expr_visitor.go
View File

@ -14,4 +14,5 @@ type LogicalExprVisitor interface {
VisitBinaryArithExpr(expr *planpb.BinaryArithExpr) interface{}
VisitValueExpr(expr *planpb.ValueExpr) interface{}
VisitColumnExpr(expr *planpb.ColumnExpr) interface{}
VisitUdfExpr(expr *planpb.UdfExpr) interface{}
}

94
internal/parser/planparserv2/parser_visitor.go
View File

@ -1,9 +1,14 @@
package planparserv2
import (
"context"
"fmt"
"strconv"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/api/schemapb"
parser "github.com/milvus-io/milvus/internal/parser/planparserv2/generated"
"github.com/milvus-io/milvus/internal/proto/planpb"
@ -12,11 +17,24 @@ import (
type ParserVisitor struct {
parser.BasePlanVisitor
schema *typeutil.SchemaHelper
schema *typeutil.SchemaHelper
rootCoord types.RootCoord
}
func NewParserVisitor(schema *typeutil.SchemaHelper) *ParserVisitor {
return &ParserVisitor{schema: schema}
type ParserVisitorOpt func(v *ParserVisitor)
func ParserVisitorWithRootCoord(rootCoord types.RootCoord) ParserVisitorOpt {
return func(v *ParserVisitor) {
v.rootCoord = rootCoord
}
}
func NewParserVisitor(schema *typeutil.SchemaHelper, opts ...ParserVisitorOpt) *ParserVisitor {
v := &ParserVisitor{schema: schema}
for _, opt := range opts {
opt(v)
}
return v
}
// VisitParens unpack the parentheses.
@ -882,3 +900,73 @@ func (v *ParserVisitor) VisitShift(ctx *parser.ShiftContext) interface{} {
func (v *ParserVisitor) VisitBitOr(ctx *parser.BitOrContext) interface{} {
return fmt.Errorf("BitOr is not supported: %s", ctx.GetText())
}
// VisitUdf translates expr to udf plan.
func (v *ParserVisitor) VisitUdf(ctx *parser.UdfContext) interface{} {
// return fmt.Errorf("Udf is not supported: %s", ctx.GetText())
funcName, err := strconv.Unquote(ctx.StringLiteral().GetText())
if err != nil {
return err
}
req := rootcoordpb.GetFunctionInfoRequest{
Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_GetFunctionInfo},
FunctionName: funcName,
}
GetFunctionInfoResponse, err := v.rootCoord.GetFunctionInfo(context.Background(), &req)
if err != nil {
return err
}
argTypes := GetFunctionInfoResponse.GetInfo().GetArgTypes()
wasmBody := GetFunctionInfoResponse.GetInfo().GetWatBodyBase64()
allExpr := ctx.AllExpr()
lenOfAllExpr := len(allExpr)
udfParams := make([]*planpb.UdfParams, 0, lenOfAllExpr)
// parser udf parameters
for i := 0; i < lenOfAllExpr; i++ {
child := allExpr[i].Accept(v)
if err := getError(child); err != nil {
return err
}
childExpr := getExpr(child)
column := toColumnInfo(childExpr)
if column != nil {
arg := &planpb.UdfParams{
Val: &planpb.UdfParams_ColumnInfo{
ColumnInfo: column,
},
}
udfParams = append(udfParams, arg)
}
childValue := getGenericValue(child)
if childValue != nil {
arg := &planpb.UdfParams{
Val: &planpb.UdfParams_Value{
Value: childValue,
},
}
udfParams = append(udfParams, arg)
}
if column == nil && childValue == nil {
return fmt.Errorf("udf argument is invalid: %s", ctx.GetText())
}
}
expr := &planpb.Expr{
Expr: &planpb.Expr_UdfExpr{
UdfExpr: &planpb.UdfExpr{
UdfFuncName: funcName,
UdfParams: udfParams,
WasmBody: wasmBody,
ArgTypes: argTypes,
},
},
}
return &ExprWithType{
expr: expr,
dataType: schemapb.DataType_Bool,
}
}

16
internal/parser/planparserv2/plan_parser_v2.go
View File

@ -10,7 +10,7 @@ import (
"github.com/antlr/antlr4/runtime/Go/antlr"
)
func handleExpr(schema *typeutil.SchemaHelper, exprStr string) interface{} {
func handleExpr(schema *typeutil.SchemaHelper, exprStr string, opts ...ParserVisitorOpt) interface{} {
if exprStr == "" {
return nil
}
@ -37,16 +37,16 @@ func handleExpr(schema *typeutil.SchemaHelper, exprStr string) interface{} {
putLexer(lexer)
putParser(parser)
visitor := NewParserVisitor(schema)
visitor := NewParserVisitor(schema, opts...)
return ast.Accept(visitor)
}
func ParseExpr(schema *typeutil.SchemaHelper, exprStr string) (*planpb.Expr, error) {
func ParseExpr(schema *typeutil.SchemaHelper, exprStr string, opts ...ParserVisitorOpt) (*planpb.Expr, error) {
if len(exprStr) <= 0 {
return nil, nil
}
ret := handleExpr(schema, exprStr)
ret := handleExpr(schema, exprStr, opts...)
if err := getError(ret); err != nil {
return nil, fmt.Errorf("cannot parse expression: %s, error: %s", exprStr, err)
@ -64,13 +64,13 @@ func ParseExpr(schema *typeutil.SchemaHelper, exprStr string) (*planpb.Expr, err
return predicate.expr, nil
}
func CreateRetrievePlan(schemaPb *schemapb.CollectionSchema, exprStr string) (*planpb.PlanNode, error) {
func CreateRetrievePlan(schemaPb *schemapb.CollectionSchema, exprStr string, opts ...ParserVisitorOpt) (*planpb.PlanNode, error) {
schema, err := typeutil.CreateSchemaHelper(schemaPb)
if err != nil {
return nil, err
}
expr, err := ParseExpr(schema, exprStr)
expr, err := ParseExpr(schema, exprStr, opts...)
if err != nil {
return nil, err
}
@ -83,13 +83,13 @@ func CreateRetrievePlan(schemaPb *schemapb.CollectionSchema, exprStr string) (*p
return planNode, nil
}
func CreateSearchPlan(schemaPb *schemapb.CollectionSchema, exprStr string, vectorFieldName string, queryInfo *planpb.QueryInfo) (*planpb.PlanNode, error) {
func CreateSearchPlan(schemaPb *schemapb.CollectionSchema, exprStr string, vectorFieldName string, queryInfo *planpb.QueryInfo, opts ...ParserVisitorOpt) (*planpb.PlanNode, error) {
schema, err := typeutil.CreateSchemaHelper(schemaPb)
if err != nil {
return nil, err
}
expr, err := ParseExpr(schema, exprStr)
expr, err := ParseExpr(schema, exprStr, opts...)
if err != nil {
return nil, err
}

49
internal/parser/planparserv2/plan_parser_v2_test.go
View File

@ -1,9 +1,12 @@
package planparserv2
import (
"fmt"
"sync"
"testing"
"github.com/golang/protobuf/proto"
"github.com/milvus-io/milvus/internal/proto/planpb"
"github.com/stretchr/testify/assert"
@ -535,3 +538,49 @@ func Test_handleExpr_17126(t *testing.T) {
}
wg.Wait()
}
// test udf expr
func TestExpr_UDF(t *testing.T) {
schema := newTestSchema()
helper, err := typeutil.CreateSchemaHelper(schema)
assert.NoError(t, err)
exprStrs := []string{
`UDF "funcName" [2]`,
`UDF "funcName" [Int8Field]`,
`UDF "funcName" [DoubleField, 2]`,
`UDF "funcName" [Int8Field, Int8Field]`,
`UDF "funcName" [Int8Field, 2, Int16Field, 4]`,
}
for _, exprStr := range exprStrs {
expr, err := ParseExpr(helper, exprStr)
assert.NoError(t, err, exprStr)
marshaledProtoPlan := proto.MarshalTextString(expr)
fmt.Printf(marshaledProtoPlan)
ShowExpr(expr)
}
//marshaledProtoPlan1 := proto.MarshalTextString(exprStr1)
//fmt.Printf(marshaledProtoPlan1)
}
// test udf expr
func TestExprTextString_UDF(t *testing.T) {
schema := newTestSchema()
helper, err := typeutil.CreateSchemaHelper(schema)
assert.NoError(t, err)
exprStrs := []string{
`UDF "funcName" [DoubleField, 2]`,
`UDF "less_than" [Int64Field, 2000]`,
`UDF "multiple_columns" [Int8Field, Int16Field, Int32Field, Int64Field, 2000]`,
}
for _, exprStr := range exprStrs {
expr, err := ParseExpr(helper, exprStr)
assert.NoError(t, err, exprStr)
marshaledProtoPlan := proto.MarshalTextString(expr)
fmt.Printf(marshaledProtoPlan)
ShowExpr(expr)
}
}

23
internal/parser/planparserv2/show_visitor.go
View File

@ -59,6 +59,8 @@ func (v *ShowExprVisitor) VisitExpr(expr *planpb.Expr) interface{} {
js["expr"] = v.VisitValueExpr(realExpr.ValueExpr)
case *planpb.Expr_ColumnExpr:
js["expr"] = v.VisitColumnExpr(realExpr.ColumnExpr)
case *planpb.Expr_UdfExpr:
js["expr"] = v.VisitUdfExpr(realExpr.UdfExpr)
default:
js["expr"] = ""
}
@ -155,6 +157,27 @@ func (v *ShowExprVisitor) VisitColumnExpr(expr *planpb.ColumnExpr) interface{} {
return js
}
func (v *ShowExprVisitor) VisitUdfExpr(expr *planpb.UdfExpr) interface{} {
js := make(map[string]interface{})
js["expr_type"] = "udf"
js["udf_func_name"] = expr.GetUdfFuncName()
udfArgs := make([]interface{}, 0, len(expr.UdfParams))
for _, v := range expr.UdfParams {
col := v.GetColumnInfo()
if col != nil {
udfArgs = append(udfArgs, extractColumnInfo(col))
}
val := v.GetValue()
if val != nil {
udfArgs = append(udfArgs, extractGenericValue(val))
}
}
js["udf_args"] = udfArgs
js["wasm_body"] = expr.GetWasmBody()
js["arg_types"] = expr.GetArgTypes()
return js
}
func NewShowExprVisitor() LogicalExprVisitor {
return &ShowExprVisitor{}
}

5
internal/proto/common.proto
View File

@ -203,6 +203,11 @@ enum MsgType {
GetRecoveryInfo = 602;
GetSegmentState = 603;
/* FUNCTION */
CreateFunction = 700;
DropFunction = 701;
GetFunctionInfo = 702;
/* SYSTEM CONTROL */
TimeTick = 1200;
QueryNodeStats = 1201; // GOOSE TODO: Remove kQueryNodeStats

19
internal/proto/milvus.proto
View File

@ -83,6 +83,9 @@ service MilvusService {
rpc SelectUser(SelectUserRequest) returns (SelectUserResponse) {}
rpc OperatePrivilege(OperatePrivilegeRequest) returns (common.Status) {}
rpc SelectGrant(SelectGrantRequest) returns (SelectGrantResponse) {}
rpc CreateFunction(CreateFunctionRequest) returns (common.Status){}
rpc DropFunction(DropFunctionRequest) returns (common.Status){}
}
message CreateAliasRequest {
@ -1256,6 +1259,22 @@ message OperatePrivilegeRequest {
OperatePrivilegeType type = 3;
}
message CreateFunctionRequest {
common.MsgBase base = 1;
// The unique function name in rootcoord.(Required)
string function_name = 2;
// wat file after base64.(Required)
string wat_body_base64 = 3;
// list of function parameter types.(Required)
repeated schema.DataType arg_types = 4;
}
message DropFunctionRequest {
common.MsgBase base = 1;
// The unique function name in rootcoord.(Required)
string function_name = 2;
}
message MilvusExt {
string version = 1;
}

15
internal/proto/plan.proto
View File

@ -125,6 +125,20 @@ message BinaryArithOpEvalRangeExpr {
GenericValue value = 5;
}
message UdfParams {
oneof val {
GenericValue value = 1;
ColumnInfo column_info = 2;
};
}
message UdfExpr {
string udf_func_name = 1;
repeated UdfParams udf_params = 2;
string wasm_body = 3;
repeated schema.DataType arg_types = 4;
}
message Expr {
oneof expr {
TermExpr term_expr = 1;
@ -137,6 +151,7 @@ message Expr {
BinaryArithExpr binary_arith_expr = 8;
ValueExpr value_expr = 9;
ColumnExpr column_expr = 10;
UdfExpr udf_expr = 11;
};
}

353
internal/proto/planpb/plan.pb.go
View File

@ -994,6 +994,149 @@ func (m *BinaryArithOpEvalRangeExpr) GetValue() *GenericValue {
return nil
}
type UdfParams struct {
// Types that are valid to be assigned to Val:
// *UdfParams_Value
// *UdfParams_ColumnInfo
Val isUdfParams_Val `protobuf_oneof:"val"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UdfParams) Reset() { *m = UdfParams{} }
func (m *UdfParams) String() string { return proto.CompactTextString(m) }
func (*UdfParams) ProtoMessage() {}
func (*UdfParams) Descriptor() ([]byte, []int) {
return fileDescriptor_2d655ab2f7683c23, []int{14}
}
func (m *UdfParams) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UdfParams.Unmarshal(m, b)
}
func (m *UdfParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UdfParams.Marshal(b, m, deterministic)
}
func (m *UdfParams) XXX_Merge(src proto.Message) {
xxx_messageInfo_UdfParams.Merge(m, src)
}
func (m *UdfParams) XXX_Size() int {
return xxx_messageInfo_UdfParams.Size(m)
}
func (m *UdfParams) XXX_DiscardUnknown() {
xxx_messageInfo_UdfParams.DiscardUnknown(m)
}
var xxx_messageInfo_UdfParams proto.InternalMessageInfo
type isUdfParams_Val interface {
isUdfParams_Val()
}
type UdfParams_Value struct {
Value *GenericValue `protobuf:"bytes,1,opt,name=value,proto3,oneof"`
}
type UdfParams_ColumnInfo struct {
ColumnInfo *ColumnInfo `protobuf:"bytes,2,opt,name=column_info,json=columnInfo,proto3,oneof"`
}
func (*UdfParams_Value) isUdfParams_Val() {}
func (*UdfParams_ColumnInfo) isUdfParams_Val() {}
func (m *UdfParams) GetVal() isUdfParams_Val {
if m != nil {
return m.Val
}
return nil
}
func (m *UdfParams) GetValue() *GenericValue {
if x, ok := m.GetVal().(*UdfParams_Value); ok {
return x.Value
}
return nil
}
func (m *UdfParams) GetColumnInfo() *ColumnInfo {
if x, ok := m.GetVal().(*UdfParams_ColumnInfo); ok {
return x.ColumnInfo
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*UdfParams) XXX_OneofWrappers() []interface{} {
return []interface{}{
(*UdfParams_Value)(nil),
(*UdfParams_ColumnInfo)(nil),
}
}
type UdfExpr struct {
UdfFuncName string `protobuf:"bytes,1,opt,name=udf_func_name,json=udfFuncName,proto3" json:"udf_func_name,omitempty"`
UdfParams []*UdfParams `protobuf:"bytes,2,rep,name=udf_params,json=udfParams,proto3" json:"udf_params,omitempty"`
WasmBody string `protobuf:"bytes,3,opt,name=wasm_body,json=wasmBody,proto3" json:"wasm_body,omitempty"`
ArgTypes []schemapb.DataType `protobuf:"varint,4,rep,packed,name=arg_types,json=argTypes,proto3,enum=milvus.proto.schema.DataType" json:"arg_types,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *UdfExpr) Reset() { *m = UdfExpr{} }
func (m *UdfExpr) String() string { return proto.CompactTextString(m) }
func (*UdfExpr) ProtoMessage() {}
func (*UdfExpr) Descriptor() ([]byte, []int) {
return fileDescriptor_2d655ab2f7683c23, []int{15}
}
func (m *UdfExpr) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UdfExpr.Unmarshal(m, b)
}
func (m *UdfExpr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_UdfExpr.Marshal(b, m, deterministic)
}
func (m *UdfExpr) XXX_Merge(src proto.Message) {
xxx_messageInfo_UdfExpr.Merge(m, src)
}
func (m *UdfExpr) XXX_Size() int {
return xxx_messageInfo_UdfExpr.Size(m)
}
func (m *UdfExpr) XXX_DiscardUnknown() {
xxx_messageInfo_UdfExpr.DiscardUnknown(m)
}
var xxx_messageInfo_UdfExpr proto.InternalMessageInfo
func (m *UdfExpr) GetUdfFuncName() string {
if m != nil {
return m.UdfFuncName
}
return ""
}
func (m *UdfExpr) GetUdfParams() []*UdfParams {
if m != nil {
return m.UdfParams
}
return nil
}
func (m *UdfExpr) GetWasmBody() string {
if m != nil {
return m.WasmBody
}
return ""
}
func (m *UdfExpr) GetArgTypes() []schemapb.DataType {
if m != nil {
return m.ArgTypes
}
return nil
}
type Expr struct {
// Types that are valid to be assigned to Expr:
// *Expr_TermExpr
@ -1006,6 +1149,7 @@ type Expr struct {
// *Expr_BinaryArithExpr
// *Expr_ValueExpr
// *Expr_ColumnExpr
// *Expr_UdfExpr
Expr isExpr_Expr `protobuf_oneof:"expr"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -1016,7 +1160,7 @@ func (m *Expr) Reset() { *m = Expr{} }
func (m *Expr) String() string { return proto.CompactTextString(m) }
func (*Expr) ProtoMessage() {}
func (*Expr) Descriptor() ([]byte, []int) {
return fileDescriptor_2d655ab2f7683c23, []int{14}
return fileDescriptor_2d655ab2f7683c23, []int{16}
}
func (m *Expr) XXX_Unmarshal(b []byte) error {
@ -1081,6 +1225,10 @@ type Expr_ColumnExpr struct {
ColumnExpr *ColumnExpr `protobuf:"bytes,10,opt,name=column_expr,json=columnExpr,proto3,oneof"`
}
type Expr_UdfExpr struct {
UdfExpr *UdfExpr `protobuf:"bytes,11,opt,name=udf_expr,json=udfExpr,proto3,oneof"`
}
func (*Expr_TermExpr) isExpr_Expr() {}
func (*Expr_UnaryExpr) isExpr_Expr() {}
@ -1101,6 +1249,8 @@ func (*Expr_ValueExpr) isExpr_Expr() {}
func (*Expr_ColumnExpr) isExpr_Expr() {}
func (*Expr_UdfExpr) isExpr_Expr() {}
func (m *Expr) GetExpr() isExpr_Expr {
if m != nil {
return m.Expr
@ -1178,6 +1328,13 @@ func (m *Expr) GetColumnExpr() *ColumnExpr {
return nil
}
func (m *Expr) GetUdfExpr() *UdfExpr {
if x, ok := m.GetExpr().(*Expr_UdfExpr); ok {
return x.UdfExpr
}
return nil
}
// XXX_OneofWrappers is for the internal use of the proto package.
func (*Expr) XXX_OneofWrappers() []interface{} {
return []interface{}{
@ -1191,6 +1348,7 @@ func (*Expr) XXX_OneofWrappers() []interface{} {
(*Expr_BinaryArithExpr)(nil),
(*Expr_ValueExpr)(nil),
(*Expr_ColumnExpr)(nil),
(*Expr_UdfExpr)(nil),
}
}
@ -1209,7 +1367,7 @@ func (m *VectorANNS) Reset() { *m = VectorANNS{} }
func (m *VectorANNS) String() string { return proto.CompactTextString(m) }
func (*VectorANNS) ProtoMessage() {}
func (*VectorANNS) Descriptor() ([]byte, []int) {
return fileDescriptor_2d655ab2f7683c23, []int{15}
return fileDescriptor_2d655ab2f7683c23, []int{17}
}
func (m *VectorANNS) XXX_Unmarshal(b []byte) error {
@ -1280,7 +1438,7 @@ func (m *PlanNode) Reset() { *m = PlanNode{} }
func (m *PlanNode) String() string { return proto.CompactTextString(m) }
func (*PlanNode) ProtoMessage() {}
func (*PlanNode) Descriptor() ([]byte, []int) {
return fileDescriptor_2d655ab2f7683c23, []int{16}
return fileDescriptor_2d655ab2f7683c23, []int{18}
}
func (m *PlanNode) XXX_Unmarshal(b []byte) error {
@ -1372,6 +1530,8 @@ func init() {
proto.RegisterType((*BinaryArithOp)(nil), "milvus.proto.plan.BinaryArithOp")
proto.RegisterType((*BinaryArithExpr)(nil), "milvus.proto.plan.BinaryArithExpr")
proto.RegisterType((*BinaryArithOpEvalRangeExpr)(nil), "milvus.proto.plan.BinaryArithOpEvalRangeExpr")
proto.RegisterType((*UdfParams)(nil), "milvus.proto.plan.UdfParams")
proto.RegisterType((*UdfExpr)(nil), "milvus.proto.plan.UdfExpr")
proto.RegisterType((*Expr)(nil), "milvus.proto.plan.Expr")
proto.RegisterType((*VectorANNS)(nil), "milvus.proto.plan.VectorANNS")
proto.RegisterType((*PlanNode)(nil), "milvus.proto.plan.PlanNode")
@ -1380,93 +1540,102 @@ func init() {
func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
var fileDescriptor_2d655ab2f7683c23 = []byte{
// 1407 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcd, 0x72, 0xdc, 0x44,
0x10, 0x5e, 0xad, 0x76, 0xbd, 0x52, 0xef, 0x7a, 0xad, 0xe8, 0x42, 0x7e, 0x48, 0x6c, 0x44, 0x8a,
0x98, 0x50, 0xb1, 0x2b, 0x24, 0x24, 0x95, 0x50, 0x01, 0xff, 0x05, 0x7b, 0x8b, 0xc4, 0x36, 0x8a,
0xe3, 0x03, 0x17, 0xd5, 0xac, 0x34, 0xf6, 0x4e, 0x45, 0xab, 0x51, 0x46, 0xa3, 0x4d, 0xf6, 0xcc,
0x8d, 0x1b, 0x0f, 0xc0, 0x15, 0xee, 0xdc, 0xe0, 0xc2, 0x0b, 0x70, 0xe0, 0xc8, 0x9d, 0xb7, 0xe0,
0x44, 0x4d, 0x8f, 0xf6, 0x2f, 0xb5, 0x1b, 0xaf, 0x8b, 0x54, 0x71, 0x1b, 0xf5, 0x74, 0x7f, 0xd3,
0xfd, 0x4d, 0x77, 0x4f, 0x0b, 0x20, 0x8d, 0x49, 0xb2, 0x96, 0x0a, 0x2e, 0xb9, 0x7b, 0xa1, 0xcb,
0xe2, 0x5e, 0x9e, 0xe9, 0xaf, 0x35, 0xb5, 0x71, 0xb9, 0x91, 0x85, 0x1d, 0xda, 0x25, 0x5a, 0xe4,
0xfd, 0x60, 0x40, 0x63, 0x97, 0x26, 0x54, 0xb0, 0xf0, 0x98, 0xc4, 0x39, 0x75, 0xaf, 0x80, 0xd5,
0xe6, 0x3c, 0x0e, 0x7a, 0x24, 0xbe, 0x68, 0xac, 0x18, 0xab, 0xd6, 0x5e, 0xc9, 0xaf, 0x29, 0xc9,
0x31, 0x89, 0xdd, 0xab, 0x60, 0xb3, 0x44, 0xde, 0xbb, 0x8b, 0xbb, 0xe5, 0x15, 0x63, 0xd5, 0xdc,
0x2b, 0xf9, 0x16, 0x8a, 0x8a, 0xed, 0x93, 0x98, 0x13, 0x89, 0xdb, 0xe6, 0x8a, 0xb1, 0x6a, 0xa8,
0x6d, 0x14, 0xa9, 0xed, 0x65, 0x80, 0x4c, 0x0a, 0x96, 0x9c, 0xe2, 0x7e, 0x65, 0xc5, 0x58, 0xb5,
0xf7, 0x4a, 0xbe, 0xad, 0x65, 0xc7, 0x24, 0xde, 0xaa, 0x82, 0xd9, 0x23, 0xb1, 0xf7, 0xbd, 0x01,
0xf6, 0x37, 0x39, 0x15, 0xfd, 0x56, 0x72, 0xc2, 0x5d, 0x17, 0x2a, 0x92, 0xa7, 0x2f, 0xd0, 0x19,
0xd3, 0xc7, 0xb5, 0xbb, 0x0c, 0xf5, 0x2e, 0x95, 0x82, 0x85, 0x81, 0xec, 0xa7, 0x14, 0x8f, 0xb2,
0x7d, 0xd0, 0xa2, 0xa3, 0x7e, 0x4a, 0xdd, 0x0f, 0x61, 0x31, 0xa3, 0x44, 0x84, 0x9d, 0x20, 0x25,
0x82, 0x74, 0x33, 0x7d, 0x9a, 0xdf, 0xd0, 0xc2, 0x43, 0x94, 0x29, 0x25, 0xc1, 0xf3, 0x24, 0x0a,
0x22, 0x1a, 0xb2, 0x2e, 0x89, 0x2f, 0x56, 0xf1, 0x88, 0x06, 0x0a, 0x77, 0xb4, 0xcc, 0xfb, 0xc9,
0x00, 0xd8, 0xe6, 0x71, 0xde, 0x4d, 0xd0, 0x9b, 0x4b, 0x60, 0x9d, 0x30, 0x1a, 0x47, 0x01, 0x8b,
0x0a, 0x8f, 0x6a, 0xf8, 0xdd, 0x8a, 0xdc, 0x87, 0x60, 0x47, 0x44, 0x12, 0xed, 0x92, 0x22, 0xa7,
0xf9, 0xe9, 0xd5, 0xb5, 0x09, 0xfe, 0x0b, 0xe6, 0x77, 0x88, 0x24, 0xca, 0x4b, 0xdf, 0x8a, 0x8a,
0x95, 0x7b, 0x1d, 0x9a, 0x2c, 0x0b, 0x52, 0xc1, 0xba, 0x44, 0xf4, 0x83, 0x17, 0xb4, 0x8f, 0x31,
0x59, 0x7e, 0x83, 0x65, 0x87, 0x5a, 0xf8, 0x35, 0xed, 0xbb, 0x57, 0xc0, 0x66, 0x59, 0x40, 0x72,
0xc9, 0x5b, 0x3b, 0x18, 0x91, 0xe5, 0x5b, 0x2c, 0xdb, 0xc4, 0x6f, 0xef, 0xcb, 0x81, 0x9f, 0x8f,
0x5f, 0xa7, 0xc2, 0xbd, 0x0d, 0x15, 0x96, 0x9c, 0x70, 0xf4, 0xb1, 0xfe, 0xa6, 0x1f, 0x98, 0x20,
0xa3, 0xa0, 0x7c, 0x54, 0xf5, 0xb6, 0xc0, 0xc6, 0x14, 0x40, 0xfb, 0xcf, 0xa0, 0xda, 0x53, 0x1f,
0x05, 0xc0, 0xf2, 0x14, 0x80, 0xf1, 0xb4, 0xf1, 0xb5, 0xb6, 0xf7, 0x8b, 0x01, 0xcd, 0xe7, 0x09,
0x11, 0x7d, 0x9f, 0x24, 0xa7, 0x1a, 0xe9, 0x0b, 0xa8, 0x87, 0x78, 0x54, 0x30, 0xbf, 0x43, 0x10,
0x8e, 0x18, 0xff, 0x18, 0xca, 0x3c, 0x2d, 0xf8, 0xbc, 0x34, 0xc5, 0xec, 0x20, 0x45, 0x2e, 0xcb,
0x3c, 0x1d, 0x39, 0x6d, 0x9e, 0xcb, 0xe9, 0x9f, 0xcb, 0xb0, 0xb4, 0xc5, 0xde, 0xad, 0xd7, 0x37,
0x60, 0x29, 0xe6, 0xaf, 0xa8, 0x08, 0x58, 0x12, 0xc6, 0x79, 0xc6, 0x7a, 0x3a, 0x25, 0x2c, 0xbf,
0x89, 0xe2, 0xd6, 0x40, 0xaa, 0x14, 0xf3, 0x34, 0x9d, 0x50, 0xd4, 0x57, 0xdf, 0x44, 0xf1, 0x48,
0x71, 0x03, 0xea, 0x1a, 0x51, 0x87, 0x58, 0x99, 0x2f, 0x44, 0x40, 0x1b, 0x5d, 0xda, 0x1b, 0x50,
0xd7, 0x47, 0x69, 0x84, 0xea, 0x9c, 0x08, 0x68, 0x83, 0x6b, 0xef, 0x0f, 0x03, 0xea, 0xdb, 0xbc,
0x9b, 0x12, 0xa1, 0x59, 0xda, 0x05, 0x27, 0xa6, 0x27, 0x32, 0x38, 0x37, 0x55, 0x4d, 0x65, 0x36,
0x56, 0x56, 0x2d, 0xb8, 0x20, 0xd8, 0x69, 0x67, 0x12, 0xa9, 0x3c, 0x0f, 0xd2, 0x12, 0xda, 0x6d,
0xbf, 0x99, 0x2f, 0xe6, 0x1c, 0xf9, 0xe2, 0x7d, 0x67, 0x80, 0x75, 0x44, 0x45, 0xf7, 0x9d, 0xdc,
0xf8, 0x7d, 0x58, 0x40, 0x5e, 0xb3, 0x8b, 0xe5, 0x15, 0x73, 0x1e, 0x62, 0x0b, 0x75, 0xd5, 0x82,
0x6d, 0xac, 0x19, 0x74, 0xe3, 0x2e, 0xba, 0x6f, 0xa0, 0xfb, 0xd7, 0xa7, 0x40, 0x0c, 0x35, 0xf5,
0xea, 0x20, 0xc5, 0xcc, 0xbf, 0x05, 0xd5, 0xb0, 0xc3, 0xe2, 0xa8, 0xe0, 0xec, 0xbd, 0x29, 0x86,
0xca, 0xc6, 0xd7, 0x5a, 0xde, 0x32, 0xd4, 0x0a, 0x6b, 0xb7, 0x0e, 0xb5, 0x56, 0xd2, 0x23, 0x31,
0x8b, 0x9c, 0x92, 0x5b, 0x03, 0x73, 0x9f, 0x4b, 0xc7, 0xf0, 0xfe, 0x32, 0x00, 0x74, 0x49, 0xa0,
0x53, 0xf7, 0xc6, 0x9c, 0xfa, 0x68, 0x0a, 0xf6, 0x48, 0xb5, 0x58, 0x16, 0x6e, 0x7d, 0x02, 0x15,
0x75, 0xd1, 0x67, 0x79, 0x85, 0x4a, 0x2a, 0x06, 0xbc, 0xcb, 0xa2, 0x7a, 0x67, 0xc7, 0x80, 0x5a,
0xde, 0x3d, 0xb0, 0x06, 0x67, 0x4d, 0x06, 0xd1, 0x04, 0x78, 0xc2, 0x4f, 0x59, 0x48, 0xe2, 0xcd,
0x24, 0x72, 0x0c, 0x77, 0x11, 0xec, 0xe2, 0xfb, 0x40, 0x38, 0x65, 0xef, 0x4f, 0x03, 0x16, 0xb5,
0xe1, 0xa6, 0x60, 0xb2, 0x73, 0x90, 0xfe, 0xe7, 0x9b, 0x7f, 0x00, 0x16, 0x51, 0x50, 0xc1, 0xb0,
0x4f, 0x5d, 0x9b, 0x62, 0x5c, 0x9c, 0x86, 0xc9, 0x57, 0x23, 0xc5, 0xd1, 0x3b, 0xb0, 0xa8, 0xf3,
0x9e, 0xa7, 0x54, 0x90, 0x24, 0x9a, 0xb7, 0x73, 0x35, 0xd0, 0xea, 0x40, 0x1b, 0x79, 0x3f, 0x1a,
0x83, 0x06, 0x86, 0x87, 0xe0, 0x95, 0x0d, 0xa8, 0x37, 0xce, 0x45, 0x7d, 0x79, 0x1e, 0xea, 0xdd,
0xb5, 0xb1, 0x12, 0x3b, 0x2b, 0x54, 0x55, 0x67, 0xbf, 0x97, 0xe1, 0xf2, 0x04, 0xe5, 0x8f, 0x7b,
0x24, 0x7e, 0x77, 0xbd, 0xf6, 0xff, 0xe6, 0xbf, 0x68, 0x39, 0x95, 0x73, 0x3d, 0x51, 0xd5, 0x73,
0x3d, 0x51, 0xff, 0x54, 0xa1, 0x82, 0x5c, 0x3d, 0x04, 0x5b, 0x52, 0xd1, 0x0d, 0xe8, 0xeb, 0x54,
0x14, 0x4c, 0x5d, 0x99, 0x82, 0x31, 0xe8, 0x6a, 0x6a, 0xfe, 0x92, 0x83, 0x0e, 0xf7, 0x08, 0x20,
0x57, 0x97, 0xa0, 0x8d, 0xf5, 0x55, 0xbf, 0xff, 0xb6, 0x16, 0xa3, 0xa6, 0xb3, 0x7c, 0xd8, 0x04,
0x36, 0xa0, 0xde, 0x66, 0x23, 0x7b, 0x73, 0xe6, 0x35, 0x8d, 0xba, 0xc1, 0x5e, 0xc9, 0x87, 0xf6,
0xa8, 0x8d, 0x6c, 0x43, 0x23, 0xd4, 0xaf, 0x87, 0x86, 0xd0, 0x6f, 0xd8, 0xb5, 0xa9, 0x37, 0x3d,
0x7c, 0x64, 0xf6, 0x4a, 0x7e, 0x3d, 0x1c, 0x7b, 0x73, 0x9e, 0x82, 0xa3, 0xa3, 0x10, 0x2a, 0x81,
0x34, 0x90, 0x26, 0xf3, 0x83, 0x59, 0xb1, 0x0c, 0x53, 0x6d, 0xaf, 0xe4, 0x37, 0xf3, 0xc9, 0x87,
0xfe, 0x10, 0x2e, 0x14, 0x51, 0x8d, 0xe1, 0x2d, 0x20, 0x9e, 0x37, 0x33, 0xb6, 0x71, 0xc0, 0xa5,
0xf6, 0x1b, 0xa3, 0x83, 0x84, 0xe5, 0x02, 0x71, 0x90, 0x95, 0x01, 0xed, 0x91, 0x78, 0x1c, 0xbf,
0x86, 0xf8, 0xb7, 0x66, 0xe2, 0x4f, 0x2b, 0x93, 0xbd, 0x92, 0x7f, 0xb9, 0x3d, 0xbb, 0x88, 0x46,
0x71, 0xe8, 0x53, 0xf1, 0x1c, 0xeb, 0x8c, 0x38, 0x86, 0xed, 0x62, 0x14, 0xc7, 0xa8, 0x83, 0x3c,
0x02, 0xc0, 0xe4, 0xd3, 0x50, 0xf6, 0xcc, 0x74, 0x19, 0x0e, 0x8d, 0x2a, 0x5d, 0x7a, 0xc3, 0x09,
0x72, 0x63, 0x58, 0xd5, 0x68, 0x0f, 0x67, 0x54, 0xf5, 0x20, 0x5d, 0xc2, 0xe1, 0xd7, 0xd6, 0x02,
0x54, 0x94, 0xa9, 0xf7, 0xb7, 0x01, 0x70, 0x4c, 0x43, 0xc9, 0xc5, 0xe6, 0xfe, 0xfe, 0xb3, 0x62,
0x0a, 0xd6, 0xde, 0xea, 0x5f, 0x14, 0x35, 0x05, 0xeb, 0x80, 0x26, 0xe6, 0xf3, 0xf2, 0xe4, 0x7c,
0x7e, 0x1f, 0x20, 0x15, 0x34, 0x62, 0x21, 0x91, 0x34, 0x3b, 0xeb, 0x91, 0x19, 0x53, 0x75, 0x3f,
0x07, 0x78, 0xa9, 0x7e, 0x47, 0x74, 0x7b, 0xaa, 0xcc, 0x24, 0x62, 0xf8, 0xcf, 0xe2, 0xdb, 0x2f,
0x87, 0xbf, 0x2f, 0x37, 0x60, 0x29, 0x8d, 0x49, 0x48, 0x3b, 0x3c, 0x8e, 0xa8, 0x08, 0x24, 0x39,
0xc5, 0x6c, 0xb5, 0xfd, 0xe6, 0x98, 0xf8, 0x88, 0x9c, 0x7a, 0xbf, 0x1a, 0x60, 0x1d, 0xc6, 0x24,
0xd9, 0xe7, 0x11, 0x8e, 0x6a, 0x3d, 0x8c, 0x38, 0x20, 0x49, 0x92, 0xbd, 0xa5, 0x25, 0x8e, 0x78,
0x51, 0xe4, 0x69, 0x9b, 0xcd, 0x24, 0xc9, 0xdc, 0x07, 0x13, 0xd1, 0xbe, 0xbd, 0xaf, 0x2b, 0xd3,
0xb1, 0x78, 0x57, 0xc1, 0xe1, 0xb9, 0x4c, 0x73, 0x19, 0x0c, 0xa8, 0x54, 0x74, 0x99, 0xab, 0xa6,
0xdf, 0xd4, 0xf2, 0xaf, 0x34, 0xa3, 0x99, 0xba, 0xa1, 0x84, 0x47, 0xf4, 0xe6, 0x6f, 0x06, 0x2c,
0xe8, 0x26, 0x37, 0xf9, 0x14, 0x2f, 0x41, 0x7d, 0x57, 0x50, 0x22, 0xa9, 0x38, 0xea, 0x90, 0xc4,
0x31, 0x5c, 0x07, 0x1a, 0x85, 0xe0, 0xf1, 0xcb, 0x9c, 0xc4, 0x4e, 0xd9, 0x6d, 0x80, 0xf5, 0x84,
0x66, 0x19, 0xee, 0x9b, 0xf8, 0x56, 0xd3, 0x2c, 0xd3, 0x9b, 0x15, 0xd7, 0x86, 0xaa, 0x5e, 0x56,
0x95, 0xde, 0x3e, 0x97, 0xfa, 0x6b, 0x41, 0x01, 0x1f, 0x0a, 0x7a, 0xc2, 0x5e, 0x3f, 0x25, 0x32,
0xec, 0x38, 0x35, 0x05, 0x7c, 0xc8, 0x33, 0x39, 0x94, 0x58, 0xca, 0x56, 0x2f, 0x6d, 0xb5, 0xc4,
0x42, 0x71, 0xc0, 0x5d, 0x80, 0x72, 0x2b, 0x71, 0xea, 0x4a, 0xb4, 0xcf, 0x65, 0x2b, 0x71, 0x1a,
0x37, 0x77, 0xa1, 0x3e, 0xf6, 0x36, 0xa8, 0x00, 0x9e, 0x27, 0x2f, 0x12, 0xfe, 0x2a, 0xd1, 0x03,
0xd1, 0x66, 0xa4, 0x86, 0x88, 0x1a, 0x98, 0xcf, 0xf2, 0xb6, 0x53, 0x56, 0x8b, 0xa7, 0x79, 0xec,
0x98, 0x6a, 0xb1, 0xc3, 0x7a, 0x4e, 0x05, 0x25, 0x3c, 0x72, 0xaa, 0x5b, 0x77, 0xbe, 0xbd, 0x7d,
0xca, 0x64, 0x27, 0x6f, 0xaf, 0x85, 0xbc, 0xbb, 0xae, 0xa9, 0xbe, 0xc5, 0x78, 0xb1, 0x5a, 0x67,
0x89, 0xa4, 0x22, 0x21, 0xf1, 0x3a, 0xb2, 0xbf, 0xae, 0xd8, 0x4f, 0xdb, 0xed, 0x05, 0xfc, 0xba,
0xf3, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x32, 0x23, 0x5b, 0x87, 0xb6, 0x0f, 0x00, 0x00,
// 1538 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcd, 0x73, 0xdb, 0x44,
0x14, 0xb7, 0xfc, 0x29, 0x3d, 0x3b, 0x8e, 0xaa, 0x0b, 0x6d, 0xd2, 0x36, 0x41, 0x74, 0x68, 0x28,
0xd3, 0x64, 0x4a, 0x4b, 0x33, 0x2d, 0x53, 0x68, 0x3e, 0xda, 0xd8, 0x43, 0x9b, 0x04, 0x35, 0xcd,
0x81, 0x8b, 0x66, 0x2d, 0xad, 0x6d, 0x4d, 0xe5, 0x5d, 0x75, 0x25, 0xb9, 0xf5, 0x99, 0x1b, 0x33,
0x1c, 0xf8, 0x03, 0xb8, 0xc2, 0x1d, 0x4e, 0x70, 0xe1, 0xc0, 0x95, 0x03, 0x47, 0xee, 0xfc, 0x23,
0xcc, 0xbe, 0x95, 0xbf, 0x3a, 0x76, 0xe3, 0x0c, 0x9d, 0xe1, 0xb6, 0xfb, 0xf6, 0xbd, 0xb7, 0xef,
0xfd, 0xf6, 0x7d, 0x2d, 0x40, 0x14, 0x12, 0xb6, 0x19, 0x09, 0x9e, 0x70, 0xeb, 0x42, 0x2f, 0x08,
0xfb, 0x69, 0xac, 0x76, 0x9b, 0xf2, 0x60, 0xa5, 0x16, 0x7b, 0x5d, 0xda, 0x23, 0x8a, 0x64, 0x7f,
0xaf, 0x41, 0xed, 0x80, 0x32, 0x2a, 0x02, 0xef, 0x94, 0x84, 0x29, 0xb5, 0x56, 0x41, 0x6f, 0x71,
0x1e, 0xba, 0x7d, 0x12, 0x5e, 0xd4, 0xd6, 0xb5, 0x0d, 0xbd, 0x91, 0x73, 0x2a, 0x92, 0x72, 0x4a,
0x42, 0xeb, 0x0a, 0x18, 0x01, 0x4b, 0xee, 0xde, 0xc1, 0xd3, 0xfc, 0xba, 0xb6, 0x51, 0x68, 0xe4,
0x1c, 0x1d, 0x49, 0xd9, 0x71, 0x3b, 0xe4, 0x24, 0xc1, 0xe3, 0xc2, 0xba, 0xb6, 0xa1, 0xc9, 0x63,
0x24, 0xc9, 0xe3, 0x35, 0x80, 0x38, 0x11, 0x01, 0xeb, 0xe0, 0x79, 0x71, 0x5d, 0xdb, 0x30, 0x1a,
0x39, 0xc7, 0x50, 0xb4, 0x53, 0x12, 0xee, 0x96, 0xa0, 0xd0, 0x27, 0xa1, 0xfd, 0xad, 0x06, 0xc6,
0x57, 0x29, 0x15, 0x83, 0x26, 0x6b, 0x73, 0xcb, 0x82, 0x62, 0xc2, 0xa3, 0x17, 0x68, 0x4c, 0xc1,
0xc1, 0xb5, 0xb5, 0x06, 0xd5, 0x1e, 0x4d, 0x44, 0xe0, 0xb9, 0xc9, 0x20, 0xa2, 0x78, 0x95, 0xe1,
0x80, 0x22, 0x9d, 0x0c, 0x22, 0x6a, 0x7d, 0x00, 0x4b, 0x31, 0x25, 0xc2, 0xeb, 0xba, 0x11, 0x11,
0xa4, 0x17, 0xab, 0xdb, 0x9c, 0x9a, 0x22, 0x1e, 0x23, 0x4d, 0x32, 0x09, 0x9e, 0x32, 0xdf, 0xf5,
0xa9, 0x17, 0xf4, 0x48, 0x78, 0xb1, 0x84, 0x57, 0xd4, 0x90, 0xb8, 0xaf, 0x68, 0xf6, 0x8f, 0x1a,
0xc0, 0x1e, 0x0f, 0xd3, 0x1e, 0x43, 0x6b, 0x2e, 0x81, 0xde, 0x0e, 0x68, 0xe8, 0xbb, 0x81, 0x9f,
0x59, 0x54, 0xc1, 0x7d, 0xd3, 0xb7, 0xee, 0x83, 0xe1, 0x93, 0x84, 0x28, 0x93, 0x24, 0x38, 0xf5,
0x4f, 0xae, 0x6c, 0x4e, 0xe1, 0x9f, 0x21, 0xbf, 0x4f, 0x12, 0x22, 0xad, 0x74, 0x74, 0x3f, 0x5b,
0x59, 0xd7, 0xa0, 0x1e, 0xc4, 0x6e, 0x24, 0x82, 0x1e, 0x11, 0x03, 0xf7, 0x05, 0x1d, 0xa0, 0x4f,
0xba, 0x53, 0x0b, 0xe2, 0x63, 0x45, 0xfc, 0x92, 0x0e, 0xac, 0x55, 0x30, 0x82, 0xd8, 0x25, 0x69,
0xc2, 0x9b, 0xfb, 0xe8, 0x91, 0xee, 0xe8, 0x41, 0xbc, 0x83, 0x7b, 0xfb, 0x8b, 0xa1, 0x9d, 0x8f,
0x5e, 0x47, 0xc2, 0xba, 0x05, 0xc5, 0x80, 0xb5, 0x39, 0xda, 0x58, 0x7d, 0xd3, 0x0e, 0x0c, 0x90,
0xb1, 0x53, 0x0e, 0xb2, 0xda, 0xbb, 0x60, 0x60, 0x08, 0xa0, 0xfc, 0xa7, 0x50, 0xea, 0xcb, 0x4d,
0xa6, 0x60, 0x6d, 0x86, 0x82, 0xc9, 0xb0, 0x71, 0x14, 0xb7, 0xfd, 0xb3, 0x06, 0xf5, 0xe7, 0x8c,
0x88, 0x81, 0x43, 0x58, 0x47, 0x69, 0xfa, 0x1c, 0xaa, 0x1e, 0x5e, 0xe5, 0x2e, 0x6e, 0x10, 0x78,
0x63, 0xc4, 0x3f, 0x82, 0x3c, 0x8f, 0x32, 0x3c, 0x2f, 0xcd, 0x10, 0x3b, 0x8a, 0x10, 0xcb, 0x3c,
0x8f, 0xc6, 0x46, 0x17, 0xce, 0x65, 0xf4, 0x4f, 0x79, 0x58, 0xde, 0x0d, 0xde, 0xad, 0xd5, 0xd7,
0x61, 0x39, 0xe4, 0xaf, 0xa8, 0x70, 0x03, 0xe6, 0x85, 0x69, 0x1c, 0xf4, 0x55, 0x48, 0xe8, 0x4e,
0x1d, 0xc9, 0xcd, 0x21, 0x55, 0x32, 0xa6, 0x51, 0x34, 0xc5, 0xa8, 0x9e, 0xbe, 0x8e, 0xe4, 0x31,
0xe3, 0x43, 0xa8, 0x2a, 0x8d, 0xca, 0xc5, 0xe2, 0x62, 0x2e, 0x02, 0xca, 0xa8, 0xd4, 0x7e, 0x08,
0x55, 0x75, 0x95, 0xd2, 0x50, 0x5a, 0x50, 0x03, 0xca, 0xe0, 0xda, 0xfe, 0x53, 0x83, 0xea, 0x1e,
0xef, 0x45, 0x44, 0x28, 0x94, 0x0e, 0xc0, 0x0c, 0x69, 0x3b, 0x71, 0xcf, 0x0d, 0x55, 0x5d, 0x8a,
0x4d, 0xa4, 0x55, 0x13, 0x2e, 0x88, 0xa0, 0xd3, 0x9d, 0xd6, 0x94, 0x5f, 0x44, 0xd3, 0x32, 0xca,
0xed, 0xbd, 0x19, 0x2f, 0x85, 0x05, 0xe2, 0xc5, 0xfe, 0x46, 0x03, 0xfd, 0x84, 0x8a, 0xde, 0x3b,
0x79, 0xf1, 0x6d, 0x28, 0x23, 0xae, 0xf1, 0xc5, 0xfc, 0x7a, 0x61, 0x11, 0x60, 0x33, 0x76, 0x59,
0x82, 0x0d, 0xcc, 0x19, 0x34, 0xe3, 0x0e, 0x9a, 0xaf, 0xa1, 0xf9, 0xd7, 0x66, 0xa8, 0x18, 0x71,
0xaa, 0xd5, 0x51, 0x84, 0x91, 0x7f, 0x13, 0x4a, 0x5e, 0x37, 0x08, 0xfd, 0x0c, 0xb3, 0xf7, 0x66,
0x08, 0x4a, 0x19, 0x47, 0x71, 0xd9, 0x6b, 0x50, 0xc9, 0xa4, 0xad, 0x2a, 0x54, 0x9a, 0xac, 0x4f,
0xc2, 0xc0, 0x37, 0x73, 0x56, 0x05, 0x0a, 0x87, 0x3c, 0x31, 0x35, 0xfb, 0x6f, 0x0d, 0x40, 0xa5,
0x04, 0x1a, 0x75, 0x77, 0xc2, 0xa8, 0x0f, 0x67, 0xe8, 0x1e, 0xb3, 0x66, 0xcb, 0xcc, 0xac, 0x8f,
0xa1, 0x28, 0x1f, 0xfa, 0x2c, 0xab, 0x90, 0x49, 0xfa, 0x80, 0x6f, 0x99, 0x65, 0xef, 0x7c, 0x1f,
0x90, 0xcb, 0xbe, 0x0b, 0xfa, 0xf0, 0xae, 0x69, 0x27, 0xea, 0x00, 0x4f, 0x78, 0x27, 0xf0, 0x48,
0xb8, 0xc3, 0x7c, 0x53, 0xb3, 0x96, 0xc0, 0xc8, 0xf6, 0x47, 0xc2, 0xcc, 0xdb, 0x7f, 0x69, 0xb0,
0xa4, 0x04, 0x77, 0x44, 0x90, 0x74, 0x8f, 0xa2, 0xff, 0xfc, 0xf2, 0xf7, 0x40, 0x27, 0x52, 0x95,
0x3b, 0xaa, 0x53, 0x57, 0x67, 0x08, 0x67, 0xb7, 0x61, 0xf0, 0x55, 0x48, 0x76, 0xf5, 0x3e, 0x2c,
0xa9, 0xb8, 0xe7, 0x11, 0x15, 0x84, 0xf9, 0x8b, 0x56, 0xae, 0x1a, 0x4a, 0x1d, 0x29, 0x21, 0xfb,
0x07, 0x6d, 0x58, 0xc0, 0xf0, 0x12, 0x7c, 0xb2, 0x21, 0xf4, 0xda, 0xb9, 0xa0, 0xcf, 0x2f, 0x02,
0xbd, 0xb5, 0x39, 0x91, 0x62, 0x67, 0xb9, 0x2a, 0xf3, 0xec, 0xf7, 0x3c, 0xac, 0x4c, 0x41, 0xfe,
0xa8, 0x4f, 0xc2, 0x77, 0x57, 0x6b, 0xff, 0x6f, 0xfc, 0xb3, 0x92, 0x53, 0x3c, 0x57, 0x8b, 0x2a,
0x9d, 0xab, 0x45, 0x7d, 0x27, 0x6b, 0x84, 0xdf, 0xce, 0x06, 0x97, 0xed, 0xf3, 0x35, 0xe7, 0x46,
0x2e, 0x53, 0x23, 0x3b, 0xc0, 0x79, 0x0b, 0x6c, 0x23, 0x37, 0x89, 0xf5, 0x70, 0x44, 0xfb, 0x43,
0x83, 0xca, 0x73, 0xbf, 0x8d, 0xcf, 0x67, 0xc3, 0x52, 0xea, 0xb7, 0xdd, 0x76, 0xca, 0x3c, 0x97,
0x91, 0x9e, 0xb2, 0xca, 0x70, 0xaa, 0xa9, 0xdf, 0x7e, 0x9c, 0x32, 0xef, 0x90, 0xf4, 0xa8, 0xf5,
0x19, 0x80, 0xe4, 0xc9, 0x86, 0x31, 0x55, 0x20, 0x2f, 0xcf, 0xaa, 0x6e, 0x43, 0x1f, 0x1d, 0x23,
0x1d, 0xb9, 0xbb, 0x0a, 0xc6, 0x2b, 0x12, 0xf7, 0xdc, 0x16, 0xf7, 0x07, 0xd9, 0xac, 0xa7, 0x4b,
0xc2, 0x2e, 0xf7, 0x07, 0x72, 0xea, 0x22, 0xa2, 0x83, 0x43, 0x97, 0x9c, 0xf2, 0x0a, 0x0b, 0x4c,
0x5d, 0x44, 0x74, 0xe4, 0x22, 0xb6, 0x7f, 0x29, 0x43, 0x11, 0x5d, 0xb8, 0x0f, 0x46, 0x42, 0x45,
0xcf, 0xa5, 0xaf, 0x23, 0x91, 0x81, 0xba, 0x3a, 0xc3, 0xba, 0x61, 0xaf, 0x90, 0x53, 0x6d, 0x32,
0xec, 0x1b, 0x0f, 0x00, 0x52, 0x19, 0xda, 0x4a, 0x58, 0x41, 0x7a, 0xf9, 0x6d, 0x85, 0x5b, 0xce,
0xbc, 0xe9, 0xa8, 0xb4, 0x3e, 0x84, 0x6a, 0x2b, 0x18, 0xcb, 0x17, 0xe6, 0x3e, 0xc9, 0xb8, 0xc6,
0xca, 0x27, 0x69, 0x8d, 0x8b, 0xf3, 0x1e, 0xd4, 0x3c, 0xd5, 0x93, 0x95, 0x0a, 0x35, 0x19, 0x5c,
0x9d, 0xf9, 0xaa, 0xa3, 0xd6, 0xdd, 0xc8, 0x39, 0x55, 0x6f, 0xa2, 0x93, 0x3f, 0x05, 0x53, 0x79,
0x21, 0x64, 0x5a, 0x2a, 0x45, 0x2a, 0x44, 0xdf, 0x9f, 0xe7, 0xcb, 0x28, 0x81, 0x1b, 0x39, 0xa7,
0x9e, 0x4e, 0x8f, 0x4f, 0xc7, 0x70, 0x21, 0xf3, 0x6a, 0x42, 0x5f, 0x19, 0xf5, 0xd9, 0x73, 0x7d,
0x9b, 0x54, 0xb8, 0xdc, 0x7a, 0x63, 0x20, 0x4b, 0x60, 0x2d, 0xd3, 0x38, 0xcc, 0x75, 0x97, 0xf6,
0x49, 0x38, 0xa9, 0xbf, 0x82, 0xfa, 0x6f, 0xce, 0xd5, 0x3f, 0xab, 0xf8, 0x34, 0x72, 0xce, 0x4a,
0x6b, 0x7e, 0x69, 0x1a, 0xfb, 0xa1, 0x6e, 0xc5, 0x7b, 0xf4, 0x33, 0xfc, 0x18, 0x15, 0xe1, 0xb1,
0x1f, 0xe3, 0xba, 0xfc, 0x00, 0x00, 0x73, 0x51, 0xa9, 0x32, 0xe6, 0x86, 0xcb, 0x68, 0x14, 0x97,
0xe1, 0xd2, 0x1f, 0xcd, 0xe5, 0xe3, 0x0c, 0x46, 0x79, 0x38, 0x23, 0x83, 0x87, 0xe1, 0xe2, 0x8d,
0x7f, 0x06, 0xdb, 0xa0, 0xcb, 0x54, 0x44, 0xf1, 0x2a, 0x8a, 0xaf, 0xcc, 0x4e, 0xc4, 0x4c, 0xb6,
0x92, 0xaa, 0xe5, 0x6e, 0x19, 0x8a, 0x52, 0xc8, 0xfe, 0x47, 0x03, 0x38, 0xa5, 0x5e, 0xc2, 0xc5,
0xce, 0xe1, 0xe1, 0xb3, 0xec, 0x53, 0xa2, 0xdc, 0x54, 0x3f, 0x46, 0xf9, 0x29, 0x51, 0x48, 0x4c,
0x7d, 0x97, 0xf2, 0xd3, 0xdf, 0xa5, 0x6d, 0x80, 0x48, 0x50, 0x3f, 0xf0, 0x48, 0x42, 0xe3, 0xb3,
0x7a, 0xfe, 0x04, 0xab, 0xac, 0x25, 0x2f, 0xe5, 0xef, 0x50, 0xd5, 0xb0, 0xe2, 0x5c, 0x04, 0x47,
0x5f, 0x48, 0xc7, 0x78, 0x39, 0xfa, 0x4d, 0x5e, 0x87, 0xe5, 0x28, 0x24, 0x1e, 0xed, 0xf2, 0xd0,
0xa7, 0xc2, 0x4d, 0x48, 0x07, 0xc3, 0xdc, 0x70, 0xea, 0x13, 0xe4, 0x13, 0xd2, 0xb1, 0x7f, 0xd5,
0x40, 0x3f, 0x0e, 0x09, 0x3b, 0xe4, 0x3e, 0xd6, 0xcd, 0x3e, 0x7a, 0xec, 0x12, 0xc6, 0xe2, 0xb7,
0x74, 0xa8, 0x31, 0x2e, 0x12, 0x75, 0x25, 0xb3, 0xc3, 0x58, 0x6c, 0xdd, 0x9b, 0xf2, 0xf6, 0xed,
0x6d, 0x56, 0x8a, 0x4e, 0xf8, 0xbb, 0x01, 0x26, 0x4f, 0x93, 0x28, 0x4d, 0xdc, 0x21, 0x94, 0x12,
0xae, 0xc2, 0x46, 0xc1, 0xa9, 0x2b, 0xfa, 0x63, 0x85, 0x68, 0x2c, 0x5f, 0x88, 0x71, 0x9f, 0xde,
0xf8, 0x4d, 0x83, 0xb2, 0xea, 0x39, 0xd3, 0x93, 0xd1, 0x32, 0x54, 0x0f, 0x04, 0x25, 0x09, 0x15,
0x27, 0x5d, 0xc2, 0x4c, 0xcd, 0x32, 0xa1, 0x96, 0x11, 0x1e, 0xbd, 0x4c, 0x49, 0x68, 0xe6, 0xad,
0x1a, 0xe8, 0x4f, 0x68, 0x1c, 0xe3, 0x79, 0x01, 0x47, 0x27, 0x1a, 0xc7, 0xea, 0xb0, 0x68, 0x19,
0x50, 0x52, 0xcb, 0x92, 0xe4, 0x3b, 0xe4, 0x89, 0xda, 0x95, 0xa5, 0xe2, 0x63, 0x41, 0xdb, 0xc1,
0xeb, 0xa7, 0x24, 0xf1, 0xba, 0x66, 0x45, 0x2a, 0x3e, 0xe6, 0x71, 0x32, 0xa2, 0xe8, 0x52, 0x56,
0x2d, 0x0d, 0xb9, 0xc4, 0x0c, 0x33, 0xc1, 0x2a, 0x43, 0xbe, 0xc9, 0xcc, 0xaa, 0x24, 0x1d, 0xf2,
0xa4, 0xc9, 0xcc, 0xda, 0x8d, 0x03, 0xa8, 0x4e, 0xb4, 0x6a, 0xe9, 0xc0, 0x73, 0xf6, 0x82, 0xf1,
0x57, 0x4c, 0xcd, 0xa7, 0x3b, 0xbe, 0x9c, 0xe9, 0x2a, 0x50, 0x78, 0x96, 0xb6, 0xcc, 0xbc, 0x5c,
0x3c, 0x4d, 0x43, 0xb3, 0x20, 0x17, 0xfb, 0x41, 0xdf, 0x2c, 0x22, 0x85, 0xfb, 0x66, 0x69, 0xf7,
0xf6, 0xd7, 0xb7, 0x3a, 0x41, 0xd2, 0x4d, 0x5b, 0x9b, 0x1e, 0xef, 0x6d, 0x29, 0xa8, 0x6f, 0x06,
0x3c, 0x5b, 0x6d, 0x05, 0x2c, 0xa1, 0x82, 0x91, 0x70, 0x0b, 0xd1, 0xdf, 0x92, 0xe8, 0x47, 0xad,
0x56, 0x19, 0x77, 0xb7, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x70, 0x80, 0xb8, 0x76, 0x45, 0x11,
0x00, 0x00,
}

25
internal/proto/root_coord.proto
View File

@ -9,6 +9,7 @@ import "internal.proto";
import "proxy.proto";
//import "data_coord.proto";
import "etcd_meta.proto";
import "schema.proto";
service RootCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
@ -133,6 +134,11 @@ service RootCoord {
rpc OperatePrivilege(milvus.OperatePrivilegeRequest) returns (common.Status) {}
rpc SelectGrant(milvus.SelectGrantRequest) returns (milvus.SelectGrantResponse) {}
rpc ListPolicy(internal.ListPolicyRequest) returns (internal.ListPolicyResponse) {}
// user defined function
rpc CreateFunction(milvus.CreateFunctionRequest) returns (common.Status){}
rpc DropFunction(milvus.DropFunctionRequest) returns (common.Status){}
rpc GetFunctionInfo(GetFunctionInfoRequest) returns (GetFunctionInfoResponse){}
}
message AllocTimestampRequest {
@ -210,3 +216,22 @@ message GetCredentialResponse {
string password = 3;
}
message GetFunctionInfoRequest {
common.MsgBase base = 1;
// The unique function name in rootcoord.(Required)
string function_name = 2;
}
message GetFunctionInfoResponse {
common.Status status = 1;
FunctionInfo info = 2;
}
message FunctionInfo {
// The unique function name in rootcoord.(Required)
string function_name = 2;
// wat file after base64.(Required)
string wat_body_base64 = 3;
// list of function parameter types.(Required)
repeated schema.DataType arg_types = 4;
}

468
internal/proto/rootcoordpb/root_coord.pb.go
View File

@ -9,6 +9,7 @@ import (
proto "github.com/golang/protobuf/proto"
commonpb "github.com/milvus-io/milvus/api/commonpb"
milvuspb "github.com/milvus-io/milvus/api/milvuspb"
schemapb "github.com/milvus-io/milvus/api/schemapb"
etcdpb "github.com/milvus-io/milvus/internal/proto/etcdpb"
internalpb "github.com/milvus-io/milvus/internal/proto/internalpb"
proxypb "github.com/milvus-io/milvus/internal/proto/proxypb"
@ -655,6 +656,159 @@ func (m *GetCredentialResponse) GetPassword() string {
return ""
}
type GetFunctionInfoRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
// The unique function name in rootcoord.(Required)
FunctionName string `protobuf:"bytes,2,opt,name=function_name,json=functionName,proto3" json:"function_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetFunctionInfoRequest) Reset() { *m = GetFunctionInfoRequest{} }
func (m *GetFunctionInfoRequest) String() string { return proto.CompactTextString(m) }
func (*GetFunctionInfoRequest) ProtoMessage() {}
func (*GetFunctionInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_4513485a144f6b06, []int{11}
}
func (m *GetFunctionInfoRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFunctionInfoRequest.Unmarshal(m, b)
}
func (m *GetFunctionInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetFunctionInfoRequest.Marshal(b, m, deterministic)
}
func (m *GetFunctionInfoRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetFunctionInfoRequest.Merge(m, src)
}
func (m *GetFunctionInfoRequest) XXX_Size() int {
return xxx_messageInfo_GetFunctionInfoRequest.Size(m)
}
func (m *GetFunctionInfoRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetFunctionInfoRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetFunctionInfoRequest proto.InternalMessageInfo
func (m *GetFunctionInfoRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *GetFunctionInfoRequest) GetFunctionName() string {
if m != nil {
return m.FunctionName
}
return ""
}
type GetFunctionInfoResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Info *FunctionInfo `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetFunctionInfoResponse) Reset() { *m = GetFunctionInfoResponse{} }
func (m *GetFunctionInfoResponse) String() string { return proto.CompactTextString(m) }
func (*GetFunctionInfoResponse) ProtoMessage() {}
func (*GetFunctionInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_4513485a144f6b06, []int{12}
}
func (m *GetFunctionInfoResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetFunctionInfoResponse.Unmarshal(m, b)
}
func (m *GetFunctionInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetFunctionInfoResponse.Marshal(b, m, deterministic)
}
func (m *GetFunctionInfoResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetFunctionInfoResponse.Merge(m, src)
}
func (m *GetFunctionInfoResponse) XXX_Size() int {
return xxx_messageInfo_GetFunctionInfoResponse.Size(m)
}
func (m *GetFunctionInfoResponse) XXX_DiscardUnknown() {
xxx_messageInfo_GetFunctionInfoResponse.DiscardUnknown(m)
}
var xxx_messageInfo_GetFunctionInfoResponse proto.InternalMessageInfo
func (m *GetFunctionInfoResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *GetFunctionInfoResponse) GetInfo() *FunctionInfo {
if m != nil {
return m.Info
}
return nil
}
type FunctionInfo struct {
// The unique function name in rootcoord.(Required)
FunctionName string `protobuf:"bytes,2,opt,name=function_name,json=functionName,proto3" json:"function_name,omitempty"`
// wat file after base64.(Required)
WatBodyBase64 string `protobuf:"bytes,3,opt,name=wat_body_base64,json=watBodyBase64,proto3" json:"wat_body_base64,omitempty"`
// list of function parameter types.(Required)
ArgTypes []schemapb.DataType `protobuf:"varint,4,rep,packed,name=arg_types,json=argTypes,proto3,enum=milvus.proto.schema.DataType" json:"arg_types,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *FunctionInfo) Reset() { *m = FunctionInfo{} }
func (m *FunctionInfo) String() string { return proto.CompactTextString(m) }
func (*FunctionInfo) ProtoMessage() {}
func (*FunctionInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_4513485a144f6b06, []int{13}
}
func (m *FunctionInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FunctionInfo.Unmarshal(m, b)
}
func (m *FunctionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_FunctionInfo.Marshal(b, m, deterministic)
}
func (m *FunctionInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_FunctionInfo.Merge(m, src)
}
func (m *FunctionInfo) XXX_Size() int {
return xxx_messageInfo_FunctionInfo.Size(m)
}
func (m *FunctionInfo) XXX_DiscardUnknown() {
xxx_messageInfo_FunctionInfo.DiscardUnknown(m)
}
var xxx_messageInfo_FunctionInfo proto.InternalMessageInfo
func (m *FunctionInfo) GetFunctionName() string {
if m != nil {
return m.FunctionName
}
return ""
}
func (m *FunctionInfo) GetWatBodyBase64() string {
if m != nil {
return m.WatBodyBase64
}
return ""
}
func (m *FunctionInfo) GetArgTypes() []schemapb.DataType {
if m != nil {
return m.ArgTypes
}
return nil
}
func init() {
proto.RegisterType((*AllocTimestampRequest)(nil), "milvus.proto.rootcoord.AllocTimestampRequest")
proto.RegisterType((*AllocTimestampResponse)(nil), "milvus.proto.rootcoord.AllocTimestampResponse")
@ -669,106 +823,120 @@ func init() {
proto.RegisterMapType((map[int64]*SegmentInfos)(nil), "milvus.proto.rootcoord.DescribeSegmentsResponse.SegmentInfosEntry")
proto.RegisterType((*GetCredentialRequest)(nil), "milvus.proto.rootcoord.GetCredentialRequest")
proto.RegisterType((*GetCredentialResponse)(nil), "milvus.proto.rootcoord.GetCredentialResponse")
proto.RegisterType((*GetFunctionInfoRequest)(nil), "milvus.proto.rootcoord.GetFunctionInfoRequest")
proto.RegisterType((*GetFunctionInfoResponse)(nil), "milvus.proto.rootcoord.GetFunctionInfoResponse")
proto.RegisterType((*FunctionInfo)(nil), "milvus.proto.rootcoord.FunctionInfo")
}
func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) }
var fileDescriptor_4513485a144f6b06 = []byte{
// 1496 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5b, 0x73, 0x13, 0x37,
0x14, 0xc6, 0x36, 0x49, 0xec, 0x63, 0xc7, 0x0e, 0x1a, 0x2e, 0xae, 0xa1, 0xd4, 0xb8, 0x14, 0xcc,
0xcd, 0xa1, 0x61, 0x86, 0x52, 0xde, 0x88, 0xcd, 0x04, 0x4f, 0x9b, 0x21, 0x5d, 0x43, 0x87, 0x5e,
0x18, 0x57, 0xde, 0x15, 0x8e, 0x26, 0xeb, 0x95, 0x59, 0xc9, 0xb9, 0x4c, 0x9f, 0x3a, 0xd3, 0xf7,
0xfe, 0xa5, 0x4e, 0xfb, 0x53, 0xfa, 0x47, 0x3a, 0x5a, 0xed, 0xca, 0xbb, 0xeb, 0x5d, 0x67, 0x03,
0xbc, 0x59, 0xda, 0x4f, 0xdf, 0x77, 0xf4, 0x49, 0x47, 0x47, 0x32, 0x6c, 0xb8, 0x8c, 0x89, 0xa1,
0xc9, 0x98, 0x6b, 0x75, 0xa6, 0x2e, 0x13, 0x0c, 0x5d, 0x9e, 0x50, 0xfb, 0x70, 0xc6, 0x55, 0xab,
0x23, 0x3f, 0x7b, 0x5f, 0x1b, 0x15, 0x93, 0x4d, 0x26, 0xcc, 0x51, 0xfd, 0x8d, 0x4a, 0x18, 0xd5,
0xa8, 0x52, 0x47, 0x10, 0xd7, 0xc1, 0xb6, 0xdf, 0x2e, 0x4f, 0x5d, 0x76, 0x7c, 0xe2, 0x37, 0x6a,
0x44, 0x98, 0xd6, 0x70, 0x42, 0x04, 0x56, 0x1d, 0xad, 0x21, 0x5c, 0x7a, 0x66, 0xdb, 0xcc, 0x7c,
0x45, 0x27, 0x84, 0x0b, 0x3c, 0x99, 0x1a, 0xe4, 0xfd, 0x8c, 0x70, 0x81, 0x1e, 0xc2, 0xf9, 0x11,
0xe6, 0xa4, 0x9e, 0x6b, 0xe6, 0xda, 0xe5, 0xad, 0x6b, 0x9d, 0x48, 0x24, 0xbe, 0xfc, 0x2e, 0x1f,
0x6f, 0x63, 0x4e, 0x0c, 0x0f, 0x89, 0x2e, 0xc2, 0x8a, 0xc9, 0x66, 0x8e, 0xa8, 0x17, 0x9a, 0xb9,
0xf6, 0xba, 0xa1, 0x1a, 0xad, 0x3f, 0x72, 0x70, 0x39, 0xae, 0xc0, 0xa7, 0xcc, 0xe1, 0x04, 0x3d,
0x82, 0x55, 0x2e, 0xb0, 0x98, 0x71, 0x5f, 0xe4, 0x6a, 0xa2, 0xc8, 0xc0, 0x83, 0x18, 0x3e, 0x14,
0x5d, 0x83, 0x92, 0x08, 0x98, 0xea, 0xf9, 0x66, 0xae, 0x7d, 0xde, 0x98, 0x77, 0xa4, 0xc4, 0xf0,
0x06, 0xaa, 0x5e, 0x08, 0xfd, 0xde, 0x27, 0x98, 0x5d, 0x3e, 0xcc, 0x6c, 0x43, 0x4d, 0x33, 0x7f,
0xcc, 0xac, 0xaa, 0x90, 0xef, 0xf7, 0x3c, 0xea, 0x82, 0x91, 0xef, 0xf7, 0x52, 0xe6, 0xf1, 0x4f,
0x1e, 0x2a, 0xfd, 0xc9, 0x94, 0xb9, 0xc2, 0x20, 0x7c, 0x66, 0x8b, 0x0f, 0xd3, 0xba, 0x02, 0x6b,
0x02, 0xf3, 0x83, 0x21, 0xb5, 0x7c, 0xc1, 0x55, 0xd9, 0xec, 0x5b, 0xe8, 0x0b, 0x28, 0x5b, 0x58,
0x60, 0x87, 0x59, 0x44, 0x7e, 0x2c, 0x78, 0x1f, 0x21, 0xe8, 0xea, 0x5b, 0xe8, 0x31, 0xac, 0x48,
0x0e, 0x52, 0x3f, 0xdf, 0xcc, 0xb5, 0xab, 0x5b, 0xcd, 0x44, 0x35, 0x15, 0xa0, 0xd4, 0x24, 0x86,
0x82, 0xa3, 0x06, 0x14, 0x39, 0x19, 0x4f, 0x88, 0x23, 0x78, 0x7d, 0xa5, 0x59, 0x68, 0x17, 0x0c,
0xdd, 0x46, 0x9f, 0x41, 0x11, 0xcf, 0x04, 0x1b, 0x52, 0x8b, 0xd7, 0x57, 0xbd, 0x6f, 0x6b, 0xb2,
0xdd, 0xb7, 0x38, 0xba, 0x0a, 0x25, 0x97, 0x1d, 0x0d, 0x95, 0x11, 0x6b, 0x5e, 0x34, 0x45, 0x97,
0x1d, 0x75, 0x65, 0x1b, 0x7d, 0x03, 0x2b, 0xd4, 0x79, 0xc7, 0x78, 0xbd, 0xd8, 0x2c, 0xb4, 0xcb,
0x5b, 0x37, 0x12, 0x63, 0xf9, 0x8e, 0x9c, 0xfc, 0x88, 0xed, 0x19, 0xd9, 0xc3, 0xd4, 0x35, 0x14,
0xbe, 0xf5, 0x57, 0x0e, 0xae, 0xf4, 0x08, 0x37, 0x5d, 0x3a, 0x22, 0x03, 0x3f, 0x8a, 0x0f, 0xdf,
0x16, 0x2d, 0xa8, 0x98, 0xcc, 0xb6, 0x89, 0x29, 0x28, 0x73, 0xf4, 0x12, 0x46, 0xfa, 0xd0, 0x75,
0x00, 0x7f, 0xba, 0xfd, 0x1e, 0xaf, 0x17, 0xbc, 0x49, 0x86, 0x7a, 0x5a, 0x33, 0xa8, 0xf9, 0x81,
0x48, 0xe2, 0xbe, 0xf3, 0x8e, 0x2d, 0xd0, 0xe6, 0x12, 0x68, 0x9b, 0x50, 0x9e, 0x62, 0x57, 0xd0,
0x88, 0x72, 0xb8, 0x4b, 0xe6, 0x8a, 0x96, 0xf1, 0x97, 0x73, 0xde, 0xd1, 0xfa, 0x2f, 0x0f, 0x15,
0x5f, 0x57, 0x6a, 0x72, 0xd4, 0x83, 0x92, 0x9c, 0xd3, 0x50, 0xfa, 0xe4, 0x5b, 0x70, 0xbb, 0x93,
0x7c, 0x02, 0x75, 0x62, 0x01, 0x1b, 0xc5, 0x51, 0x10, 0x7a, 0x0f, 0xca, 0xd4, 0xb1, 0xc8, 0xf1,
0x50, 0x2d, 0x4f, 0xde, 0x5b, 0x9e, 0x2f, 0xa3, 0x3c, 0xf2, 0x14, 0xea, 0x68, 0x6d, 0x8b, 0x1c,
0x7b, 0x1c, 0x40, 0x83, 0x9f, 0x1c, 0x11, 0xb8, 0x40, 0x8e, 0x85, 0x8b, 0x87, 0x61, 0xae, 0x82,
0xc7, 0xf5, 0xed, 0x29, 0x31, 0x79, 0x04, 0x9d, 0xe7, 0x72, 0xb4, 0xe6, 0xe6, 0xcf, 0x1d, 0xe1,
0x9e, 0x18, 0x35, 0x12, 0xed, 0x6d, 0xfc, 0x06, 0x17, 0x93, 0x80, 0x68, 0x03, 0x0a, 0x07, 0xe4,
0xc4, 0xb7, 0x5d, 0xfe, 0x44, 0x5b, 0xb0, 0x72, 0x28, 0xb7, 0x92, 0xe7, 0xf3, 0xc2, 0xde, 0xf0,
0x26, 0x34, 0x9f, 0x89, 0x82, 0x3e, 0xcd, 0x3f, 0xc9, 0xb5, 0xfe, 0xcd, 0x43, 0x7d, 0x71, 0xbb,
0x7d, 0xcc, 0x59, 0x91, 0x65, 0xcb, 0x8d, 0x61, 0xdd, 0x5f, 0xe8, 0x88, 0x75, 0xdb, 0x69, 0xd6,
0xa5, 0x45, 0x18, 0xf1, 0x54, 0x79, 0x58, 0xe1, 0xa1, 0xae, 0x06, 0x81, 0x0b, 0x0b, 0x90, 0x04,
0xf7, 0x9e, 0x46, 0xdd, 0xbb, 0x99, 0x65, 0x09, 0xc3, 0x2e, 0x5a, 0x70, 0x71, 0x87, 0x88, 0xae,
0x4b, 0x2c, 0xe2, 0x08, 0x8a, 0xed, 0x0f, 0x4f, 0xd8, 0x06, 0x14, 0x67, 0x5c, 0xd6, 0xc7, 0x89,
0x0a, 0xa6, 0x64, 0xe8, 0x76, 0xeb, 0xcf, 0x1c, 0x5c, 0x8a, 0xc9, 0x7c, 0xcc, 0x42, 0x2d, 0x91,
0x92, 0xdf, 0xa6, 0x98, 0xf3, 0x23, 0xe6, 0xaa, 0x83, 0xb6, 0x64, 0xe8, 0xf6, 0xd6, 0xdf, 0xd7,
0xa1, 0x64, 0x30, 0x26, 0xba, 0xd2, 0x12, 0x34, 0x05, 0x24, 0x63, 0x62, 0x93, 0x29, 0x73, 0x88,
0xa3, 0x0e, 0x56, 0x8e, 0x1e, 0x46, 0x03, 0xd0, 0x35, 0x7f, 0x11, 0xea, 0x5b, 0xd5, 0xb8, 0x95,
0x32, 0x22, 0x06, 0x6f, 0x9d, 0x43, 0x13, 0x4f, 0x51, 0xd6, 0xeb, 0x57, 0xd4, 0x3c, 0xe8, 0xee,
0x63, 0xc7, 0x21, 0xf6, 0x32, 0xc5, 0x18, 0x34, 0x50, 0x8c, 0x25, 0xbd, 0xdf, 0x18, 0x08, 0x97,
0x3a, 0xe3, 0xc0, 0xd9, 0xd6, 0x39, 0xf4, 0xde, 0x5b, 0x5b, 0xa9, 0x4e, 0xb9, 0xa0, 0x26, 0x0f,
0x04, 0xb7, 0xd2, 0x05, 0x17, 0xc0, 0x67, 0x94, 0x1c, 0xc2, 0x46, 0xd7, 0x25, 0x58, 0x90, 0xae,
0x4e, 0x1a, 0x74, 0x3f, 0x71, 0x68, 0x1c, 0x16, 0x08, 0x2d, 0xdb, 0x00, 0xad, 0x73, 0xe8, 0x17,
0xa8, 0xf6, 0x5c, 0x36, 0x0d, 0xd1, 0xdf, 0x4d, 0xa4, 0x8f, 0x82, 0x32, 0x92, 0x0f, 0x61, 0xfd,
0x05, 0xe6, 0x21, 0xee, 0x3b, 0x89, 0xdc, 0x11, 0x4c, 0x40, 0x7d, 0x23, 0x11, 0xba, 0xcd, 0x98,
0x1d, 0xb2, 0xe7, 0x08, 0x50, 0x70, 0x20, 0x84, 0x54, 0x3a, 0xc9, 0x33, 0x58, 0x00, 0x06, 0x52,
0x9b, 0x99, 0xf1, 0x5a, 0xf8, 0x35, 0x94, 0x95, 0xe1, 0xcf, 0x6c, 0x8a, 0x39, 0xba, 0xbd, 0x64,
0x49, 0x3c, 0x44, 0x46, 0xc3, 0x7e, 0x80, 0x92, 0x34, 0x5a, 0x91, 0x7e, 0x95, 0xba, 0x10, 0x67,
0xa1, 0x1c, 0x00, 0x3c, 0xb3, 0x05, 0x71, 0x15, 0xe7, 0xad, 0x44, 0xce, 0x39, 0x20, 0x23, 0xa9,
0x03, 0xb5, 0xc1, 0xbe, 0xbc, 0xe0, 0x04, 0xd6, 0x70, 0x74, 0x2f, 0x79, 0x43, 0x47, 0x51, 0x01,
0xfd, 0xfd, 0x6c, 0x60, 0x6d, 0xf7, 0x5b, 0xa8, 0x29, 0x33, 0xf7, 0x82, 0x4b, 0x43, 0x8a, 0x5e,
0x0c, 0x95, 0x71, 0x3a, 0x3f, 0xc1, 0xba, 0xb4, 0x75, 0x4e, 0x7e, 0x27, 0xd5, 0xfa, 0xb3, 0x52,
0xbf, 0x85, 0xca, 0x0b, 0xcc, 0xe7, 0xcc, 0xed, 0xb4, 0x0c, 0x58, 0x20, 0xce, 0x94, 0x00, 0x07,
0x50, 0x95, 0xae, 0xe9, 0xc1, 0x3c, 0x25, 0x7d, 0xa3, 0xa0, 0x40, 0xe2, 0x5e, 0x26, 0xac, 0x16,
0x23, 0x50, 0x91, 0xdf, 0x82, 0xd2, 0x9b, 0x32, 0x97, 0x30, 0x24, 0x10, 0xba, 0x93, 0x01, 0x19,
0x3a, 0x66, 0xab, 0xd1, 0x77, 0x18, 0x7a, 0x90, 0x56, 0x85, 0x13, 0x5f, 0x84, 0x8d, 0x4e, 0x56,
0xb8, 0x96, 0xfc, 0x15, 0xd6, 0xfc, 0xd7, 0x51, 0x3c, 0x43, 0x62, 0x83, 0xf5, 0xc3, 0xac, 0x71,
0xfb, 0x54, 0x9c, 0x66, 0xc7, 0x70, 0xe9, 0xf5, 0xd4, 0x92, 0xa7, 0xb3, 0xaa, 0x01, 0x41, 0x15,
0x8a, 0x6f, 0xb3, 0x79, 0xa5, 0x8b, 0xe2, 0x76, 0xf9, 0xf8, 0xb4, 0x6d, 0xe6, 0xc2, 0xe7, 0x7d,
0xe7, 0x10, 0xdb, 0xd4, 0x8a, 0x14, 0x81, 0x5d, 0x22, 0x70, 0x17, 0x9b, 0xfb, 0x24, 0x5e, 0xa3,
0xd4, 0x53, 0x3b, 0x3a, 0x44, 0x83, 0x33, 0x6e, 0xed, 0xdf, 0x01, 0xa9, 0x8c, 0x75, 0xde, 0xd1,
0xf1, 0xcc, 0xc5, 0x6a, 0xff, 0xa5, 0x55, 0xdf, 0x45, 0x68, 0x20, 0xf3, 0xf5, 0x19, 0x46, 0x84,
0x0a, 0x23, 0xec, 0x10, 0xb1, 0x4b, 0x84, 0x4b, 0xcd, 0xb4, 0x63, 0x6d, 0x0e, 0x48, 0x59, 0xb4,
0x04, 0x9c, 0x16, 0x18, 0xc0, 0xaa, 0x7a, 0x20, 0xa2, 0x56, 0xe2, 0xa0, 0xe0, 0x79, 0xbb, 0xac,
0x9c, 0xeb, 0x27, 0x70, 0x28, 0x5d, 0x77, 0x88, 0x08, 0x3d, 0x3c, 0x53, 0xd2, 0x35, 0x0a, 0x5a,
0x9e, 0xae, 0x71, 0xac, 0x16, 0x73, 0xa0, 0xf6, 0x3d, 0xe5, 0xfe, 0xc7, 0x57, 0x98, 0x1f, 0xa4,
0x1d, 0xd2, 0x31, 0xd4, 0xf2, 0x43, 0x7a, 0x01, 0x1c, 0x72, 0xac, 0x62, 0x10, 0xf9, 0xc1, 0xf7,
0x2d, 0xf5, 0xee, 0x1c, 0xfe, 0x67, 0xe0, 0xb4, 0x4d, 0xf6, 0x46, 0x5f, 0x80, 0xf4, 0x5d, 0x37,
0x5e, 0x18, 0xe7, 0x69, 0xa3, 0x21, 0xf2, 0x5a, 0x9e, 0x81, 0xd9, 0xcf, 0xca, 0x4f, 0xcd, 0x3c,
0x84, 0x8d, 0x1e, 0xb1, 0x49, 0x84, 0xf9, 0x7e, 0xca, 0x1d, 0x23, 0x0a, 0xcb, 0x98, 0x79, 0xfb,
0xb0, 0x2e, 0x97, 0x41, 0x8e, 0x7b, 0xcd, 0x89, 0xcb, 0x53, 0xea, 0x55, 0x04, 0x13, 0x50, 0xdf,
0xcd, 0x02, 0x0d, 0xed, 0xa1, 0xf5, 0xc8, 0x3b, 0x23, 0x3e, 0x8f, 0xf9, 0xa2, 0x26, 0xbd, 0x7a,
0x1a, 0x0f, 0x32, 0xa2, 0x43, 0x7b, 0x08, 0xd4, 0x72, 0x1b, 0xcc, 0x26, 0x29, 0x69, 0x3d, 0x07,
0x64, 0xb4, 0xeb, 0x25, 0x14, 0x65, 0xe9, 0xf6, 0x28, 0x6f, 0xa6, 0x56, 0xf6, 0x33, 0x10, 0xbe,
0x85, 0xda, 0xcb, 0x29, 0x71, 0xb1, 0x20, 0xd2, 0x2f, 0x8f, 0x37, 0x39, 0xb3, 0x62, 0xa8, 0xcc,
0xd7, 0x66, 0x18, 0x10, 0x79, 0x82, 0x2f, 0x31, 0x61, 0x0e, 0x58, 0x7e, 0xb6, 0x85, 0x71, 0xe1,
0xc3, 0x53, 0xf5, 0xcb, 0xc0, 0x96, 0x0a, 0x78, 0x91, 0x67, 0x10, 0x50, 0xb8, 0xf0, 0xb3, 0xc5,
0x9f, 0xfa, 0x9e, 0x4b, 0x0f, 0xa9, 0x4d, 0xc6, 0x24, 0x25, 0x03, 0xe2, 0xb0, 0x8c, 0x16, 0x8d,
0xa0, 0xac, 0x84, 0x77, 0x5c, 0xec, 0x08, 0xb4, 0x2c, 0x34, 0x0f, 0x11, 0xd0, 0xb6, 0x4f, 0x07,
0xea, 0x49, 0x98, 0x00, 0x32, 0x2d, 0xf6, 0x98, 0x4d, 0xcd, 0x93, 0xf8, 0x65, 0x47, 0x1f, 0x0d,
0x73, 0x48, 0xca, 0x65, 0x27, 0x11, 0x19, 0x88, 0x6c, 0x3f, 0xf9, 0xf9, 0xf1, 0x98, 0x8a, 0xfd,
0xd9, 0x48, 0x4e, 0x71, 0x53, 0x0d, 0x7c, 0x40, 0x99, 0xff, 0x6b, 0x33, 0x18, 0xbc, 0xe9, 0x71,
0x6d, 0xea, 0x04, 0x9a, 0x8e, 0x46, 0xab, 0x5e, 0xd7, 0xa3, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
0x19, 0x92, 0xda, 0x17, 0x8d, 0x17, 0x00, 0x00,
// 1673 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4b, 0x73, 0xdb, 0xb6,
0x16, 0x8e, 0x24, 0x3f, 0xa4, 0xa3, 0x97, 0x83, 0xc9, 0x43, 0x57, 0x49, 0xee, 0x55, 0x94, 0xdc,
0x44, 0x79, 0xc9, 0xa9, 0xd3, 0x49, 0xd3, 0xec, 0x62, 0x2b, 0x75, 0x34, 0xad, 0x1b, 0x97, 0x76,
0xda, 0xb4, 0x69, 0x86, 0x85, 0x48, 0x58, 0xe6, 0x98, 0x22, 0x18, 0x02, 0xb2, 0xad, 0xe9, 0xaa,
0x33, 0x5d, 0x74, 0xd7, 0x65, 0xff, 0x4f, 0xfb, 0x53, 0xba, 0xed, 0x8f, 0xe8, 0x80, 0x0f, 0x88,
0xa4, 0x48, 0x99, 0xb6, 0xb3, 0x23, 0x80, 0x0f, 0xdf, 0x77, 0xce, 0xc1, 0x39, 0x78, 0x10, 0x56,
0x1c, 0x4a, 0xb9, 0xaa, 0x51, 0xea, 0xe8, 0x5d, 0xdb, 0xa1, 0x9c, 0xa2, 0x2b, 0x23, 0xc3, 0x3c,
0x1c, 0x33, 0xaf, 0xd5, 0x15, 0xc3, 0xee, 0x68, 0xb3, 0xa2, 0xd1, 0xd1, 0x88, 0x5a, 0x5e, 0x7f,
0xb3, 0x12, 0x46, 0x35, 0x6b, 0x86, 0xc5, 0x89, 0x63, 0x61, 0xd3, 0x6f, 0x97, 0x6d, 0x87, 0x1e,
0x4f, 0xfc, 0x46, 0x9d, 0x70, 0x4d, 0x57, 0x47, 0x84, 0xe3, 0x60, 0x2e, 0xd3, 0xf6, 0xc9, 0xc8,
0x6f, 0xb5, 0x55, 0xb8, 0xfc, 0xc2, 0x34, 0xa9, 0xb6, 0x6b, 0x8c, 0x08, 0xe3, 0x78, 0x64, 0x2b,
0xe4, 0xc3, 0x98, 0x30, 0x8e, 0x1e, 0xc3, 0xc2, 0x00, 0x33, 0xd2, 0xc8, 0xb5, 0x72, 0x9d, 0xf2,
0xda, 0xf5, 0x6e, 0xc4, 0x2e, 0xdf, 0x98, 0x2d, 0x36, 0x5c, 0xc7, 0x8c, 0x28, 0x2e, 0x12, 0x5d,
0x82, 0x45, 0x8d, 0x8e, 0x2d, 0xde, 0x28, 0xb4, 0x72, 0x9d, 0xaa, 0xe2, 0x35, 0xda, 0xbf, 0xe4,
0xe0, 0x4a, 0x5c, 0x81, 0xd9, 0xd4, 0x62, 0x04, 0x3d, 0x81, 0x25, 0xc6, 0x31, 0x1f, 0x33, 0x5f,
0xe4, 0x5a, 0xa2, 0xc8, 0x8e, 0x0b, 0x51, 0x7c, 0x28, 0xba, 0x0e, 0x25, 0x1e, 0x30, 0x35, 0xf2,
0xad, 0x5c, 0x67, 0x41, 0x99, 0x76, 0xa4, 0xd8, 0xf0, 0x16, 0x6a, 0xae, 0x09, 0xfd, 0xde, 0x47,
0xf0, 0x2e, 0x1f, 0x66, 0x36, 0xa1, 0x2e, 0x99, 0xcf, 0xe3, 0x55, 0x0d, 0xf2, 0xfd, 0x9e, 0x4b,
0x5d, 0x50, 0xf2, 0xfd, 0x5e, 0x8a, 0x1f, 0x7f, 0xe6, 0xa1, 0xd2, 0x1f, 0xd9, 0xd4, 0xe1, 0x0a,
0x61, 0x63, 0x93, 0x9f, 0x4d, 0xeb, 0x2a, 0x2c, 0x73, 0xcc, 0x0e, 0x54, 0x43, 0xf7, 0x05, 0x97,
0x44, 0xb3, 0xaf, 0xa3, 0xff, 0x41, 0x59, 0xc7, 0x1c, 0x5b, 0x54, 0x27, 0x62, 0xb0, 0xe0, 0x0e,
0x42, 0xd0, 0xd5, 0xd7, 0xd1, 0x53, 0x58, 0x14, 0x1c, 0xa4, 0xb1, 0xd0, 0xca, 0x75, 0x6a, 0x6b,
0xad, 0x44, 0x35, 0xcf, 0x40, 0xa1, 0x49, 0x14, 0x0f, 0x8e, 0x9a, 0x50, 0x64, 0x64, 0x38, 0x22,
0x16, 0x67, 0x8d, 0xc5, 0x56, 0xa1, 0x53, 0x50, 0x64, 0x1b, 0xfd, 0x07, 0x8a, 0x78, 0xcc, 0xa9,
0x6a, 0xe8, 0xac, 0xb1, 0xe4, 0x8e, 0x2d, 0x8b, 0x76, 0x5f, 0x67, 0xe8, 0x1a, 0x94, 0x1c, 0x7a,
0xa4, 0x7a, 0x81, 0x58, 0x76, 0xad, 0x29, 0x3a, 0xf4, 0x68, 0x43, 0xb4, 0xd1, 0x67, 0xb0, 0x68,
0x58, 0x7b, 0x94, 0x35, 0x8a, 0xad, 0x42, 0xa7, 0xbc, 0x76, 0x33, 0xd1, 0x96, 0x2f, 0xc9, 0xe4,
0x5b, 0x6c, 0x8e, 0xc9, 0x36, 0x36, 0x1c, 0xc5, 0xc3, 0xb7, 0x7f, 0xcf, 0xc1, 0xd5, 0x1e, 0x61,
0x9a, 0x63, 0x0c, 0xc8, 0x8e, 0x6f, 0xc5, 0xd9, 0xd3, 0xa2, 0x0d, 0x15, 0x8d, 0x9a, 0x26, 0xd1,
0xb8, 0x41, 0x2d, 0xb9, 0x84, 0x91, 0x3e, 0xf4, 0x5f, 0x00, 0xdf, 0xdd, 0x7e, 0x8f, 0x35, 0x0a,
0xae, 0x93, 0xa1, 0x9e, 0xf6, 0x18, 0xea, 0xbe, 0x21, 0x82, 0xb8, 0x6f, 0xed, 0xd1, 0x19, 0xda,
0x5c, 0x02, 0x6d, 0x0b, 0xca, 0x36, 0x76, 0xb8, 0x11, 0x51, 0x0e, 0x77, 0x89, 0x5a, 0x91, 0x32,
0xfe, 0x72, 0x4e, 0x3b, 0xda, 0x7f, 0xe7, 0xa1, 0xe2, 0xeb, 0x0a, 0x4d, 0x86, 0x7a, 0x50, 0x12,
0x3e, 0xa9, 0x22, 0x4e, 0x7e, 0x08, 0xee, 0x76, 0x93, 0xf7, 0xa3, 0x6e, 0xcc, 0x60, 0xa5, 0x38,
0x08, 0x4c, 0xef, 0x41, 0xd9, 0xb0, 0x74, 0x72, 0xac, 0x7a, 0xcb, 0x93, 0x77, 0x97, 0xe7, 0x56,
0x94, 0x47, 0xec, 0x49, 0x5d, 0xa9, 0xad, 0x93, 0x63, 0x97, 0x03, 0x8c, 0xe0, 0x93, 0x21, 0x02,
0x17, 0xc9, 0x31, 0x77, 0xb0, 0x1a, 0xe6, 0x2a, 0xb8, 0x5c, 0x9f, 0x9f, 0x60, 0x93, 0x4b, 0xd0,
0x7d, 0x29, 0x66, 0x4b, 0x6e, 0xf6, 0xd2, 0xe2, 0xce, 0x44, 0xa9, 0x93, 0x68, 0x6f, 0xf3, 0x27,
0xb8, 0x94, 0x04, 0x44, 0x2b, 0x50, 0x38, 0x20, 0x13, 0x3f, 0xec, 0xe2, 0x13, 0xad, 0xc1, 0xe2,
0xa1, 0x48, 0x25, 0x37, 0xce, 0x33, 0xb9, 0xe1, 0x3a, 0x34, 0xf5, 0xc4, 0x83, 0x3e, 0xcf, 0x3f,
0xcb, 0xb5, 0xff, 0xca, 0x43, 0x63, 0x36, 0xdd, 0xce, 0xb3, 0x57, 0x64, 0x49, 0xb9, 0x21, 0x54,
0xfd, 0x85, 0x8e, 0x84, 0x6e, 0x3d, 0x2d, 0x74, 0x69, 0x16, 0x46, 0x62, 0xea, 0xc5, 0xb0, 0xc2,
0x42, 0x5d, 0x4d, 0x02, 0x17, 0x67, 0x20, 0x09, 0xd1, 0x7b, 0x1e, 0x8d, 0xde, 0xed, 0x2c, 0x4b,
0x18, 0x8e, 0xa2, 0x0e, 0x97, 0x36, 0x09, 0xdf, 0x70, 0x88, 0x4e, 0x2c, 0x6e, 0x60, 0xf3, 0xec,
0x05, 0xdb, 0x84, 0xe2, 0x98, 0x89, 0xd3, 0x72, 0xe4, 0x19, 0x53, 0x52, 0x64, 0xbb, 0xfd, 0x6b,
0x0e, 0x2e, 0xc7, 0x64, 0xce, 0xb3, 0x50, 0x73, 0xa4, 0xc4, 0x98, 0x8d, 0x19, 0x3b, 0xa2, 0x8e,
0xb7, 0xd1, 0x96, 0x14, 0xd9, 0x6e, 0x53, 0xb8, 0xb2, 0x49, 0xf8, 0x17, 0x63, 0xcb, 0x5b, 0x4d,
0x91, 0x50, 0x67, 0x76, 0xf7, 0x16, 0x54, 0xf7, 0x7c, 0x22, 0x35, 0x64, 0x48, 0x25, 0xe8, 0xfc,
0x5a, 0xf8, 0xfd, 0x5b, 0x0e, 0xae, 0xce, 0x28, 0x9e, 0xc7, 0xf3, 0x67, 0xb0, 0xe0, 0x6e, 0x22,
0x27, 0xac, 0x76, 0x44, 0xd0, 0x9d, 0xd1, 0xfe, 0x23, 0x07, 0x95, 0x70, 0x77, 0x26, 0x07, 0xd0,
0x1d, 0xa8, 0x1f, 0x61, 0xae, 0x0e, 0xa8, 0x3e, 0x51, 0x85, 0xdb, 0x4f, 0x3f, 0xf5, 0x83, 0x5a,
0x3d, 0xc2, 0x7c, 0x9d, 0xea, 0x93, 0x75, 0xb7, 0x13, 0x3d, 0x87, 0x12, 0x76, 0x86, 0x2a, 0x9f,
0xd8, 0x84, 0x35, 0x16, 0x5a, 0x85, 0x4e, 0x6d, 0xed, 0x46, 0xd4, 0x38, 0xff, 0x72, 0xd4, 0xc3,
0x1c, 0xef, 0x4e, 0x6c, 0xa2, 0x14, 0xb1, 0x33, 0x14, 0x1f, 0x6c, 0xed, 0x9f, 0x16, 0x94, 0x14,
0x4a, 0xf9, 0x86, 0x30, 0x1d, 0xd9, 0x80, 0x44, 0xa6, 0xd0, 0x91, 0x4d, 0x2d, 0x62, 0x79, 0xc7,
0x1d, 0x43, 0x8f, 0xa3, 0x64, 0xf2, 0x5e, 0x36, 0x0b, 0xf5, 0x57, 0xb4, 0x79, 0x27, 0x65, 0x46,
0x0c, 0xde, 0xbe, 0x80, 0x46, 0xae, 0xa2, 0xb8, 0x45, 0xed, 0x1a, 0xda, 0xc1, 0xc6, 0x3e, 0xb6,
0x2c, 0x62, 0xce, 0x53, 0x8c, 0x41, 0x03, 0xc5, 0xd8, 0x56, 0xec, 0x37, 0x76, 0xb8, 0x63, 0x58,
0xc3, 0x60, 0xd5, 0xdb, 0x17, 0xd0, 0x07, 0xb7, 0xe2, 0x84, 0xba, 0xc1, 0xb8, 0xa1, 0xb1, 0x40,
0x70, 0x2d, 0x5d, 0x70, 0x06, 0x7c, 0x4a, 0x49, 0x15, 0x56, 0x36, 0x1c, 0x82, 0x39, 0xd9, 0x90,
0x5b, 0x19, 0x7a, 0x98, 0x38, 0x35, 0x0e, 0x0b, 0x84, 0xe6, 0x25, 0x67, 0xfb, 0x02, 0x7a, 0x07,
0xb5, 0x9e, 0x43, 0xed, 0x10, 0xfd, 0xfd, 0x44, 0xfa, 0x28, 0x28, 0x23, 0xb9, 0x0a, 0xd5, 0x57,
0x98, 0x85, 0xb8, 0xef, 0x25, 0x72, 0x47, 0x30, 0x01, 0xf5, 0xcd, 0x44, 0xe8, 0x3a, 0xa5, 0x66,
0x28, 0x3c, 0x47, 0x80, 0x82, 0x6d, 0x3a, 0xa4, 0xd2, 0x4d, 0xf6, 0x60, 0x06, 0x18, 0x48, 0xad,
0x66, 0xc6, 0x4b, 0xe1, 0x37, 0x50, 0xf6, 0x02, 0xfe, 0xc2, 0x34, 0x30, 0x43, 0x77, 0xe7, 0x2c,
0x89, 0x8b, 0xc8, 0x18, 0xb0, 0x6f, 0xa0, 0x24, 0x02, 0xed, 0x91, 0xfe, 0x3f, 0x75, 0x21, 0x4e,
0x43, 0xb9, 0x03, 0xf0, 0xc2, 0xe4, 0xc4, 0xf1, 0x38, 0xef, 0x24, 0x72, 0x4e, 0x01, 0x19, 0x49,
0x2d, 0xa8, 0xef, 0xec, 0x8b, 0x6b, 0x67, 0x10, 0x1a, 0x86, 0x1e, 0x24, 0x27, 0x74, 0x14, 0x15,
0xd0, 0x3f, 0xcc, 0x06, 0x96, 0xe1, 0x7e, 0x0f, 0x75, 0x2f, 0x98, 0xdb, 0xc1, 0x55, 0x2e, 0x45,
0x2f, 0x86, 0xca, 0xe8, 0xce, 0xf7, 0x50, 0x15, 0x61, 0x9d, 0x92, 0xdf, 0x4b, 0x0d, 0xfd, 0x69,
0xa9, 0xdf, 0x43, 0xe5, 0x15, 0x66, 0x53, 0xe6, 0x4e, 0x5a, 0x05, 0xcc, 0x10, 0x67, 0x2a, 0x80,
0x03, 0xa8, 0x89, 0xa8, 0xc9, 0xc9, 0x2c, 0xa5, 0x7c, 0xa3, 0xa0, 0x40, 0xe2, 0x41, 0x26, 0xac,
0x14, 0x23, 0x50, 0x11, 0x63, 0xc1, 0x85, 0x28, 0xc5, 0x97, 0x30, 0x24, 0x10, 0xba, 0x97, 0x01,
0x19, 0xda, 0x66, 0x6b, 0xd1, 0xd7, 0x31, 0x7a, 0x94, 0x76, 0x5a, 0x26, 0xbe, 0xd3, 0x9b, 0xdd,
0xac, 0x70, 0x29, 0xf9, 0x23, 0x2c, 0xfb, 0x6f, 0xd6, 0x78, 0x85, 0xc4, 0x26, 0xcb, 0xe7, 0x72,
0xf3, 0xee, 0x89, 0x38, 0xc9, 0x8e, 0xe1, 0xf2, 0x1b, 0x5b, 0x17, 0xbb, 0xb3, 0x77, 0x06, 0x04,
0xa7, 0x50, 0x3c, 0xcd, 0xa6, 0x27, 0x5d, 0x14, 0xb7, 0xc5, 0x86, 0x27, 0xa5, 0x99, 0x03, 0x37,
0xfa, 0xd6, 0x21, 0x36, 0x0d, 0x3d, 0x72, 0x08, 0x6c, 0x11, 0x8e, 0x37, 0xb0, 0xb6, 0x4f, 0xe2,
0x67, 0x94, 0xf7, 0x3b, 0x24, 0x3a, 0x45, 0x82, 0x33, 0xa6, 0xf6, 0xcf, 0x80, 0xbc, 0x8a, 0xb5,
0xf6, 0x8c, 0xe1, 0xd8, 0xc1, 0x5e, 0xfe, 0xa5, 0x9d, 0xbe, 0xb3, 0xd0, 0x40, 0xe6, 0x93, 0x53,
0xcc, 0x08, 0x1d, 0x8c, 0xb0, 0x49, 0xf8, 0x16, 0xe1, 0x8e, 0xa1, 0xa5, 0x6d, 0x6b, 0x53, 0x40,
0xca, 0xa2, 0x25, 0xe0, 0xa4, 0xc0, 0x0e, 0x2c, 0x79, 0xcf, 0x76, 0xd4, 0x4e, 0x9c, 0x14, 0xfc,
0x74, 0x98, 0x77, 0x9c, 0xcb, 0x1f, 0x13, 0xa1, 0x72, 0xdd, 0x24, 0x3c, 0xf4, 0x3b, 0x20, 0xa5,
0x5c, 0xa3, 0xa0, 0xf9, 0xe5, 0x1a, 0xc7, 0x4a, 0x31, 0x0b, 0xea, 0x5f, 0x19, 0xcc, 0x1f, 0xdc,
0xc5, 0xec, 0x20, 0x6d, 0x93, 0x8e, 0xa1, 0xe6, 0x6f, 0xd2, 0x33, 0xe0, 0x50, 0xc4, 0x2a, 0x0a,
0x11, 0x03, 0x7e, 0xdc, 0x52, 0xef, 0xb8, 0xe1, 0xff, 0x35, 0x27, 0x25, 0xd9, 0x5b, 0x79, 0x01,
0x92, 0x2f, 0x90, 0xf8, 0xc1, 0x38, 0x2d, 0x1b, 0x09, 0x11, 0xd7, 0xe4, 0x0c, 0xcc, 0x7e, 0x55,
0x7e, 0x6c, 0x66, 0x15, 0x56, 0x7a, 0xc4, 0x24, 0x11, 0xe6, 0x87, 0x29, 0x77, 0x8c, 0x28, 0x2c,
0x63, 0xe5, 0xed, 0x43, 0x55, 0x2c, 0x83, 0x98, 0xf7, 0x86, 0x11, 0x87, 0xa5, 0x9c, 0x57, 0x11,
0x4c, 0x40, 0x7d, 0x3f, 0x0b, 0x34, 0x94, 0x43, 0xd5, 0xc8, 0xeb, 0x2f, 0xee, 0xc7, 0x74, 0x51,
0x93, 0xde, 0xa2, 0xcd, 0x47, 0x19, 0xd1, 0xa1, 0x1c, 0x02, 0x6f, 0xb9, 0x15, 0x6a, 0x92, 0x94,
0xb2, 0x9e, 0x02, 0x32, 0x86, 0xeb, 0x35, 0x14, 0xc5, 0xd1, 0xed, 0x52, 0xde, 0x4e, 0x3d, 0xd9,
0x4f, 0x41, 0xf8, 0x1e, 0xea, 0xaf, 0x6d, 0xe2, 0x60, 0x4e, 0x44, 0xbc, 0x5c, 0xde, 0xe4, 0xca,
0x8a, 0xa1, 0x32, 0x5f, 0x9b, 0x61, 0x87, 0x88, 0x1d, 0x7c, 0x4e, 0x10, 0xa6, 0x80, 0xf9, 0x7b,
0x5b, 0x18, 0x17, 0xde, 0x3c, 0xbd, 0x7e, 0x61, 0xd8, 0x5c, 0x01, 0xd7, 0xf2, 0x0c, 0x02, 0x1e,
0x2e, 0xfc, 0x6c, 0xf1, 0x5d, 0xdf, 0x76, 0x8c, 0x43, 0xc3, 0x24, 0x43, 0x92, 0x52, 0x01, 0x71,
0x58, 0xc6, 0x10, 0x0d, 0xa0, 0xec, 0x09, 0x6f, 0x3a, 0xd8, 0xe2, 0x68, 0x9e, 0x69, 0x2e, 0x22,
0xa0, 0xed, 0x9c, 0x0c, 0x94, 0x4e, 0x68, 0x00, 0xa2, 0x2c, 0xb6, 0xa9, 0x69, 0x68, 0x93, 0xf8,
0x65, 0x47, 0x6e, 0x0d, 0x53, 0x48, 0xca, 0x65, 0x27, 0x11, 0x29, 0x45, 0xde, 0x41, 0xcd, 0xcb,
0xe7, 0xe0, 0x85, 0x9f, 0x72, 0x22, 0x44, 0x41, 0x19, 0xa3, 0xf4, 0x1d, 0x54, 0x44, 0x66, 0x4b,
0xea, 0x4e, 0x6a, 0xf2, 0x9f, 0x92, 0x98, 0x43, 0x3d, 0xf6, 0x73, 0x04, 0x75, 0xe7, 0x94, 0x7a,
0xc2, 0x7f, 0x9b, 0xf8, 0xa3, 0x6b, 0x0e, 0x3e, 0x88, 0xd5, 0xfa, 0xb3, 0x1f, 0x9e, 0x0e, 0x0d,
0xbe, 0x3f, 0x1e, 0x08, 0x7b, 0x56, 0xbd, 0xe9, 0x8f, 0x0c, 0xea, 0x7f, 0xad, 0x06, 0x81, 0x5e,
0x75, 0x19, 0x57, 0x25, 0xa3, 0x3d, 0x18, 0x2c, 0xb9, 0x5d, 0x4f, 0xfe, 0x0d, 0x00, 0x00, 0xff,
0xff, 0x97, 0xa2, 0x6e, 0x4c, 0x5d, 0x1a, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -874,6 +1042,10 @@ type RootCoordClient interface {
OperatePrivilege(ctx context.Context, in *milvuspb.OperatePrivilegeRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
SelectGrant(ctx context.Context, in *milvuspb.SelectGrantRequest, opts ...grpc.CallOption) (*milvuspb.SelectGrantResponse, error)
ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest, opts ...grpc.CallOption) (*internalpb.ListPolicyResponse, error)
// user defined function
CreateFunction(ctx context.Context, in *milvuspb.CreateFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
DropFunction(ctx context.Context, in *milvuspb.DropFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
GetFunctionInfo(ctx context.Context, in *GetFunctionInfoRequest, opts ...grpc.CallOption) (*GetFunctionInfoResponse, error)
}
type rootCoordClient struct {
@ -1235,6 +1407,33 @@ func (c *rootCoordClient) ListPolicy(ctx context.Context, in *internalpb.ListPol
return out, nil
}
func (c *rootCoordClient) CreateFunction(ctx context.Context, in *milvuspb.CreateFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/CreateFunction", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *rootCoordClient) DropFunction(ctx context.Context, in *milvuspb.DropFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/DropFunction", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *rootCoordClient) GetFunctionInfo(ctx context.Context, in *GetFunctionInfoRequest, opts ...grpc.CallOption) (*GetFunctionInfoResponse, error) {
out := new(GetFunctionInfoResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/GetFunctionInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// RootCoordServer is the server API for RootCoord service.
type RootCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
@ -1328,6 +1527,10 @@ type RootCoordServer interface {
OperatePrivilege(context.Context, *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)
SelectGrant(context.Context, *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)
ListPolicy(context.Context, *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)
// user defined function
CreateFunction(context.Context, *milvuspb.CreateFunctionRequest) (*commonpb.Status, error)
DropFunction(context.Context, *milvuspb.DropFunctionRequest) (*commonpb.Status, error)
GetFunctionInfo(context.Context, *GetFunctionInfoRequest) (*GetFunctionInfoResponse, error)
}
// UnimplementedRootCoordServer can be embedded to have forward compatible implementations.
@ -1451,6 +1654,15 @@ func (*UnimplementedRootCoordServer) SelectGrant(ctx context.Context, req *milvu
func (*UnimplementedRootCoordServer) ListPolicy(ctx context.Context, req *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ListPolicy not implemented")
}
func (*UnimplementedRootCoordServer) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateFunction not implemented")
}
func (*UnimplementedRootCoordServer) DropFunction(ctx context.Context, req *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method DropFunction not implemented")
}
func (*UnimplementedRootCoordServer) GetFunctionInfo(ctx context.Context, req *GetFunctionInfoRequest) (*GetFunctionInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetFunctionInfo not implemented")
}
func RegisterRootCoordServer(s *grpc.Server, srv RootCoordServer) {
s.RegisterService(&_RootCoord_serviceDesc, srv)
@ -2158,6 +2370,60 @@ func _RootCoord_ListPolicy_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _RootCoord_CreateFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.CreateFunctionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).CreateFunction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/CreateFunction",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).CreateFunction(ctx, req.(*milvuspb.CreateFunctionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RootCoord_DropFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(milvuspb.DropFunctionRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).DropFunction(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/DropFunction",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).DropFunction(ctx, req.(*milvuspb.DropFunctionRequest))
}
return interceptor(ctx, in, info, handler)
}
func _RootCoord_GetFunctionInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetFunctionInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RootCoordServer).GetFunctionInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.rootcoord.RootCoord/GetFunctionInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).GetFunctionInfo(ctx, req.(*GetFunctionInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RootCoord_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.rootcoord.RootCoord",
HandlerType: (*RootCoordServer)(nil),
@ -2318,6 +2584,18 @@ var _RootCoord_serviceDesc = grpc.ServiceDesc{
MethodName: "ListPolicy",
Handler: _RootCoord_ListPolicy_Handler,
},
{
MethodName: "CreateFunction",
Handler: _RootCoord_CreateFunction_Handler,
},
{
MethodName: "DropFunction",
Handler: _RootCoord_DropFunction_Handler,
},
{
MethodName: "GetFunctionInfo",
Handler: _RootCoord_GetFunctionInfo_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "root_coord.proto",

275
internal/proxy/impl.go
View File

@ -23,6 +23,8 @@ import (
"os"
"strconv"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/golang/protobuf/proto"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
@ -2514,6 +2516,7 @@ func (node *Proxy) Search(ctx context.Context, request *milvuspb.SearchRequest)
},
request: request,
qc: node.queryCoord,
rc: node.rootCoord,
tr: timerecord.NewTimeRecorder("search"),
shardMgr: node.shardMgr,
}
@ -2757,6 +2760,7 @@ func (node *Proxy) Query(ctx context.Context, request *milvuspb.QueryRequest) (*
},
request: request,
qc: node.queryCoord,
rc: node.rootCoord,
queryShardPolicy: mergeRoundRobinPolicy,
shardMgr: node.shardMgr,
}
@ -2852,6 +2856,276 @@ func (node *Proxy) Query(ctx context.Context, request *milvuspb.QueryRequest) (*
return ret, nil
}
// CreateFunction create function, then you can use function in search.
func (node *Proxy) CreateFunction(ctx context.Context, request *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
return unhealthyStatus(), nil
}
sp, ctx := trace.StartSpanFromContextWithOperationName(ctx, "Proxy-CreateFunction")
defer sp.Finish()
traceID, _, _ := trace.InfoFromSpan(sp)
cft := &createFunctionTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
CreateFunctionRequest: request,
rootCoord: node.rootCoord,
}
method := "CreateFunction"
tr := timerecord.NewTimeRecorder(method)
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.TotalLabel).Inc()
log.Debug(
rpcReceived(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("functionName", request.FunctionName),
zap.String("WatBodyBase64", request.WatBodyBase64),
zap.String("ArgTypes", string(request.GetArgTypes())))
if err := node.sched.ddQueue.Enqueue(cft); err != nil {
log.Warn(
rpcFailedToEnqueue(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("functionName", request.FunctionName),
zap.String("WatBodyBase64", request.WatBodyBase64),
zap.String("ArgTypes", string(request.GetArgTypes())))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.AbandonLabel).Inc()
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug(
rpcEnqueued(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", cft.ID()),
zap.Uint64("BeginTs", cft.BeginTs()),
zap.Uint64("EndTs", cft.EndTs()),
zap.String("functionName", request.FunctionName),
zap.String("WatBodyBase64", request.WatBodyBase64),
zap.String("ArgTypes", string(request.GetArgTypes())))
if err := cft.WaitToFinish(); err != nil {
log.Warn(
rpcFailedToWaitToFinish(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", cft.ID()),
zap.Uint64("BeginTs", cft.BeginTs()),
zap.Uint64("EndTs", cft.EndTs()),
zap.String("FunctionName", request.FunctionName),
zap.String("WatBodyBase64", request.WatBodyBase64),
zap.String("ArgTypes", string(request.GetArgTypes())))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.FailLabel).Inc()
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug(
rpcDone(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", cft.ID()),
zap.Uint64("BeginTs", cft.BeginTs()),
zap.Uint64("EndTs", cft.EndTs()),
zap.String("FunctionName", request.FunctionName),
zap.String("WatBodyBase64", request.WatBodyBase64),
zap.String("ArgTypes", string(request.GetArgTypes())))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.SuccessLabel).Inc()
metrics.ProxyDDLReqLatency.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
return cft.result, nil
}
// DropFunction drop function by function name.
func (node *Proxy) DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
return unhealthyStatus(), nil
}
sp, ctx := trace.StartSpanFromContextWithOperationName(ctx, "Proxy-DropFunction")
defer sp.Finish()
traceID, _, _ := trace.InfoFromSpan(sp)
dft := &dropFunctionTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
DropFunctionRequest: request,
rootCoord: node.rootCoord,
}
method := "DropFunction"
tr := timerecord.NewTimeRecorder(method)
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.TotalLabel).Inc()
log.Debug(
rpcReceived(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("FunctionName", request.FunctionName))
if err := node.sched.ddQueue.Enqueue(dft); err != nil {
log.Warn(
rpcFailedToEnqueue(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("FunctionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.AbandonLabel).Inc()
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug(
rpcEnqueued(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", dft.ID()),
zap.Uint64("BeginTs", dft.BeginTs()),
zap.Uint64("EndTs", dft.EndTs()),
zap.String("FunctionName", request.FunctionName))
if err := dft.WaitToFinish(); err != nil {
log.Warn(
rpcFailedToWaitToFinish(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", dft.ID()),
zap.Uint64("BeginTs", dft.BeginTs()),
zap.Uint64("EndTs", dft.EndTs()),
zap.String("FunctionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.FailLabel).Inc()
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug(
rpcDone(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", dft.ID()),
zap.Uint64("BeginTs", dft.BeginTs()),
zap.Uint64("EndTs", dft.EndTs()),
zap.String("functionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.SuccessLabel).Inc()
metrics.ProxyDDLReqLatency.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
return dft.result, nil
}
// GetFunctionInfo get function information by function name, then use function in udf expression parser.
func (node *Proxy) GetFunctionInfo(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
sp, ctx := trace.StartSpanFromContextWithOperationName(ctx, "Proxy-GetFunctionInfo")
defer sp.Finish()
if !node.checkHealthy() {
return &rootcoordpb.GetFunctionInfoResponse{
Status: unhealthyStatus(),
}, nil
}
traceID, _, _ := trace.InfoFromSpan(sp)
gft := &getFunctionInfoTask{
ctx: ctx,
Condition: NewTaskCondition(ctx),
GetFunctionInfoRequest: request,
rootCoord: node.rootCoord,
}
method := "GetFunctionInfo"
tr := timerecord.NewTimeRecorder(method)
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.TotalLabel).Inc()
log.Debug(
rpcReceived(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("FunctionName", request.FunctionName))
if err := node.sched.ddQueue.Enqueue(gft); err != nil {
log.Warn(
rpcFailedToEnqueue(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.String("FunctionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.AbandonLabel).Inc()
return &rootcoordpb.GetFunctionInfoResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
log.Debug(
rpcEnqueued(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", gft.ID()),
zap.Uint64("BeginTs", gft.BeginTs()),
zap.Uint64("EndTs", gft.EndTs()),
zap.String("FunctionName", request.FunctionName))
if err := gft.WaitToFinish(); err != nil {
log.Warn(
rpcFailedToWaitToFinish(method),
zap.Error(err),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", gft.ID()),
zap.Uint64("BeginTs", gft.BeginTs()),
zap.Uint64("EndTs", gft.EndTs()),
zap.String("FunctionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.FailLabel).Inc()
return &rootcoordpb.GetFunctionInfoResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
},
}, nil
}
log.Debug(
rpcDone(method),
zap.String("traceID", traceID),
zap.String("role", typeutil.ProxyRole),
zap.Int64("MsgID", gft.ID()),
zap.Uint64("BeginTs", gft.BeginTs()),
zap.Uint64("EndTs", gft.EndTs()),
zap.String("FunctionName", request.FunctionName))
metrics.ProxyDDLFunctionCall.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method, metrics.SuccessLabel).Inc()
metrics.ProxyDDLReqLatency.WithLabelValues(strconv.FormatInt(Params.ProxyCfg.GetNodeID(), 10), method).Observe(float64(tr.ElapseSpan().Milliseconds()))
return gft.result, nil
}
// CreateAlias create alias for collection, then you can search the collection with alias.
func (node *Proxy) CreateAlias(ctx context.Context, request *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
if !node.checkHealthy() {
@ -3163,6 +3437,7 @@ func (node *Proxy) CalcDistance(ctx context.Context, request *milvuspb.CalcDista
},
request: queryRequest,
qc: node.queryCoord,
rc: node.rootCoord,
ids: ids.IdArray,
queryShardPolicy: mergeRoundRobinPolicy,

15
internal/proxy/rootcoord_mock_test.go
View File

@ -111,6 +111,21 @@ type RootCoordMock struct {
lastTsMtx sync.Mutex
}
func (coord *RootCoordMock) CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
//TODO (ziyu wang) implement me
panic("implement me")
}
func (coord *RootCoordMock) DropFunction(ctx context.Context, req *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
//TODO (ziyu wang) implement me
panic("implement me")
}
func (coord *RootCoordMock) GetFunctionInfo(ctx context.Context, req *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
//TODO (ziyu wang) implement me
panic("implement me")
}
func (coord *RootCoordMock) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {

211
internal/proxy/task.go
View File

@ -24,6 +24,8 @@ import (
"strconv"
"strings"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/golang/protobuf/proto"
@ -88,6 +90,9 @@ const (
CreateAliasTaskName = "CreateAliasTask"
DropAliasTaskName = "DropAliasTask"
AlterAliasTaskName = "AlterAliasTask"
CreateFunctionTaskName = "createFunctionTask"
DropFunctionTaskName = "DropFunctionTaskName"
GetFunctionInfoTaskName = "GetFunctionInfoTaskName"
// minFloat32 minimum float.
minFloat32 = -1 * float32(math.MaxFloat32)
@ -1339,7 +1344,7 @@ func (cit *createIndexTask) Execute(ctx context.Context) error {
Timestamp: cit.BeginTs(),
}
cit.result, err = cit.indexCoord.CreateIndex(ctx, req)
//cit.result, err = cit.rootCoord.CreateIndex(ctx, cit.CreateIndexRequest)
//cit.result, err = cit.rc.CreateIndex(ctx, cit.CreateIndexRequest)
if err != nil {
return err
}
@ -2746,3 +2751,207 @@ func (a *AlterAliasTask) Execute(ctx context.Context) error {
func (a *AlterAliasTask) PostExecute(ctx context.Context) error {
return nil
}
// createFunctionTask contains task information of CreateFunction
type createFunctionTask struct {
Condition
*milvuspb.CreateFunctionRequest
ctx context.Context
rootCoord types.RootCoord
result *commonpb.Status
}
func (c *createFunctionTask) TraceCtx() context.Context {
return c.ctx
}
func (c *createFunctionTask) ID() UniqueID {
return c.Base.MsgID
}
func (c *createFunctionTask) SetID(uid UniqueID) {
c.Base.MsgID = uid
}
func (c *createFunctionTask) Name() string {
return CreateFunctionTaskName
}
func (c *createFunctionTask) Type() commonpb.MsgType {
return c.Base.MsgType
}
func (c *createFunctionTask) BeginTs() Timestamp {
return c.Base.Timestamp
}
func (c *createFunctionTask) EndTs() Timestamp {
return c.Base.Timestamp
}
func (c *createFunctionTask) SetTs(ts Timestamp) {
c.Base.Timestamp = ts
}
func (c *createFunctionTask) OnEnqueue() error {
c.Base = &commonpb.MsgBase{}
return nil
}
func (c *createFunctionTask) PreExecute(ctx context.Context) error {
c.Base.MsgType = commonpb.MsgType_CreateFunction
c.Base.SourceID = Params.ProxyCfg.GetNodeID()
return nil
}
func (c *createFunctionTask) Execute(ctx context.Context) error {
var err error
c.result, err = c.rootCoord.CreateFunction(ctx, c.CreateFunctionRequest)
return err
}
func (c *createFunctionTask) PostExecute(ctx context.Context) error {
//TODO implement me
return nil
}
// dropFunctionTask contains task information of DropFunction
type dropFunctionTask struct {
Condition
*milvuspb.DropFunctionRequest
ctx context.Context
rootCoord types.RootCoord
result *commonpb.Status
}
// TraceCtx returns the context for trace
func (d *dropFunctionTask) TraceCtx() context.Context {
return d.ctx
}
// ID returns the MsgID
func (d *dropFunctionTask) ID() UniqueID {
return d.Base.MsgID
}
// SetID sets the MsgID
func (d *dropFunctionTask) SetID(uid UniqueID) {
d.Base.MsgID = uid
}
// Name returns the name of the task
func (d *dropFunctionTask) Name() string {
return DropFunctionTaskName
}
func (d *dropFunctionTask) Type() commonpb.MsgType {
return d.Base.MsgType
}
func (d *dropFunctionTask) BeginTs() Timestamp {
return d.Base.Timestamp
}
func (d *dropFunctionTask) EndTs() Timestamp {
return d.Base.Timestamp
}
func (d *dropFunctionTask) SetTs(ts Timestamp) {
d.Base.Timestamp = ts
}
func (d *dropFunctionTask) OnEnqueue() error {
d.Base = &commonpb.MsgBase{}
return nil
}
func (d *dropFunctionTask) PreExecute(ctx context.Context) error {
d.Base.MsgType = commonpb.MsgType_DropFunction
d.Base.SourceID = Params.ProxyCfg.GetNodeID()
return nil
}
func (d *dropFunctionTask) Execute(ctx context.Context) error {
var err error
d.result, err = d.rootCoord.DropFunction(ctx, d.DropFunctionRequest)
return err
}
func (d *dropFunctionTask) PostExecute(ctx context.Context) error {
return nil
}
type getFunctionInfoTask struct {
Condition
*rootcoordpb.GetFunctionInfoRequest
ctx context.Context
rootCoord types.RootCoord
result *rootcoordpb.GetFunctionInfoResponse
}
func (t *getFunctionInfoTask) TraceCtx() context.Context {
return t.ctx
}
func (t *getFunctionInfoTask) ID() UniqueID {
return t.Base.MsgID
}
func (t *getFunctionInfoTask) SetID(uid UniqueID) {
t.Base.MsgID = uid
}
func (t *getFunctionInfoTask) Name() string {
return GetFunctionInfoTaskName
}
func (t *getFunctionInfoTask) Type() commonpb.MsgType {
return t.Base.MsgType
}
func (t *getFunctionInfoTask) BeginTs() Timestamp {
return t.Base.Timestamp
}
func (t *getFunctionInfoTask) EndTs() Timestamp {
return t.Base.Timestamp
}
func (t *getFunctionInfoTask) SetTs(ts Timestamp) {
t.Base.Timestamp = ts
}
func (t *getFunctionInfoTask) OnEnqueue() error {
t.Base = &commonpb.MsgBase{}
return nil
}
func (t *getFunctionInfoTask) PreExecute(ctx context.Context) error {
t.Base.MsgType = commonpb.MsgType_GetFunctionInfo
t.Base.SourceID = Params.ProxyCfg.GetNodeID()
return nil
}
func (t *getFunctionInfoTask) Execute(ctx context.Context) error {
respFromRootCoord, err := t.rootCoord.GetFunctionInfo(ctx, t.GetFunctionInfoRequest)
if err != nil {
return err
}
if respFromRootCoord == nil {
return errors.New("failed to get function information")
}
if respFromRootCoord.Status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(respFromRootCoord.Status.Reason)
}
t.result = respFromRootCoord
return nil
}
func (t *getFunctionInfoTask) PostExecute(ctx context.Context) error {
return nil
}

3
internal/proxy/task_query.go
View File

@ -42,6 +42,7 @@ type queryTask struct {
result *milvuspb.QueryResults
request *milvuspb.QueryRequest
qc types.QueryCoord
rc types.RootCoord
ids *schemapb.IDs
collectionName string
queryParams *queryParams
@ -223,7 +224,7 @@ func (t *queryTask) PreExecute(ctx context.Context) error {
return fmt.Errorf("query expression is empty")
}
plan, err := planparserv2.CreateRetrievePlan(schema, t.request.Expr)
plan, err := planparserv2.CreateRetrievePlan(schema, t.request.Expr, planparserv2.ParserVisitorWithRootCoord(t.rc))
if err != nil {
return err
}

1
internal/proxy/task_query_test.go
View File

@ -132,6 +132,7 @@ func TestQueryTask_all(t *testing.T) {
Expr: expr,
},
qc: qc,
rc: rc,
shardMgr: mgr,
}

3
internal/proxy/task_search.go
View File

@ -40,6 +40,7 @@ type searchTask struct {
result *milvuspb.SearchResults
request *milvuspb.SearchRequest
qc types.QueryCoord
rc types.RootCoord
tr *timerecord.TimeRecorder
collectionName string
schema *schemapb.CollectionSchema
@ -251,7 +252,7 @@ func (t *searchTask) PreExecute(ctx context.Context) error {
}
t.offset = offset
plan, err := planparserv2.CreateSearchPlan(t.schema, t.request.Dsl, annsField, queryInfo)
plan, err := planparserv2.CreateSearchPlan(t.schema, t.request.Dsl, annsField, queryInfo, planparserv2.ParserVisitorWithRootCoord(t.rc))
if err != nil {
log.Ctx(ctx).Warn("failed to create query plan", zap.Error(err), zap.Int64("msgID", t.ID()),
zap.String("dsl", t.request.Dsl), // may be very large if large term passed.

6
internal/proxy/task_search_test.go
View File

@ -417,7 +417,7 @@ func TestSearchTaskWithInvalidRoundDecimal(t *testing.T) {
// ShardsNum: shardsNum,
// },
// ctx: ctx,
// rootCoord: rc,
// rc: rc,
// result: nil,
// schema: nil,
// }
@ -661,7 +661,7 @@ func TestSearchTaskV2_all(t *testing.T) {
// ShardsNum: shardsNum,
// },
// ctx: ctx,
// rootCoord: rc,
// rc: rc,
// result: nil,
// schema: nil,
// }
@ -899,7 +899,7 @@ func TestSearchTaskV2_7803_reduce(t *testing.T) {
// ShardsNum: shardsNum,
// },
// ctx: ctx,
// rootCoord: rc,
// rc: rc,
// result: nil,
// schema: nil,
// }

25
internal/rootcoord/create_function_task.go Normal file
View File

@ -0,0 +1,25 @@
package rootcoord
import (
"context"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
)
type createFunctionTask struct {
baseTask
Req *milvuspb.CreateFunctionRequest
}
func (t *createFunctionTask) Prepare(ctx context.Context) error {
if err := CheckMsgType(t.Req.GetBase().GetMsgType(), commonpb.MsgType_CreateFunction); err != nil {
return err
}
return nil
}
func (t *createFunctionTask) Execute(ctx context.Context) error {
return t.core.meta.CreateFunction(ctx, t.Req.GetFunctionName(), t.Req.GetWatBodyBase64(), t.Req.GetArgTypes(), t.GetTs())
}

44
internal/rootcoord/create_function_task_test.go Normal file
View File

@ -0,0 +1,44 @@
package rootcoord
import (
"context"
"testing"
"github.com/milvus-io/milvus/api/schemapb"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus/api/milvuspb"
)
func Test_createFunctionTask_Prepare(t *testing.T) {
t.Run("invalid msg type", func(t *testing.T) {
task := &createFunctionTask{Req: &milvuspb.CreateFunctionRequest{Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_DropCollection}}}
err := task.Prepare(context.Background())
assert.Error(t, err)
})
t.Run("normal case", func(t *testing.T) {
task := &createFunctionTask{Req: &milvuspb.CreateFunctionRequest{Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_CreateFunction}}}
err := task.Prepare(context.Background())
assert.NoError(t, err)
})
}
func Test_createFunctionTask_Execute(t *testing.T) {
t.Run("failed to create function", func(t *testing.T) {
core := newTestCore(withInvalidMeta())
task := &createFunctionTask{
baseTask: baseTask{core: core},
Req: &milvuspb.CreateFunctionRequest{
Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_CreateFunction},
FunctionName: "test",
WatBodyBase64: "test",
ArgTypes: []schemapb.DataType{schemapb.DataType_Int64, schemapb.DataType_Int64},
},
}
err := task.Execute(context.Background())
assert.Error(t, err)
})
}

25
internal/rootcoord/drop_function_task.go Normal file
View File

@ -0,0 +1,25 @@
package rootcoord
import (
"context"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
)
type dropFunctionTask struct {
baseTask
Req *milvuspb.DropFunctionRequest
}
func (t *dropFunctionTask) Prepare(ctx context.Context) error {
if err := CheckMsgType(t.Req.GetBase().GetMsgType(), commonpb.MsgType_DropFunction); err != nil {
return err
}
return nil
}
func (t *dropFunctionTask) Execute(ctx context.Context) error {
return t.core.meta.DropFunction(ctx, t.Req.GetFunctionName(), t.GetTs())
}

49
internal/rootcoord/drop_function_task_test.go Normal file
View File

@ -0,0 +1,49 @@
package rootcoord
import (
"context"
"testing"
"github.com/milvus-io/milvus/internal/util/funcutil"
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
)
func Test_dropFunctionTask_Prepare(t *testing.T) {
t.Run("invalid msg type", func(t *testing.T) {
task := &dropFunctionTask{
Req: &milvuspb.DropFunctionRequest{Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_DropCollection}},
}
err := task.Prepare(context.Background())
assert.Error(t, err)
})
t.Run("normal case", func(t *testing.T) {
task := &dropFunctionTask{
Req: &milvuspb.DropFunctionRequest{Base: &commonpb.MsgBase{MsgType: commonpb.MsgType_DropFunction}},
}
err := task.Prepare(context.Background())
assert.NoError(t, err)
})
}
func Test_dropFunctionTask_Execute(t *testing.T) {
t.Run("failed to drop function", func(t *testing.T) {
core := newTestCore(withInvalidMeta())
funcName := funcutil.GenRandomStr()
task := &dropFunctionTask{
baseTask: baseTask{core: core},
Req: &milvuspb.DropFunctionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_DropFunction,
},
FunctionName: funcName,
},
}
err := task.Execute(context.Background())
assert.Error(t, err)
})
}

32
internal/rootcoord/get_function_info_task.go Normal file
View File

@ -0,0 +1,32 @@
package rootcoord
import (
"context"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
)
type getFunctionInfoTask struct {
baseTask
Req *rootcoordpb.GetFunctionInfoRequest
Rsp *rootcoordpb.GetFunctionInfoResponse
}
func (t *getFunctionInfoTask) Prepare(ctx context.Context) error {
if err := CheckMsgType(t.Req.GetBase().GetMsgType(), commonpb.MsgType_GetFunctionInfo); err != nil {
return err
}
return nil
}
func (t *getFunctionInfoTask) Execute(ctx context.Context) error {
t.Rsp.Status = succStatus()
functionInfo, err := t.core.meta.GetFunctionInfo(ctx, t.Req.GetFunctionName(), t.GetTs())
if err != nil {
t.Rsp.Status = failStatus(commonpb.ErrorCode_UnexpectedError, err.Error())
return err
}
t.Rsp.Info = functionInfo
return nil
}

57
internal/rootcoord/get_function_info_task_test.go Normal file
View File

@ -0,0 +1,57 @@
package rootcoord
import (
"context"
"testing"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/util/funcutil"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/stretchr/testify/assert"
)
func Test_getFunctionInfoTask_Prepare(t *testing.T) {
t.Run("invalid msg type", func(t *testing.T) {
task := &getFunctionInfoTask{
Req: &rootcoordpb.GetFunctionInfoRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_CreateFunction,
},
},
}
err := task.Prepare(context.Background())
assert.Error(t, err)
})
t.Run("normal case", func(t *testing.T) {
task := &getFunctionInfoTask{
Req: &rootcoordpb.GetFunctionInfoRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_GetFunctionInfo,
},
},
}
err := task.Prepare(context.Background())
assert.NoError(t, err)
})
}
func Test_getFunctionInfoTask_Execute(t *testing.T) {
t.Run("fail to get function", func(t *testing.T) {
core := newTestCore(withInvalidMeta())
funcName := funcutil.GenRandomStr()
task := &getFunctionInfoTask{
baseTask: baseTask{core: core},
Req: &rootcoordpb.GetFunctionInfoRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_GetFunctionInfo,
},
FunctionName: funcName,
},
Rsp: &rootcoordpb.GetFunctionInfoResponse{},
}
err := task.Execute(context.Background())
assert.Error(t, err)
})
}

74
internal/rootcoord/meta_table.go
View File

@ -22,6 +22,9 @@ import (
"fmt"
"sync"
"github.com/milvus-io/milvus/api/schemapb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/common"
pb "github.com/milvus-io/milvus/internal/proto/etcdpb"
@ -115,15 +118,27 @@ type IMetaTable interface {
DropGrant(tenant string, role *milvuspb.RoleEntity) error
ListPolicy(tenant string) ([]string, error)
ListUserRole(tenant string) ([]string, error)
/* function */
CreateFunction(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts Timestamp) error
DropFunction(ctx context.Context, funcName string, ts Timestamp) error
GetFunctionInfo(ctx context.Context, funcName string, ts Timestamp) (*rootcoordpb.FunctionInfo, error)
}
type FunctionInfo struct {
funcName string
watBodyBase64 string
argTypes []schemapb.DataType
}
type MetaTable struct {
ctx context.Context
catalog metastore.RootCoordCatalog
collID2Meta map[typeutil.UniqueID]*model.Collection // collection id -> collection meta
collName2ID map[string]typeutil.UniqueID // collection name to collection id
collAlias2ID map[string]typeutil.UniqueID // collection alias to collection id
collID2Meta map[typeutil.UniqueID]*model.Collection // collection id -> collection meta
collName2ID map[string]typeutil.UniqueID // collection name to collection id
collAlias2ID map[string]typeutil.UniqueID // collection alias to collection id
funcName2Info map[string]*FunctionInfo // function name to function body and params
ddLock sync.RWMutex
permissionLock sync.RWMutex
@ -147,6 +162,7 @@ func (mt *MetaTable) reload() error {
mt.collID2Meta = make(map[UniqueID]*model.Collection)
mt.collName2ID = make(map[string]UniqueID)
mt.collAlias2ID = make(map[string]UniqueID)
mt.funcName2Info = make(map[string]*FunctionInfo)
// max ts means listing latest resources, meta table should always cache the latest version of catalog.
collections, err := mt.catalog.ListCollections(mt.ctx, typeutil.MaxTimestamp)
@ -876,3 +892,55 @@ func (mt *MetaTable) ListUserRole(tenant string) ([]string, error) {
return mt.catalog.ListUserRole(mt.ctx, tenant)
}
func (mt *MetaTable) CreateFunction(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts Timestamp) error {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if _, ok := mt.funcName2Info[funcName]; ok {
return fmt.Errorf("cannot create function, milvus already exists with same function name: %s", funcName)
}
// function didn't exist.
mt.funcName2Info[funcName] = &FunctionInfo{
funcName: funcName,
watBodyBase64: watBodyBase64,
argTypes: argTypes,
}
//TODO: storage in etcd
log.Info("create function", zap.String("function name", funcName), zap.String("wat body base64", watBodyBase64),
zap.String("function argument types", string(argTypes)),
zap.Uint64("ts", ts))
return nil
}
func (mt *MetaTable) DropFunction(ctx context.Context, funcName string, ts Timestamp) error {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
delete(mt.funcName2Info, funcName)
log.Info("drop function", zap.String("function name", funcName), zap.Uint64("ts", ts))
return nil
}
func (mt *MetaTable) GetFunctionInfo(ctx context.Context, funcName string, ts Timestamp) (*rootcoordpb.FunctionInfo, error) {
mt.ddLock.Lock()
defer mt.ddLock.Unlock()
if _, ok := mt.funcName2Info[funcName]; !ok {
return nil, fmt.Errorf("cannot get function information, function name not found: %s", funcName)
}
log.Info("get function information", zap.String("function name", funcName), zap.String("wat body base64", mt.funcName2Info[funcName].watBodyBase64),
zap.String("function argument types", string(mt.funcName2Info[funcName].argTypes)),
zap.Uint64("ts", ts))
return &rootcoordpb.FunctionInfo{
FunctionName: funcName,
WatBodyBase64: mt.funcName2Info[funcName].watBodyBase64,
ArgTypes: mt.funcName2Info[funcName].argTypes,
}, nil
}

27
internal/rootcoord/mock_test.go
View File

@ -6,6 +6,9 @@ import (
"math/rand"
"os"
"github.com/milvus-io/milvus/api/schemapb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/mq/msgstream"
"github.com/milvus-io/milvus/internal/proto/indexpb"
@ -55,6 +58,9 @@ type mockMetaTable struct {
GetCollectionIDByNameFunc func(name string) (UniqueID, error)
GetPartitionByNameFunc func(collID UniqueID, partitionName string, ts Timestamp) (UniqueID, error)
GetCollectionVirtualChannelsFunc func(colID int64) []string
CreateFunctionFunc func(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts Timestamp) error
DropFunctionFunc func(ctx context.Context, funcName string, ts Timestamp) error
GetFunctionInfoFunc func(ctx context.Context, funcName string, ts Timestamp) (*rootcoordpb.FunctionInfo, error)
}
func (m mockMetaTable) ListCollections(ctx context.Context, ts Timestamp) ([]*model.Collection, error) {
@ -125,6 +131,18 @@ func (m mockMetaTable) GetCollectionVirtualChannels(colID int64) []string {
return m.GetCollectionVirtualChannelsFunc(colID)
}
func (m mockMetaTable) CreateFunction(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts Timestamp) error {
return m.CreateFunctionFunc(ctx, funcName, watBodyBase64, argTypes, ts)
}
func (m mockMetaTable) DropFunction(ctx context.Context, funcName string, ts Timestamp) error {
return m.DropFunctionFunc(ctx, funcName, ts)
}
func (m mockMetaTable) GetFunctionInfo(ctx context.Context, funcName string, ts Timestamp) (*rootcoordpb.FunctionInfo, error) {
return m.GetFunctionInfoFunc(ctx, funcName, ts)
}
func newMockMetaTable() *mockMetaTable {
return &mockMetaTable{}
}
@ -358,6 +376,15 @@ func withInvalidMeta() Opt {
meta.DropAliasFunc = func(ctx context.Context, alias string, ts Timestamp) error {
return errors.New("error mock DropAlias")
}
meta.CreateFunctionFunc = func(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts Timestamp) error {
return errors.New("error mock CreateFunction")
}
meta.DropFunctionFunc = func(ctx context.Context, funcName string, ts Timestamp) error {
return errors.New("error mock DropFunction")
}
meta.GetFunctionInfoFunc = func(ctx context.Context, funcName string, ts Timestamp) (*rootcoordpb.FunctionInfo, error) {
return nil, errors.New("error mock GetFunctionInfo")
}
return withMeta(meta)
}

55
internal/rootcoord/mocks/IMetaTable.go
View File

@ -13,6 +13,10 @@ import (
mock "github.com/stretchr/testify/mock"
model "github.com/milvus-io/milvus/internal/metastore/model"
rootcoordpb "github.com/milvus-io/milvus/internal/proto/rootcoordpb"
schemapb "github.com/milvus-io/milvus/api/schemapb"
)
// IMetaTable is an autogenerated mock type for the IMetaTable type
@ -132,6 +136,20 @@ func (_m *IMetaTable) CreateAlias(ctx context.Context, alias string, collectionN
return r0
}
// CreateFunction provides a mock function with given fields: ctx, funcName, watBodyBase64, argTypes, ts
func (_m *IMetaTable) CreateFunction(ctx context.Context, funcName string, watBodyBase64 string, argTypes []schemapb.DataType, ts uint64) error {
ret := _m.Called(ctx, funcName, watBodyBase64, argTypes, ts)
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, string, string, []schemapb.DataType, uint64) error); ok {
r0 = rf(ctx, funcName, watBodyBase64, argTypes, ts)
} else {
r0 = ret.Error(0)
}
return r0
}
// CreateRole provides a mock function with given fields: tenant, entity
func (_m *IMetaTable) CreateRole(tenant string, entity *milvuspb.RoleEntity) error {
ret := _m.Called(tenant, entity)
@ -174,6 +192,20 @@ func (_m *IMetaTable) DropAlias(ctx context.Context, alias string, ts uint64) er
return r0
}
// DropFunction provides a mock function with given fields: ctx, funcName, ts
func (_m *IMetaTable) DropFunction(ctx context.Context, funcName string, ts uint64) error {
ret := _m.Called(ctx, funcName, ts)
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, string, uint64) error); ok {
r0 = rf(ctx, funcName, ts)
} else {
r0 = ret.Error(0)
}
return r0
}
// DropGrant provides a mock function with given fields: tenant, role
func (_m *IMetaTable) DropGrant(tenant string, role *milvuspb.RoleEntity) error {
ret := _m.Called(tenant, role)
@ -329,6 +361,29 @@ func (_m *IMetaTable) GetCredential(username string) (*internalpb.CredentialInfo
return r0, r1
}
// GetFunctionInfo provides a mock function with given fields: ctx, funcName, ts
func (_m *IMetaTable) GetFunctionInfo(ctx context.Context, funcName string, ts uint64) (*rootcoordpb.FunctionInfo, error) {
ret := _m.Called(ctx, funcName, ts)
var r0 *rootcoordpb.FunctionInfo
if rf, ok := ret.Get(0).(func(context.Context, string, uint64) *rootcoordpb.FunctionInfo); ok {
r0 = rf(ctx, funcName, ts)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*rootcoordpb.FunctionInfo)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, string, uint64) error); ok {
r1 = rf(ctx, funcName, ts)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetPartitionByName provides a mock function with given fields: collID, partitionName, ts
func (_m *IMetaTable) GetPartitionByName(collID int64, partitionName string, ts uint64) (int64, error) {
ret := _m.Called(collID, partitionName, ts)

161
internal/rootcoord/root_coord.go
View File

@ -1311,6 +1311,167 @@ func (c *Core) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest) (
}, nil
}
// CreateFunction create function
func (c *Core) CreateFunction(ctx context.Context, in *milvuspb.CreateFunctionRequest) (*commonpb.Status, error) {
if code, ok := c.checkHealthy(); !ok {
return failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]), nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("CreateFunction", metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder("CreateFunction")
log.Info("received request to create function", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()), zap.String("wat body base64", in.GetWatBodyBase64()),
zap.String("argument types", string(in.GetArgTypes())),
zap.Int64("msgID", in.GetBase().GetMsgID()))
t := &createFunctionTask{
baseTask: baseTask{
ctx: ctx,
core: c,
done: make(chan error, 1),
},
Req: in,
}
if err := c.scheduler.AddTask(t); err != nil {
log.Error("failed to enqueue request to create function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()), zap.String("wat body base64", in.GetWatBodyBase64()),
zap.String("argument types", string(in.GetArgTypes())),
zap.Int64("msgID", in.GetBase().GetMsgID()))
metrics.RootCoordDDLReqCounter.WithLabelValues("CreateFunction", metrics.FailLabel).Inc()
return failStatus(commonpb.ErrorCode_UnexpectedError, err.Error()), nil
}
if err := t.WaitToFinish(); err != nil {
log.Error("failed to create function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()), zap.String("wat body base64", in.GetWatBodyBase64()),
zap.String("argument types", string(in.GetArgTypes())),
zap.Int64("msgID", in.GetBase().GetMsgID()), zap.Uint64("ts", t.GetTs()))
metrics.RootCoordDDLReqCounter.WithLabelValues("CreateFunction", metrics.FailLabel).Inc()
return failStatus(commonpb.ErrorCode_UnexpectedError, err.Error()), nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("CreateFunction", metrics.SuccessLabel).Inc()
metrics.RootCoordDDLReqLatency.WithLabelValues("CreateFunction").Observe(float64(tr.ElapseSpan().Milliseconds()))
log.Info("done to create function", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()), zap.String("wat body base64", in.GetWatBodyBase64()),
zap.String("argument types", string(in.GetArgTypes())),
zap.Int64("msgID", in.GetBase().GetMsgID()))
return succStatus(), nil
}
// DropFunction drop function
func (c *Core) DropFunction(ctx context.Context, in *milvuspb.DropFunctionRequest) (*commonpb.Status, error) {
if code, ok := c.checkHealthy(); !ok {
return failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]), nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("DropFunction", metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder("DropFunction")
log.Info("received request to drop function", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()),
zap.Int64("msgID", in.GetBase().GetMsgID()))
t := &dropFunctionTask{
baseTask: baseTask{
ctx: ctx,
core: c,
done: make(chan error, 1),
},
Req: in,
}
if err := c.scheduler.AddTask(t); err != nil {
log.Error("failed to enqueue request to drop function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()),
zap.Int64("msgID", in.GetBase().GetMsgID()))
metrics.RootCoordDDLReqCounter.WithLabelValues("DropFunction", metrics.FailLabel).Inc()
return failStatus(commonpb.ErrorCode_UnexpectedError, err.Error()), nil
}
if err := t.WaitToFinish(); err != nil {
log.Error("failed to drop function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()),
zap.Int64("msgID", in.GetBase().GetMsgID()), zap.Uint64("ts", t.GetTs()))
metrics.RootCoordDDLReqCounter.WithLabelValues("DropFunction", metrics.FailLabel).Inc()
return failStatus(commonpb.ErrorCode_UnexpectedError, err.Error()), nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("DropFunction", metrics.SuccessLabel).Inc()
metrics.RootCoordDDLReqLatency.WithLabelValues("DropFunction").Observe(float64(tr.ElapseSpan().Milliseconds()))
log.Info("done to drop function", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()),
zap.Int64("msgID", in.GetBase().GetMsgID()))
return succStatus(), nil
}
func (c *Core) GetFunctionInfo(ctx context.Context, in *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error) {
if code, ok := c.checkHealthy(); !ok {
return &rootcoordpb.GetFunctionInfoResponse{
Status: failStatus(commonpb.ErrorCode_UnexpectedError, "StateCode="+internalpb.StateCode_name[int32(code)]),
}, nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("GetFunctionInfo", metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder("GetFunctionInfo")
log.Info("received request to get function information", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()), zap.Int64("msgID", in.GetBase().GetMsgID()))
t := &getFunctionInfoTask{
baseTask: baseTask{
ctx: ctx,
core: c,
done: make(chan error, 1),
},
Req: in,
Rsp: &rootcoordpb.GetFunctionInfoResponse{},
}
if err := c.scheduler.AddTask(t); err != nil {
log.Error("failed to enqueue request to create function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()), zap.Int64("msgID", in.GetBase().GetMsgID()))
metrics.RootCoordDDLReqCounter.WithLabelValues("GetFunctionInfo", metrics.FailLabel).Inc()
return &rootcoordpb.GetFunctionInfoResponse{
Status: failStatus(commonpb.ErrorCode_UnexpectedError, "GetFunctionInfo failed: "+err.Error()),
}, nil
}
if err := t.WaitToFinish(); err != nil {
log.Error("failed to create function", zap.String("role", typeutil.RootCoordRole),
zap.Error(err),
zap.String("function name", in.GetFunctionName()),
zap.Int64("msgID", in.GetBase().GetMsgID()), zap.Uint64("ts", t.GetTs()))
metrics.RootCoordDDLReqCounter.WithLabelValues("CreateFunction", metrics.FailLabel).Inc()
return &rootcoordpb.GetFunctionInfoResponse{
Status: failStatus(commonpb.ErrorCode_UnexpectedError, "GetFunctionInfo failed: "+err.Error()),
}, nil
}
metrics.RootCoordDDLReqCounter.WithLabelValues("GetFunctionInfo", metrics.SuccessLabel).Inc()
metrics.RootCoordDDLReqLatency.WithLabelValues("GetFunctionInfo").Observe(float64(tr.ElapseSpan().Milliseconds()))
log.Info("done to get function information", zap.String("role", typeutil.RootCoordRole),
zap.String("function name", in.GetFunctionName()), zap.Int64("msgID", in.GetBase().GetMsgID()))
return t.Rsp, nil
}
// CreateAlias create collection alias
func (c *Core) CreateAlias(ctx context.Context, in *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
if code, ok := c.checkHealthy(); !ok {

27
internal/types/types.go
View File

@ -740,6 +740,13 @@ type RootCoord interface {
OperatePrivilege(ctx context.Context, req *milvuspb.OperatePrivilegeRequest) (*commonpb.Status, error)
SelectGrant(ctx context.Context, req *milvuspb.SelectGrantRequest) (*milvuspb.SelectGrantResponse, error)
ListPolicy(ctx context.Context, in *internalpb.ListPolicyRequest) (*internalpb.ListPolicyResponse, error)
// CreateFunction create function
CreateFunction(ctx context.Context, req *milvuspb.CreateFunctionRequest) (*commonpb.Status, error)
// DropFunction drop function
DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error)
// GetFunctionInfo get function information by function name from root coordinator
GetFunctionInfo(ctx context.Context, request *rootcoordpb.GetFunctionInfoRequest) (*rootcoordpb.GetFunctionInfoResponse, error)
}
// RootCoordComponent is used by grpc server of RootCoord
@ -1170,6 +1177,26 @@ type ProxyComponent interface {
// error is always nil
LoadBalance(ctx context.Context, request *milvuspb.LoadBalanceRequest) (*commonpb.Status, error)
// CreateFunction notifies Proxy to create function
//
// ctx is the context to control request deadline and cancellation
// req contains the request params, including function name, wat body base 64, function argument types
//
// The `ErrorCode` of `Status` is `Success` if create alias successfully;
// otherwise, the `ErrorCode` of `Status` will be `Error`, and the `Reason` of `Status` will record the fail cause.
// error is always nil
CreateFunction(ctx context.Context, request *milvuspb.CreateFunctionRequest) (*commonpb.Status, error)
// DropFunction notifies Proxy to drop function
//
// ctx is the context to control request deadline and cancellation
// req contains the request params, including function name
//
// The `ErrorCode` of `Status` is `Success` if create alias successfully;
// otherwise, the `ErrorCode` of `Status` will be `Error`, and the `Reason` of `Status` will record the fail cause.
// error is always nil
DropFunction(ctx context.Context, request *milvuspb.DropFunctionRequest) (*commonpb.Status, error)
// CreateAlias notifies Proxy to create alias for a collection
//
// ctx is the context to control request deadline and cancellation

12
internal/util/mock/grpc_rootcoord_client.go
View File

@ -216,3 +216,15 @@ func (m *GrpcRootCoordClient) ListCredUsers(ctx context.Context, in *milvuspb.Li
func (m *GrpcRootCoordClient) GetCredential(ctx context.Context, in *rootcoordpb.GetCredentialRequest, opts ...grpc.CallOption) (*rootcoordpb.GetCredentialResponse, error) {
return &rootcoordpb.GetCredentialResponse{}, m.Err
}
func (m *GrpcRootCoordClient) CreateFunction(ctx context.Context, in *milvuspb.CreateFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
return &commonpb.Status{}, m.Err
}
func (m *GrpcRootCoordClient) DropFunction(ctx context.Context, in *milvuspb.DropFunctionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
return &commonpb.Status{}, m.Err
}
func (m *GrpcRootCoordClient) GetFunctionInfo(ctx context.Context, in *rootcoordpb.GetFunctionInfoRequest, opts ...grpc.CallOption) (*rootcoordpb.GetFunctionInfoResponse, error) {
return &rootcoordpb.GetFunctionInfoResponse{}, m.Err
}