From eed7fbe3319a6f2aad09bac06c6aead7ea717007 Mon Sep 17 00:00:00 2001 From: qw4990 Date: Mon, 10 Jun 2019 16:45:33 +0800 Subject: [PATCH 1/3] add ScalarFuncSig_TimeIsNullOnNotNullCol --- go-tipb/expression.pb.go | 570 +-- proto/expression.proto | 1 + src/prost/tipb.rs | 285 +- src/prost/wrapper_tipb.rs | 8234 ++++++++++++++++++++++++------------ src/protobuf/analyze.rs | 4 +- src/protobuf/checksum.rs | 4 +- src/protobuf/executor.rs | 4 +- src/protobuf/expression.rs | 244 +- src/protobuf/schema.rs | 2 +- src/protobuf/select.rs | 10 +- 10 files changed, 5993 insertions(+), 3365 deletions(-) diff --git a/go-tipb/expression.pb.go b/go-tipb/expression.pb.go index 6bf020ca7..708bfa867 100644 --- a/go-tipb/expression.pb.go +++ b/go-tipb/expression.pb.go @@ -352,19 +352,20 @@ const ( ScalarFuncSig_TruncateReal ScalarFuncSig = 2155 ScalarFuncSig_TruncateDecimal ScalarFuncSig = 2156 // op - ScalarFuncSig_LogicalAnd ScalarFuncSig = 3101 - ScalarFuncSig_LogicalOr ScalarFuncSig = 3102 - ScalarFuncSig_LogicalXor ScalarFuncSig = 3103 - ScalarFuncSig_UnaryNot ScalarFuncSig = 3104 - ScalarFuncSig_UnaryMinusInt ScalarFuncSig = 3108 - ScalarFuncSig_UnaryMinusReal ScalarFuncSig = 3109 - ScalarFuncSig_UnaryMinusDecimal ScalarFuncSig = 3110 - ScalarFuncSig_DecimalIsNull ScalarFuncSig = 3111 - ScalarFuncSig_DurationIsNull ScalarFuncSig = 3112 - ScalarFuncSig_RealIsNull ScalarFuncSig = 3113 - ScalarFuncSig_StringIsNull ScalarFuncSig = 3114 - ScalarFuncSig_TimeIsNull ScalarFuncSig = 3115 - ScalarFuncSig_IntIsNull ScalarFuncSig = 3116 + ScalarFuncSig_LogicalAnd ScalarFuncSig = 3101 + ScalarFuncSig_LogicalOr ScalarFuncSig = 3102 + ScalarFuncSig_LogicalXor ScalarFuncSig = 3103 + ScalarFuncSig_UnaryNot ScalarFuncSig = 3104 + ScalarFuncSig_UnaryMinusInt ScalarFuncSig = 3108 + ScalarFuncSig_UnaryMinusReal ScalarFuncSig = 3109 + ScalarFuncSig_UnaryMinusDecimal ScalarFuncSig = 3110 + ScalarFuncSig_DecimalIsNull ScalarFuncSig = 3111 + ScalarFuncSig_DurationIsNull ScalarFuncSig = 3112 + ScalarFuncSig_RealIsNull ScalarFuncSig = 3113 + ScalarFuncSig_StringIsNull ScalarFuncSig = 3114 + ScalarFuncSig_TimeIsNull ScalarFuncSig = 3115 + ScalarFuncSig_TimeIsNullOnNotNullCol ScalarFuncSig = 3142 + ScalarFuncSig_IntIsNull ScalarFuncSig = 3116 // unimplemented in tidb ScalarFuncSig_JsonIsNull ScalarFuncSig = 3117 ScalarFuncSig_BitAndSig ScalarFuncSig = 3118 @@ -863,6 +864,7 @@ var ScalarFuncSig_name = map[int32]string{ 3113: "RealIsNull", 3114: "StringIsNull", 3115: "TimeIsNull", + 3142: "TimeIsNullOnNotNullCol", 3116: "IntIsNull", 3117: "JsonIsNull", 3118: "BitAndSig", @@ -1350,6 +1352,7 @@ var ScalarFuncSig_value = map[string]int32{ "RealIsNull": 3113, "StringIsNull": 3114, "TimeIsNull": 3115, + "TimeIsNullOnNotNullCol": 3142, "IntIsNull": 3116, "JsonIsNull": 3117, "BitAndSig": 3118, @@ -2585,275 +2588,276 @@ var ( func init() { proto.RegisterFile("expression.proto", fileDescriptorExpression) } var fileDescriptorExpression = []byte{ - // 4312 bytes of a gzipped FileDescriptorProto + // 4327 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x5a, 0x67, 0x74, 0x1c, 0x55, - 0x96, 0xa6, 0x6d, 0x19, 0xec, 0x72, 0xba, 0x14, 0x36, 0x6a, 0xd8, 0xb3, 0xb6, 0x8c, 0xe6, 0xac, - 0x18, 0x66, 0x57, 0x3d, 0x63, 0x4c, 0x6b, 0x7f, 0x6c, 0x6a, 0x05, 0x8b, 0x9e, 0x95, 0x64, 0x59, - 0xdd, 0x32, 0xb3, 0xbf, 0xe6, 0x94, 0xba, 0x9f, 0x5a, 0x05, 0xdd, 0x55, 0x4d, 0xd5, 0x6b, 0x59, - 0x62, 0xc3, 0x21, 0x47, 0x47, 0x82, 0x6d, 0x72, 0x86, 0x21, 0x87, 0x19, 0x72, 0x4e, 0x83, 0x8d, - 0x89, 0x03, 0x38, 0x00, 0xc3, 0x30, 0x66, 0x12, 0x61, 0x02, 0x43, 0x8e, 0xb3, 0xe7, 0x7e, 0xef, - 0xbd, 0xea, 0x6a, 0x89, 0x5f, 0xaa, 0xf7, 0xbd, 0x7b, 0xbf, 0xfb, 0xbd, 0xfb, 0xf2, 0x53, 0x5b, - 0x24, 0x26, 0xaa, 0x81, 0x08, 0x43, 0xd7, 0xf7, 0xda, 0xab, 0x81, 0x2f, 0x7d, 0xbb, 0x49, 0xba, - 0xd5, 0x91, 0x43, 0x17, 0x95, 0xfc, 0x92, 0x0f, 0x20, 0xc5, 0x5f, 0xaa, 0xee, 0xb0, 0xbb, 0x12, - 0xd6, 0x9c, 0x95, 0xae, 0x28, 0x17, 0xf3, 0x93, 0x55, 0x61, 0x2f, 0xb2, 0x66, 0xc8, 0x6a, 0x32, - 0xd1, 0x92, 0x38, 0x7c, 0x56, 0x67, 0xd3, 0xf6, 0x37, 0x97, 0xee, 0x37, 0x34, 0x43, 0x56, 0xed, - 0xa4, 0xd5, 0x34, 0x5a, 0x76, 0x4a, 0xc9, 0x19, 0x2d, 0x89, 0xc3, 0xe7, 0x6b, 0x1c, 0x88, 0xaa, - 0x11, 0x5e, 0x72, 0x66, 0xcc, 0x03, 0x88, 0xbd, 0xc4, 0x3a, 0xa0, 0x28, 0x0a, 0x6e, 0xc5, 0x29, - 0x27, 0x9b, 0x62, 0x95, 0x06, 0xe4, 0xfa, 0x82, 0x5f, 0x2e, 0x3b, 0x52, 0x24, 0x67, 0xc5, 0xeb, - 0x35, 0x88, 0xfa, 0x31, 0x27, 0x08, 0x85, 0x4c, 0xee, 0xdf, 0x92, 0x38, 0x7c, 0x4e, 0x54, 0xaf, - 0xc0, 0xc3, 0x9e, 0x48, 0x58, 0x4d, 0x3d, 0x13, 0xd5, 0xc0, 0xfe, 0x4e, 0x24, 0x79, 0xc1, 0xf2, - 0x05, 0xed, 0xdc, 0xd2, 0x76, 0xc6, 0xb9, 0x39, 0xb1, 0x26, 0x90, 0x35, 0x73, 0xdc, 0x29, 0xa3, - 0x05, 0xf3, 0x86, 0xf8, 0xd3, 0xfe, 0x07, 0x6b, 0x76, 0x61, 0xcc, 0x2d, 0x17, 0x03, 0xc8, 0x9f, - 0x79, 0xf8, 0xdc, 0xe5, 0x56, 0xdd, 0x7b, 0x28, 0xaa, 0xb3, 0xbf, 0x67, 0xcd, 0x0c, 0xdd, 0x12, - 0x1a, 0xb1, 0x60, 0xf9, 0x41, 0xca, 0x24, 0x57, 0x70, 0xca, 0x4e, 0xb0, 0xb2, 0xe6, 0x15, 0x72, - 0x6e, 0x49, 0x47, 0x61, 0x2b, 0xbb, 0xdd, 0xb2, 0x46, 0x39, 0x99, 0x3f, 0x96, 0x93, 0x55, 0xd5, - 0xb0, 0xb9, 0xcb, 0x17, 0x2a, 0x9f, 0x28, 0xc9, 0x43, 0x73, 0x46, 0xcd, 0xe7, 0x61, 0x9d, 0xd6, - 0xfe, 0x9d, 0x93, 0x59, 0x29, 0x2a, 0xf6, 0x12, 0xab, 0x89, 0xfb, 0x0d, 0x0d, 0x69, 0x94, 0x02, - 0x9c, 0x33, 0x5d, 0x14, 0x61, 0x01, 0x2d, 0x98, 0x6d, 0x32, 0xcd, 0xc8, 0x11, 0x5b, 0x9a, 0xac, - 0xd9, 0xa6, 0xc5, 0xf6, 0x6c, 0xab, 0x69, 0xa0, 0x56, 0x2e, 0xd3, 0x7e, 0xf6, 0x1c, 0x6b, 0x56, - 0xd6, 0x93, 0xe9, 0x15, 0x94, 0xb0, 0x2d, 0x6b, 0xff, 0x61, 0x17, 0xdf, 0x33, 0xec, 0xb9, 0xd6, - 0x01, 0x2b, 0xcb, 0xbe, 0x23, 0x8f, 0x5c, 0x4e, 0x33, 0xa3, 0x42, 0x7a, 0x05, 0x35, 0xb1, 0x55, - 0x4e, 0x06, 0xae, 0x57, 0xa2, 0x59, 0xec, 0xdc, 0x39, 0x29, 0x45, 0x48, 0xfb, 0xdb, 0xf3, 0xac, - 0xd9, 0xfd, 0x93, 0xe1, 0xf1, 0xe5, 0x4e, 0x57, 0x92, 0xb0, 0xc9, 0x9a, 0x87, 0x52, 0xb7, 0xea, - 0x46, 0x1a, 0xb5, 0x0f, 0xb4, 0xe6, 0x2b, 0xa4, 0x16, 0x38, 0xd2, 0xf5, 0x3d, 0x2a, 0xd9, 0xf3, - 0xad, 0x39, 0x80, 0x7a, 0xbc, 0x5a, 0x85, 0xc6, 0x22, 0x86, 0xa3, 0xc5, 0x04, 0xb9, 0x51, 0x29, - 0x27, 0x24, 0x1d, 0x1b, 0x99, 0xe6, 0xdd, 0x8a, 0xa0, 0xe3, 0xa2, 0xe2, 0x0f, 0x43, 0xdf, 0xa3, - 0xb2, 0xbd, 0xc0, 0x9a, 0xb3, 0xc6, 0x29, 0xd7, 0x44, 0x9f, 0x1b, 0x4a, 0xda, 0x9a, 0xe0, 0x72, - 0x97, 0x5f, 0xae, 0x55, 0xbc, 0x21, 0x31, 0x4a, 0x3b, 0xb8, 0x61, 0xb3, 0xba, 0xfc, 0x9a, 0x27, - 0xe9, 0xbe, 0x66, 0x7b, 0xb6, 0x35, 0x33, 0x57, 0xab, 0xd0, 0xfd, 0xf8, 0xca, 0x8c, 0x97, 0xe8, - 0x01, 0x7c, 0xf5, 0xbb, 0x1e, 0x3d, 0xa8, 0xbe, 0x9c, 0x09, 0x7a, 0xa8, 0x99, 0x7d, 0x56, 0xba, - 0x41, 0x28, 0xe9, 0xe1, 0x66, 0x9b, 0xac, 0xb9, 0xbd, 0x81, 0x5f, 0xab, 0x76, 0xf9, 0x5e, 0xc1, - 0x91, 0xf4, 0x48, 0xb3, 0xbd, 0xd0, 0xb2, 0x32, 0xa5, 0xd2, 0x8f, 0x3b, 0x5d, 0x99, 0xf1, 0x8a, - 0xf4, 0x68, 0x33, 0x87, 0xd4, 0xc0, 0xaa, 0x80, 0x1e, 0x8b, 0x1b, 0xfc, 0xc8, 0x0f, 0xe8, 0x71, - 0x15, 0x57, 0x16, 0xe9, 0x89, 0x66, 0x7b, 0x2e, 0x27, 0xb0, 0x58, 0x14, 0xe3, 0xf4, 0x24, 0xfc, - 0x54, 0x61, 0xd0, 0xaf, 0xd2, 0x53, 0xf0, 0x53, 0xe5, 0x9c, 0x53, 0xa9, 0xd2, 0xcf, 0x61, 0xbd, - 0xc6, 0x09, 0xb8, 0xf6, 0xe9, 0x66, 0x7b, 0x9e, 0x75, 0xc0, 0x1a, 0x27, 0x40, 0xd5, 0xf6, 0x66, - 0x7b, 0xbe, 0x35, 0x7b, 0x8d, 0x13, 0xb8, 0x8e, 0x57, 0x10, 0xb4, 0xa3, 0xd9, 0x3e, 0xd0, 0x9a, - 0xc7, 0xf9, 0xc8, 0x04, 0x81, 0x33, 0x99, 0x29, 0x95, 0xe8, 0x99, 0x66, 0xdb, 0xb6, 0xe6, 0x33, - 0xb4, 0x6a, 0xe4, 0x58, 0x51, 0x90, 0x8c, 0xed, 0x54, 0x11, 0xa2, 0x71, 0x49, 0x9b, 0x06, 0x8e, - 0x38, 0xbf, 0xc7, 0x9a, 0xdf, 0x30, 0x52, 0xb9, 0xf7, 0xba, 0x9c, 0x50, 0x66, 0x3d, 0x99, 0x09, - 0xb3, 0x9e, 0xa4, 0xfd, 0xb8, 0xf7, 0x22, 0x64, 0x48, 0x38, 0x65, 0x4a, 0xd8, 0x07, 0x59, 0x0b, - 0x23, 0x48, 0x0f, 0x88, 0x19, 0xf6, 0x22, 0x8b, 0x22, 0xd0, 0xf4, 0xfd, 0xcc, 0x06, 0x6f, 0xf4, - 0x60, 0x93, 0xbd, 0xd8, 0x3a, 0xb0, 0x6e, 0x68, 0x86, 0xc4, 0xac, 0x06, 0x4b, 0x74, 0xee, 0xfe, - 0x06, 0xe2, 0xa8, 0x4a, 0x8d, 0x65, 0xdb, 0xd6, 0x82, 0x3a, 0x04, 0x39, 0x73, 0x4d, 0x64, 0x85, - 0x69, 0x3d, 0xf3, 0x4c, 0x18, 0x85, 0x1a, 0x41, 0xf3, 0x1b, 0x09, 0xa0, 0x68, 0x81, 0x7d, 0xb0, - 0x65, 0xc7, 0x4c, 0x8d, 0xa4, 0x85, 0x8d, 0xb6, 0xd0, 0x44, 0x26, 0x98, 0x26, 0x54, 0xb2, 0x16, - 0x99, 0x60, 0x11, 0x0a, 0x65, 0x8b, 0xed, 0x66, 0xeb, 0xa0, 0x06, 0x58, 0x8b, 0x3b, 0xd8, 0x4e, - 0x5a, 0x8b, 0x1a, 0x2a, 0x8c, 0xbe, 0xe6, 0x69, 0x4c, 0x90, 0x98, 0xb4, 0x0f, 0xb1, 0x16, 0x37, - 0x3a, 0x18, 0x95, 0x87, 0x4c, 0xf3, 0x80, 0xd0, 0x43, 0x4d, 0x27, 0xa9, 0x90, 0x4a, 0xe7, 0x12, - 0xa3, 0xde, 0x80, 0x90, 0xb9, 0xd4, 0xb4, 0xdf, 0xa0, 0x5a, 0x65, 0x8b, 0x91, 0x6f, 0x70, 0x23, - 0x72, 0xd9, 0x54, 0x1a, 0x68, 0x3c, 0xcc, 0x34, 0x2a, 0x32, 0x37, 0x12, 0x5b, 0xa7, 0xda, 0x43, - 0xe1, 0x77, 0x4c, 0xf7, 0xb2, 0xb7, 0xd2, 0x77, 0xb8, 0xc9, 0xb8, 0x82, 0xa0, 0xee, 0xbb, 0xc6, - 0x59, 0x61, 0x5a, 0xdb, 0x11, 0xa6, 0xd5, 0x0a, 0x35, 0xca, 0xbe, 0xd7, 0x48, 0x00, 0x5d, 0xff, - 0x68, 0x9a, 0xa7, 0x4d, 0x8d, 0xaa, 0x7f, 0x6a, 0xb4, 0x85, 0xa6, 0xf6, 0x28, 0x99, 0xda, 0x4a, - 0xe9, 0x5a, 0x6e, 0x28, 0xea, 0x30, 0xb4, 0x1d, 0x19, 0xf5, 0x63, 0x84, 0x6b, 0x7d, 0x2b, 0xa2, - 0x0e, 0x8b, 0x6a, 0x8c, 0xc6, 0xa3, 0xa6, 0x93, 0x41, 0x67, 0xda, 0x3e, 0xd4, 0x3a, 0x78, 0x8a, - 0x8b, 0xd1, 0xda, 0x31, 0xdd, 0x07, 0x7a, 0xff, 0xd9, 0xe4, 0x10, 0xb3, 0x1f, 0x5a, 0xff, 0xc5, - 0x34, 0x4b, 0x41, 0xd0, 0xf9, 0xaf, 0x26, 0x87, 0x0a, 0xd3, 0x1a, 0xff, 0xcd, 0x34, 0x56, 0xa1, - 0x46, 0xdf, 0xbf, 0x37, 0x12, 0x40, 0xdb, 0x7f, 0x98, 0xf8, 0xda, 0xd4, 0xe8, 0xca, 0x34, 0xda, - 0x42, 0x53, 0x27, 0xaf, 0x99, 0x5d, 0xbe, 0x53, 0x16, 0x61, 0x41, 0xb0, 0xa2, 0x77, 0x5a, 0x78, - 0x7d, 0x32, 0x08, 0x04, 0xbd, 0xdb, 0x62, 0x2f, 0xb2, 0x16, 0x1a, 0xc8, 0x44, 0x7e, 0xaf, 0xc5, - 0x3e, 0xc8, 0x5a, 0x60, 0x50, 0xad, 0xf2, 0xfd, 0x06, 0x6f, 0xa8, 0xf9, 0x63, 0x8b, 0xbd, 0xd8, - 0xa2, 0xc8, 0xdb, 0x88, 0xf9, 0x53, 0x83, 0x25, 0xb4, 0xfc, 0xb9, 0x85, 0xf7, 0xa9, 0xbe, 0x3c, - 0xcb, 0x28, 0xf2, 0xf6, 0xd5, 0x97, 0x47, 0x7c, 0xc1, 0xdb, 0x48, 0x5f, 0xbe, 0xbe, 0x45, 0xcd, - 0xb3, 0x66, 0xf7, 0xe5, 0x75, 0xc4, 0x92, 0x32, 0x44, 0xa8, 0x31, 0x7b, 0x81, 0x65, 0xf5, 0xe5, - 0xa3, 0x18, 0xae, 0xaa, 0x03, 0xf9, 0xb1, 0xe0, 0xee, 0x61, 0x6e, 0x0f, 0x70, 0x0f, 0xb8, 0x7d, - 0x70, 0xf7, 0x18, 0xee, 0x2a, 0xb8, 0x7b, 0x34, 0xf7, 0xf1, 0xca, 0x10, 0xdc, 0x01, 0xb8, 0x7b, - 0x22, 0xee, 0x50, 0xd5, 0x81, 0x5b, 0x32, 0x77, 0x2f, 0x74, 0x4f, 0x30, 0xdc, 0xab, 0x74, 0x4f, - 0x32, 0x77, 0x6f, 0xa4, 0xfb, 0x04, 0xe6, 0xee, 0x35, 0xba, 0xff, 0x5b, 0x19, 0x82, 0xfb, 0x7f, - 0x98, 0xbb, 0xb7, 0xae, 0xfb, 0x7f, 0x55, 0x1d, 0xb8, 0xff, 0x4f, 0x6d, 0x6a, 0xc2, 0x91, 0x02, - 0xcb, 0x2d, 0x7d, 0x8a, 0xc4, 0x19, 0x04, 0x81, 0x3e, 0x43, 0x07, 0x19, 0xc8, 0xc4, 0xfb, 0x1c, - 0x1d, 0x64, 0x50, 0x1d, 0xf6, 0x8b, 0x06, 0x6f, 0x44, 0xff, 0xb2, 0x85, 0x37, 0xa8, 0x3e, 0xa1, - 0x96, 0x73, 0xfa, 0xaa, 0x85, 0xf7, 0x3a, 0x14, 0x41, 0xfe, 0x35, 0x3c, 0x50, 0x36, 0xcc, 0xdf, - 0xb4, 0xb0, 0x28, 0x40, 0x9a, 0xf6, 0x6f, 0x75, 0x27, 0x70, 0x9e, 0xb8, 0x8c, 0x2d, 0xb2, 0x9e, - 0x14, 0xc1, 0xb8, 0x53, 0x66, 0xda, 0x93, 0x96, 0x31, 0x8d, 0x41, 0xc0, 0x7c, 0xf2, 0x32, 0xde, - 0xbc, 0x7b, 0xd1, 0x27, 0x27, 0x27, 0x78, 0x03, 0xed, 0x55, 0x9d, 0x72, 0x0a, 0x4e, 0x06, 0xbd, - 0x51, 0xaf, 0x9c, 0x9a, 0x60, 0x85, 0xbd, 0xa6, 0x5b, 0x4e, 0xd3, 0xb6, 0x88, 0x74, 0x7a, 0x82, - 0x37, 0xca, 0xde, 0x7a, 0xc7, 0x9c, 0xa1, 0x6b, 0x91, 0xbd, 0x33, 0x71, 0xa6, 0xe8, 0x59, 0xcd, - 0x21, 0xd6, 0xa1, 0xa2, 0x67, 0x35, 0x42, 0xac, 0x47, 0x88, 0x9e, 0xd5, 0x26, 0xc4, 0x06, 0x84, - 0xe8, 0x59, 0xad, 0x43, 0x6c, 0xd4, 0xb6, 0x08, 0xb1, 0x09, 0x21, 0x7a, 0x56, 0x47, 0x21, 0x36, - 0xeb, 0x5a, 0x84, 0x38, 0x17, 0x21, 0x06, 0xd0, 0x8a, 0x2d, 0xa8, 0x18, 0x50, 0xad, 0x50, 0xe7, - 0x9b, 0x81, 0xa8, 0x15, 0xdb, 0x10, 0x62, 0xc0, 0xb4, 0xe2, 0x42, 0x6d, 0x8b, 0x10, 0x17, 0x21, - 0xc4, 0x40, 0xbd, 0x15, 0x17, 0xeb, 0x5a, 0x84, 0xb8, 0x44, 0x31, 0xd5, 0xca, 0x65, 0xd5, 0x92, - 0x2b, 0x94, 0x35, 0xca, 0x08, 0x75, 0x65, 0x82, 0x4f, 0x10, 0x0a, 0x30, 0xe1, 0xae, 0x4a, 0x70, - 0xc2, 0x15, 0xa6, 0x43, 0x5e, 0x1d, 0xf3, 0x43, 0xd8, 0x6b, 0xf8, 0x74, 0xb0, 0x40, 0xfb, 0x99, - 0xd0, 0xd7, 0xc6, 0xac, 0x10, 0xfe, 0x3a, 0x08, 0x1f, 0x2c, 0xd7, 0xd4, 0xfa, 0xb4, 0x3d, 0xc1, - 0x7d, 0xcb, 0x45, 0x13, 0x6a, 0x47, 0x82, 0x0f, 0x3c, 0x8c, 0xb0, 0xba, 0x9d, 0x50, 0xdb, 0xef, - 0x7a, 0xda, 0xfe, 0x59, 0x08, 0x41, 0xd9, 0x38, 0x3c, 0x07, 0x46, 0x40, 0xec, 0xf1, 0x82, 0xb2, - 0xa8, 0x95, 0xa5, 0x5b, 0x2d, 0x4f, 0xc2, 0xe9, 0xc5, 0x04, 0x0f, 0x69, 0x03, 0x19, 0xbf, 0x97, - 0x10, 0xda, 0xa0, 0xec, 0xfa, 0x0b, 0x88, 0xed, 0x76, 0xc7, 0xdd, 0xa2, 0x5a, 0xac, 0x5e, 0x46, - 0x2a, 0x14, 0x60, 0xdc, 0x5e, 0x49, 0xe8, 0xb1, 0xa7, 0x60, 0xf6, 0x7b, 0x35, 0xc1, 0xab, 0x52, - 0x04, 0x19, 0xcb, 0x5d, 0x68, 0x49, 0xbf, 0x5f, 0x04, 0xd7, 0x6e, 0x90, 0xf7, 0xfb, 0x45, 0x53, - 0xbd, 0x07, 0xbd, 0xd2, 0xef, 0x17, 0x99, 0x62, 0x6f, 0xc2, 0x4e, 0x5a, 0x07, 0xc5, 0xc4, 0x0c, - 0x7b, 0xa1, 0x5b, 0xf2, 0x44, 0x91, 0x5e, 0x83, 0x59, 0x66, 0x04, 0x8d, 0xbb, 0x8b, 0x98, 0x32, - 0x33, 0x12, 0x0e, 0x73, 0xe9, 0x6e, 0x53, 0x42, 0x80, 0x7b, 0x08, 0xe7, 0xcf, 0x91, 0x28, 0x31, - 0xf7, 0x12, 0x56, 0x45, 0xe1, 0xf2, 0x9c, 0xc9, 0xfb, 0xdd, 0xa2, 0x40, 0xf7, 0x35, 0x42, 0x4c, - 0x72, 0x7f, 0x04, 0x75, 0x8b, 0x82, 0x82, 0x1e, 0x68, 0x84, 0xd8, 0xf1, 0x41, 0xe2, 0x24, 0x33, - 0x84, 0x58, 0x0f, 0x11, 0x27, 0x66, 0x65, 0xd9, 0xf7, 0x83, 0x88, 0xfb, 0xe1, 0x29, 0x18, 0x33, - 0x3d, 0x52, 0xc7, 0x22, 0xf6, 0x47, 0xa7, 0x60, 0xec, 0xfb, 0x18, 0x71, 0x37, 0x03, 0x03, 0xff, - 0xe3, 0x28, 0x0f, 0xf9, 0x35, 0x4f, 0x25, 0x6f, 0x07, 0xc2, 0xa3, 0xcc, 0x14, 0xcf, 0xd4, 0x8b, - 0xec, 0xbd, 0x93, 0xec, 0x83, 0xad, 0x03, 0x51, 0x3c, 0xc6, 0x95, 0x63, 0x2b, 0x03, 0xa7, 0xa0, - 0x06, 0x0b, 0x71, 0xbf, 0x34, 0xe0, 0xec, 0xfd, 0xdc, 0x74, 0x98, 0x59, 0x9e, 0x47, 0x36, 0xfb, - 0xfc, 0xd2, 0x0f, 0x32, 0x41, 0x89, 0x5e, 0x46, 0x88, 0x3e, 0xbf, 0xb4, 0x3c, 0x13, 0x94, 0x42, - 0x7a, 0x85, 0xec, 0x39, 0x56, 0x13, 0x17, 0xe9, 0x55, 0xe2, 0x39, 0xca, 0x76, 0xdf, 0xa7, 0x5d, - 0x80, 0x87, 0x1c, 0xaf, 0x48, 0xbb, 0x91, 0x34, 0xfe, 0x64, 0xd2, 0x9c, 0x10, 0x45, 0xda, 0x43, - 0x7c, 0x01, 0x18, 0xf4, 0xd7, 0xd2, 0x5e, 0xd8, 0x75, 0xf9, 0xde, 0x38, 0xbd, 0x06, 0xf7, 0xae, - 0xa1, 0xae, 0x23, 0x97, 0xd3, 0xeb, 0x80, 0x73, 0x6e, 0xc9, 0xa3, 0x37, 0xd4, 0xe7, 0xf1, 0x81, - 0xa4, 0x5f, 0xe2, 0x33, 0x53, 0xf0, 0x43, 0x7a, 0x53, 0x7d, 0x86, 0xae, 0x47, 0xbf, 0x82, 0xa0, - 0x8c, 0x74, 0x3c, 0xe8, 0x7b, 0x0b, 0x19, 0xe2, 0xa2, 0x12, 0xf8, 0x6b, 0xc4, 0xea, 0xf2, 0x43, - 0xda, 0xa7, 0xbf, 0x24, 0xbd, 0x8d, 0x16, 0x75, 0x8b, 0x52, 0x20, 0x44, 0x48, 0xbf, 0x01, 0xde, - 0x33, 0x51, 0xa5, 0xdf, 0x92, 0x7d, 0x80, 0x35, 0x63, 0x30, 0x4b, 0xbf, 0x83, 0xc1, 0x90, 0x53, - 0x74, 0x1d, 0x2f, 0xa4, 0xdf, 0xc3, 0x20, 0xe7, 0x7a, 0xf4, 0x07, 0x7c, 0xe5, 0x1d, 0x8f, 0xde, - 0x21, 0x9e, 0x24, 0xf9, 0xa0, 0xc6, 0x77, 0x20, 0x0c, 0xf6, 0x77, 0xd1, 0x4e, 0x83, 0x20, 0xcf, - 0xef, 0xf1, 0xd9, 0x78, 0xa1, 0x81, 0xcc, 0xf0, 0x7b, 0x1f, 0xe3, 0xb1, 0xcf, 0x2f, 0xb9, 0x05, - 0xa7, 0xcc, 0x17, 0xa6, 0x4b, 0x93, 0x58, 0xd7, 0x15, 0xb0, 0x2a, 0xa0, 0xcb, 0x92, 0x31, 0x03, - 0xbe, 0x30, 0x5d, 0x9e, 0xe4, 0x26, 0x0e, 0x7b, 0x4e, 0x30, 0x39, 0xe0, 0x4b, 0xba, 0x22, 0xc9, - 0x03, 0x05, 0xc5, 0x68, 0x76, 0x5f, 0x93, 0xe4, 0x45, 0xa6, 0x8e, 0x21, 0xfe, 0xb5, 0x49, 0xee, - 0xff, 0x3a, 0x68, 0x14, 0x5c, 0x07, 0x02, 0x5d, 0xca, 0x86, 0xb8, 0xfb, 0x5e, 0x0f, 0x02, 0xb3, - 0x3e, 0x69, 0xf0, 0x27, 0x50, 0xc2, 0x5c, 0x1a, 0xb8, 0x21, 0xc9, 0x8d, 0x54, 0x2b, 0x9d, 0x86, - 0x6e, 0x84, 0x0d, 0xaf, 0x74, 0x1a, 0xb8, 0x09, 0xcd, 0xc9, 0x7a, 0x52, 0x97, 0x6f, 0x86, 0x01, - 0x2f, 0x72, 0x1a, 0xb8, 0x05, 0x06, 0xea, 0xb6, 0x98, 0x73, 0x4b, 0x74, 0x2b, 0x9a, 0x87, 0xcb, - 0x22, 0x17, 0x6f, 0x33, 0xd5, 0x3f, 0xf2, 0x51, 0xbe, 0xdd, 0x94, 0x07, 0x44, 0x89, 0xcb, 0x77, - 0xd4, 0xf9, 0xf3, 0x41, 0x4d, 0xd0, 0x9d, 0x31, 0x91, 0x00, 0x7e, 0xda, 0xd8, 0x3c, 0x60, 0x3f, - 0x83, 0x11, 0x9c, 0x56, 0x3a, 0xe5, 0x50, 0xd0, 0x5d, 0x49, 0xee, 0x40, 0xe5, 0xa5, 0x90, 0xbb, - 0x55, 0x06, 0x8c, 0x9b, 0x02, 0xef, 0x51, 0x7d, 0x23, 0x46, 0x65, 0x6e, 0xcc, 0x1d, 0x95, 0x74, - 0x9f, 0x0a, 0xe6, 0x96, 0xc6, 0x34, 0x70, 0xbf, 0x11, 0xaf, 0xee, 0xd4, 0xf7, 0x82, 0xa4, 0x57, - 0xc8, 0x41, 0x27, 0x70, 0x2a, 0x7a, 0x4b, 0x78, 0x20, 0x89, 0xdd, 0x52, 0xc8, 0x35, 0x4e, 0x40, - 0x0f, 0xa2, 0x30, 0xe4, 0xaf, 0xe5, 0xb6, 0x3c, 0x84, 0x42, 0x4e, 0xd5, 0x3c, 0x0c, 0xdd, 0xb8, - 0xbb, 0x47, 0x5d, 0xf5, 0x08, 0xf8, 0x34, 0x66, 0x36, 0x8f, 0x47, 0x93, 0xd1, 0x25, 0x1f, 0x9d, - 0xff, 0x18, 0x44, 0xa9, 0xf2, 0x0f, 0x73, 0xab, 0x06, 0xe8, 0xf1, 0x18, 0x80, 0x91, 0xf0, 0x04, - 0xfa, 0x4d, 0x01, 0x5a, 0xd4, 0x93, 0x31, 0x1b, 0xec, 0x53, 0x4f, 0x25, 0x79, 0x02, 0x66, 0x3d, - 0x66, 0xbc, 0x72, 0x29, 0xeb, 0xca, 0x7a, 0x70, 0xbe, 0x6a, 0xa9, 0x4a, 0xb8, 0xd1, 0x74, 0xf5, - 0x52, 0x6e, 0x72, 0xd6, 0xd3, 0x44, 0xd7, 0x68, 0x5b, 0x90, 0x5c, 0xbb, 0x54, 0xe5, 0x39, 0xd2, - 0x7a, 0x9d, 0xae, 0xc5, 0x26, 0x77, 0xbd, 0x62, 0x1a, 0xe5, 0x61, 0xc0, 0x61, 0x4e, 0x6b, 0x81, - 0x35, 0xca, 0x08, 0x75, 0x7a, 0x0b, 0xa7, 0x40, 0x01, 0x26, 0xdc, 0x19, 0x38, 0x1b, 0x29, 0x4c, - 0x87, 0x3c, 0x33, 0xe6, 0x87, 0xb0, 0x67, 0xe1, 0x18, 0xa6, 0xfd, 0x4c, 0xe8, 0xb3, 0x5b, 0xd0, - 0xa0, 0x51, 0x8e, 0x74, 0x4e, 0x0b, 0x64, 0x8c, 0x22, 0xca, 0xba, 0x16, 0x25, 0xc3, 0x44, 0x58, - 0x8f, 0xc3, 0x59, 0x76, 0x54, 0xb3, 0x6f, 0xd0, 0xb6, 0x60, 0xde, 0xa8, 0x43, 0x45, 0xac, 0x9b, - 0x62, 0xb1, 0xd1, 0xa8, 0xcd, 0xda, 0x5c, 0x1d, 0x54, 0x70, 0x6a, 0xeb, 0x72, 0x42, 0x71, 0xcc, - 0x98, 0x40, 0x2a, 0xff, 0xa2, 0xce, 0xe0, 0x1a, 0x41, 0xfc, 0x0f, 0xd4, 0x59, 0x5f, 0x43, 0x46, - 0xc5, 0x5f, 0xd5, 0x59, 0x5f, 0xa3, 0x5a, 0xcb, 0x87, 0x0d, 0xde, 0x50, 0xf4, 0x91, 0x3a, 0xeb, - 0x1b, 0x6f, 0xa3, 0xeb, 0xe3, 0x06, 0x4b, 0x88, 0xf9, 0x04, 0x52, 0x33, 0x18, 0x4d, 0xc1, 0x64, - 0x55, 0xd2, 0x05, 0xad, 0x1a, 0xe8, 0xf1, 0x14, 0xb0, 0xa5, 0x15, 0xdb, 0x97, 0x5f, 0xc1, 0xe3, - 0x27, 0x6d, 0x6d, 0xc5, 0x9b, 0x4f, 0xf7, 0x51, 0xb4, 0x0d, 0x15, 0x83, 0x4e, 0x18, 0xae, 0xf5, - 0x83, 0x22, 0x5d, 0xd8, 0x8a, 0xd9, 0xe2, 0x78, 0x45, 0xbf, 0xa2, 0xde, 0xb8, 0x2e, 0x6a, 0xc5, - 0xba, 0x7c, 0x74, 0xe6, 0x07, 0x74, 0xb1, 0xf9, 0x5c, 0x4e, 0x97, 0x20, 0xc0, 0xb0, 0x57, 0x30, - 0x8c, 0x97, 0xb6, 0xda, 0xcd, 0x96, 0x5d, 0x07, 0x44, 0xb1, 0x4f, 0x78, 0x25, 0x39, 0x46, 0x97, - 0x21, 0x40, 0xb7, 0x23, 0x9d, 0x11, 0x27, 0x14, 0x74, 0x43, 0x2b, 0x36, 0x3a, 0x6c, 0x6c, 0xfe, - 0xda, 0x90, 0x6e, 0x44, 0xc0, 0xae, 0x5a, 0x10, 0x08, 0x4f, 0x0e, 0x87, 0x22, 0xa0, 0x9b, 0x10, - 0x05, 0x9f, 0x37, 0xb7, 0xaa, 0x6b, 0x8d, 0xe7, 0x89, 0x02, 0x56, 0xab, 0x6e, 0xba, 0x05, 0x50, - 0x1f, 0x8e, 0xd7, 0xa1, 0x08, 0x64, 0xb6, 0x9b, 0x6e, 0x45, 0xe8, 0x38, 0xc4, 0x1b, 0x50, 0xb6, - 0x9b, 0x6e, 0x6b, 0xc5, 0xd3, 0x91, 0x08, 0x42, 0xce, 0xdb, 0xed, 0x88, 0x94, 0x77, 0xbb, 0x3b, - 0x0d, 0x72, 0x47, 0xab, 0xda, 0x45, 0xd7, 0xaa, 0x29, 0x7d, 0x67, 0x2b, 0x0f, 0xa3, 0x5c, 0x59, - 0x88, 0x2a, 0x3d, 0xdd, 0xaa, 0xb6, 0xbb, 0xc2, 0x71, 0xb4, 0x5d, 0xa5, 0x44, 0x94, 0x85, 0x13, - 0x0a, 0x20, 0x3b, 0xf8, 0x56, 0xbf, 0xd0, 0x3c, 0x3a, 0x78, 0x93, 0x98, 0x5b, 0xf4, 0x4c, 0x2b, - 0x77, 0x57, 0x74, 0x4b, 0x35, 0xf0, 0xce, 0x56, 0x7d, 0x78, 0x8f, 0x90, 0x67, 0xd1, 0x04, 0x9e, - 0xbf, 0x11, 0xf4, 0x1c, 0x20, 0x3c, 0xb6, 0x18, 0xe8, 0xf9, 0x56, 0x1e, 0x25, 0xfa, 0xd9, 0xc0, - 0x80, 0x2f, 0xc0, 0x0e, 0xb7, 0x76, 0x03, 0xbd, 0xd8, 0xaa, 0x26, 0xa9, 0x90, 0x19, 0xe9, 0x7b, - 0xf4, 0x52, 0x54, 0x1c, 0x90, 0xbe, 0x43, 0xbf, 0x68, 0x55, 0x53, 0x5a, 0xc8, 0x34, 0xaa, 0x5f, - 0xae, 0x97, 0x51, 0xff, 0x4a, 0x2b, 0xc6, 0x74, 0x98, 0x1d, 0x1c, 0x5f, 0x41, 0xaf, 0x82, 0x5d, - 0x15, 0x78, 0xa8, 0x38, 0x92, 0x76, 0xc5, 0xa0, 0x7e, 0xa7, 0x5a, 0x15, 0x45, 0xda, 0x5d, 0x77, - 0x49, 0xd3, 0x1e, 0xd5, 0x59, 0xc3, 0xd9, 0x6e, 0xda, 0x8b, 0x6c, 0xf7, 0xb9, 0xc7, 0x09, 0x5e, - 0xf0, 0x76, 0x2d, 0xe3, 0x1c, 0x0d, 0x89, 0x92, 0x98, 0xa8, 0x76, 0xba, 0xbc, 0x33, 0x31, 0xba, - 0x7b, 0x19, 0x8e, 0x35, 0x40, 0xb9, 0xbc, 0x67, 0x19, 0x37, 0x92, 0xc7, 0x70, 0xcf, 0x84, 0x0c, - 0x9c, 0x82, 0x64, 0xf0, 0xac, 0x36, 0x03, 0x0e, 0x7b, 0xc7, 0xd7, 0x7c, 0x09, 0xbe, 0xb3, 0xdb, - 0x38, 0x8d, 0x0c, 0xe6, 0x27, 0xab, 0x40, 0xce, 0x69, 0x33, 0xdb, 0x4d, 0x4e, 0xc0, 0x6f, 0x5d, - 0x9b, 0x79, 0xf9, 0x53, 0xe3, 0x80, 0xb1, 0xf5, 0x11, 0xd7, 0x90, 0xa8, 0x96, 0x9d, 0x02, 0x3c, - 0x37, 0x44, 0x86, 0x43, 0xa2, 0xe2, 0x8f, 0x03, 0xdb, 0xd8, 0x66, 0x5e, 0x12, 0xfb, 0x45, 0x50, - 0x02, 0xb4, 0xa9, 0xad, 0xf1, 0x25, 0x91, 0xb1, 0xcd, 0x6d, 0x0d, 0x0f, 0x8e, 0x0c, 0x9d, 0xdb, - 0xc6, 0xfd, 0xce, 0xd0, 0x1a, 0xa7, 0xec, 0x16, 0x21, 0xc8, 0x2d, 0xd1, 0x79, 0x6d, 0x9c, 0x00, - 0x2e, 0x75, 0xf9, 0x9e, 0x74, 0x5c, 0x2f, 0x64, 0xf4, 0xfc, 0x36, 0x1e, 0xab, 0xf5, 0x07, 0xcb, - 0x6a, 0x55, 0xa8, 0xbd, 0xf1, 0x82, 0xc6, 0x8a, 0x7a, 0x0b, 0xb6, 0xb4, 0xf1, 0xde, 0x1e, 0x09, - 0x1b, 0x74, 0x64, 0x61, 0x8c, 0xf1, 0xad, 0x6d, 0xf6, 0x21, 0xd6, 0xa2, 0x3a, 0x1e, 0x88, 0x50, - 0x04, 0xaa, 0x2d, 0xdb, 0xda, 0xf8, 0x2c, 0x1d, 0x0f, 0x3d, 0xe8, 0x48, 0x38, 0x5d, 0x18, 0x35, - 0x69, 0x30, 0x10, 0x52, 0x42, 0xff, 0x45, 0x51, 0x93, 0x56, 0x9b, 0x64, 0x5f, 0x1c, 0x99, 0xe5, - 0x84, 0x13, 0xa8, 0x78, 0x97, 0x44, 0x02, 0x73, 0xd2, 0x0f, 0x1c, 0x4e, 0xd1, 0x09, 0x30, 0xbe, - 0x34, 0xf2, 0xef, 0x16, 0x55, 0x15, 0xe6, 0xb2, 0xa8, 0xb3, 0xfe, 0x53, 0x4c, 0xa2, 0xdd, 0x97, - 0x47, 0x8c, 0x6a, 0x59, 0x60, 0xec, 0x8a, 0x28, 0x71, 0x6c, 0x85, 0x53, 0x1c, 0xc3, 0x57, 0x46, - 0x81, 0x90, 0x4f, 0x35, 0x03, 0xb8, 0xe2, 0x2a, 0x70, 0x74, 0x3b, 0x52, 0xac, 0xf4, 0x83, 0x8a, - 0x83, 0xec, 0x7c, 0xd0, 0xce, 0x91, 0x18, 0xeb, 0x73, 0xa5, 0x08, 0x78, 0x75, 0x6d, 0xd7, 0xeb, - 0x8d, 0xe8, 0x76, 0x47, 0x47, 0xe9, 0xc3, 0x76, 0x73, 0x71, 0xe3, 0x59, 0x03, 0xe8, 0xa3, 0x76, - 0x0e, 0xc0, 0x45, 0xc5, 0x1d, 0x55, 0x7c, 0xdc, 0x6e, 0xff, 0x9d, 0x75, 0xb0, 0x99, 0xc1, 0x53, - 0x2a, 0x3f, 0x69, 0xb7, 0xff, 0xde, 0x4a, 0x9a, 0x4a, 0xf3, 0x37, 0xaa, 0xfe, 0x14, 0xa4, 0x75, - 0x9f, 0xa8, 0xe2, 0x33, 0x90, 0xaa, 0x8a, 0x69, 0x5e, 0x9f, 0xb7, 0x73, 0x27, 0xea, 0x26, 0x36, - 0xc6, 0xfb, 0xa2, 0x9d, 0xb3, 0x63, 0xa8, 0x22, 0xf8, 0xcb, 0x76, 0x9e, 0x70, 0xdc, 0x3c, 0xfa, - 0x0a, 0x9f, 0x47, 0xfb, 0xb5, 0x80, 0xbe, 0x6e, 0xc7, 0x55, 0xca, 0xf5, 0x6a, 0x52, 0xd0, 0x37, - 0xed, 0xea, 0xac, 0x51, 0xf0, 0xbd, 0x22, 0xfd, 0x0d, 0x09, 0xea, 0x77, 0x0b, 0x81, 0xaf, 0x91, - 0x13, 0x53, 0xbc, 0xcc, 0xf5, 0xfb, 0x9e, 0x1c, 0xa3, 0x93, 0x52, 0xb8, 0x5d, 0xf2, 0xf7, 0x80, - 0x53, 0x11, 0x74, 0x72, 0x0a, 0xb7, 0x55, 0x7f, 0x2d, 0xaf, 0xa0, 0x7c, 0xca, 0x3e, 0x25, 0x85, - 0xbb, 0xb0, 0x02, 0xfc, 0x9a, 0x64, 0xec, 0xd4, 0x14, 0x4e, 0xd5, 0xce, 0x24, 0x5c, 0x4e, 0x83, - 0x4b, 0xb7, 0x33, 0xb9, 0x6a, 0x54, 0x71, 0x9e, 0x0e, 0x4e, 0x00, 0xc7, 0x08, 0x71, 0x1c, 0x9d, - 0x51, 0x2f, 0xff, 0x97, 0x70, 0x02, 0x3a, 0x33, 0xc5, 0x3d, 0xc2, 0x55, 0xcc, 0xd9, 0xef, 0x17, - 0x05, 0x9d, 0x95, 0xe2, 0xb9, 0x62, 0x20, 0xbf, 0x26, 0x81, 0x9e, 0x8d, 0x38, 0x8c, 0x76, 0x3b, - 0x93, 0x74, 0x0e, 0xe2, 0x70, 0x49, 0xf3, 0xac, 0x4b, 0x71, 0xf3, 0xf1, 0xb9, 0x3e, 0xc5, 0xb9, - 0xe2, 0xcf, 0x06, 0xda, 0x0d, 0x29, 0x9e, 0x07, 0x71, 0xd8, 0x50, 0x6f, 0x84, 0xa6, 0x5e, 0x21, - 0xd5, 0x48, 0xa2, 0x4d, 0x29, 0x2c, 0xb6, 0x93, 0x21, 0x27, 0x16, 0x77, 0xa2, 0xb0, 0x4a, 0x9b, - 0x53, 0x3c, 0xf3, 0x62, 0xa0, 0x5f, 0x93, 0x8c, 0x9f, 0x9b, 0x8a, 0x6d, 0x59, 0xe8, 0x89, 0xf3, - 0xa0, 0x5f, 0x23, 0xdc, 0x55, 0xdf, 0xe7, 0x3c, 0x9d, 0x3f, 0x15, 0xc5, 0xbd, 0xe5, 0x02, 0xc8, - 0xc6, 0x06, 0xbf, 0x25, 0xa5, 0x76, 0xa4, 0x4a, 0x34, 0x78, 0xb7, 0xa2, 0xc9, 0xc3, 0xf9, 0x2e, - 0xd0, 0x6e, 0x83, 0xfe, 0xe1, 0x7c, 0x17, 0x9b, 0x84, 0xd2, 0xa9, 0x54, 0x4d, 0xb7, 0x5c, 0x98, - 0xe2, 0x41, 0x35, 0xb5, 0x46, 0xf7, 0xcf, 0x45, 0xa8, 0xcc, 0x14, 0x8b, 0x4c, 0x22, 0xb1, 0x57, - 0x14, 0xeb, 0x4f, 0x21, 0x29, 0x1e, 0x71, 0x8d, 0x95, 0xfa, 0x08, 0x72, 0x09, 0xc2, 0x65, 0x8a, - 0x45, 0x0c, 0x36, 0x47, 0x62, 0xd0, 0xe1, 0x20, 0x7f, 0xa9, 0x71, 0x32, 0xdb, 0x51, 0x9d, 0xef, - 0xb2, 0x14, 0x8f, 0xfb, 0x78, 0x95, 0x66, 0xbb, 0x1c, 0xd9, 0xd3, 0x6c, 0x0a, 0x03, 0xd7, 0x15, - 0x91, 0xba, 0x68, 0xa7, 0xac, 0xb3, 0x5d, 0x19, 0xa9, 0xab, 0x57, 0x6a, 0xbe, 0xab, 0x1a, 0xd4, - 0xe9, 0x6a, 0x30, 0x5e, 0x6d, 0x24, 0xb0, 0xe6, 0x38, 0xdb, 0x35, 0x18, 0x16, 0xf5, 0x0a, 0xcd, - 0x74, 0x2d, 0x14, 0xe4, 0x6a, 0x23, 0xdf, 0x96, 0x9f, 0xeb, 0xa0, 0xa0, 0xb1, 0x52, 0xfb, 0x5d, - 0x0f, 0x05, 0xb9, 0xda, 0xc8, 0xb4, 0xfc, 0xfc, 0xc4, 0x38, 0x4d, 0xcf, 0xcf, 0x0d, 0x10, 0x17, - 0xaf, 0xd2, 0x6c, 0x37, 0xaa, 0xd1, 0xa5, 0xd8, 0x62, 0xf9, 0xb9, 0x29, 0x52, 0xf7, 0x2d, 0xf9, - 0xb9, 0x39, 0x52, 0x37, 0x2d, 0x3f, 0xb7, 0x34, 0xa8, 0x8b, 0xe7, 0xe7, 0x56, 0x23, 0x61, 0x6a, - 0x7e, 0x6e, 0x43, 0x7e, 0xea, 0x15, 0x9a, 0xe9, 0x76, 0x04, 0x19, 0xf6, 0xdc, 0x89, 0x68, 0x74, - 0xe9, 0x41, 0x4c, 0x77, 0xc0, 0xa3, 0xa1, 0x8a, 0x8f, 0xbe, 0x77, 0x4e, 0x87, 0xbb, 0x45, 0x81, - 0x7e, 0x9a, 0x52, 0xff, 0x93, 0xf4, 0xc6, 0x45, 0x20, 0xf3, 0x27, 0xd0, 0xcf, 0x52, 0x78, 0xa8, - 0x72, 0x8e, 0x43, 0xf6, 0xe8, 0xae, 0xa8, 0x88, 0xd9, 0x70, 0x37, 0xac, 0x07, 0x45, 0xe0, 0xfa, - 0xc5, 0x4c, 0xb1, 0x48, 0xf7, 0x60, 0xc2, 0xab, 0x32, 0x96, 0xbe, 0x7b, 0x31, 0x39, 0x56, 0xd7, - 0x9c, 0x40, 0x8a, 0x80, 0xee, 0x83, 0x79, 0x4e, 0x14, 0xf2, 0x3e, 0xdc, 0xef, 0x47, 0x19, 0x6b, - 0x25, 0xaf, 0x74, 0xf4, 0x40, 0xca, 0x1c, 0x95, 0xa0, 0x87, 0x19, 0x1f, 0x4c, 0xf1, 0xc2, 0x98, - 0xf7, 0xbb, 0x9d, 0xc9, 0x90, 0x1e, 0x52, 0xf6, 0x7a, 0x55, 0x0c, 0xe9, 0x61, 0x2c, 0x01, 0x7a, - 0x4a, 0x99, 0x79, 0xf6, 0x08, 0x3a, 0x29, 0x06, 0xea, 0x29, 0xf6, 0x28, 0x96, 0xc5, 0x88, 0x1c, - 0x13, 0xfb, 0x31, 0x10, 0x44, 0x98, 0x7a, 0x95, 0x78, 0x3c, 0x65, 0x56, 0x71, 0x80, 0x66, 0x9e, - 0x3f, 0x81, 0xa6, 0xf0, 0x91, 0x95, 0x97, 0xb6, 0x27, 0xc1, 0x96, 0x93, 0x01, 0x4b, 0x93, 0x2a, - 0x39, 0x4f, 0xa9, 0xe1, 0x11, 0xc7, 0x78, 0x34, 0xd2, 0xcf, 0xa7, 0xe0, 0xa6, 0x2f, 0x9f, 0x46, - 0xa0, 0x95, 0x81, 0x5f, 0x31, 0xdd, 0x00, 0x51, 0xdb, 0xa7, 0xc1, 0xac, 0x8b, 0x76, 0x60, 0x69, - 0xd2, 0x67, 0xae, 0x88, 0xfb, 0x99, 0x06, 0xd4, 0x30, 0xef, 0x34, 0x13, 0x8f, 0xed, 0xe2, 0x5b, - 0x15, 0x3d, 0x1b, 0x9f, 0x5f, 0xfa, 0xad, 0xc0, 0x93, 0xf4, 0x5c, 0x7c, 0x89, 0xd1, 0x1b, 0x9f, - 0xbe, 0xfa, 0x3c, 0x1f, 0xf7, 0xc8, 0x7a, 0xe6, 0xc1, 0xfb, 0x05, 0x24, 0xa0, 0x0e, 0x33, 0xcb, - 0x8b, 0x29, 0xfb, 0x50, 0x6b, 0xb1, 0xc6, 0x8c, 0x44, 0x6d, 0xff, 0x52, 0x7c, 0xc6, 0x9b, 0x3a, - 0x3c, 0x60, 0x9a, 0x49, 0x30, 0x4d, 0xeb, 0xcb, 0xf1, 0xb1, 0x5e, 0xd7, 0xfa, 0x4a, 0x7c, 0xba, - 0x37, 0x6a, 0x7d, 0x35, 0xee, 0x51, 0xd7, 0xba, 0x4b, 0x75, 0x56, 0x04, 0x33, 0xcb, 0x6e, 0x68, - 0xd5, 0xd8, 0x14, 0xad, 0x7b, 0xe2, 0xb3, 0x2f, 0xae, 0x75, 0x2f, 0x86, 0x3f, 0x77, 0x0d, 0xc6, - 0xe3, 0x6b, 0x29, 0xf3, 0xbc, 0xa2, 0xf7, 0xa4, 0xd7, 0x1b, 0xc7, 0x18, 0xa6, 0xc0, 0x1b, 0x29, - 0xfd, 0x44, 0xa2, 0x2f, 0x57, 0x7b, 0xd3, 0x7c, 0x8f, 0xeb, 0x74, 0x3d, 0x7a, 0x2d, 0xcd, 0xbb, - 0x7a, 0x26, 0xd7, 0x95, 0xcd, 0xd2, 0xeb, 0x69, 0x3c, 0xb6, 0x8d, 0x39, 0x01, 0xbd, 0x91, 0x66, - 0x56, 0xfe, 0xd4, 0x1e, 0xbf, 0x4c, 0xf3, 0x1c, 0xd0, 0xff, 0xd2, 0x7f, 0x33, 0xad, 0x6e, 0x85, - 0x5c, 0x38, 0x26, 0x47, 0xbf, 0x4a, 0xf3, 0xa8, 0xd4, 0xf3, 0x95, 0xde, 0x02, 0x77, 0x4f, 0x59, - 0xd2, 0xaf, 0xd3, 0xac, 0xa4, 0x67, 0xa2, 0xea, 0x07, 0x32, 0x27, 0xe4, 0x91, 0x3c, 0x82, 0xf6, - 0x35, 0x62, 0x2b, 0x18, 0x7b, 0xbb, 0x11, 0x3b, 0x8a, 0xb1, 0xdf, 0x20, 0x04, 0x7e, 0xde, 0xc1, - 0x8d, 0xfe, 0x6d, 0x1a, 0xd7, 0x3f, 0x2e, 0xe2, 0x86, 0xfc, 0xbb, 0x34, 0x6f, 0x81, 0x28, 0xeb, - 0x7c, 0xfd, 0x5e, 0x5b, 0x78, 0xc5, 0x2c, 0x1f, 0xec, 0xe9, 0x0f, 0x10, 0xac, 0x73, 0xf2, 0x4e, - 0x1a, 0xc3, 0x19, 0x05, 0x9e, 0x8e, 0x7d, 0x7e, 0xc1, 0x29, 0x0b, 0x7a, 0x17, 0xad, 0xe4, 0x54, - 0x76, 0x3a, 0xa1, 0x48, 0xaf, 0xa0, 0xf7, 0x40, 0x72, 0xb4, 0x98, 0xe0, 0x7b, 0x57, 0x50, 0xa2, - 0xf7, 0x4d, 0x39, 0x27, 0x03, 0x2e, 0xff, 0x31, 0xad, 0x1e, 0x2b, 0xf8, 0x90, 0x4d, 0x7f, 0x4a, - 0xab, 0x07, 0x6d, 0x2e, 0xa8, 0xab, 0x0a, 0xfd, 0x39, 0xad, 0x9e, 0x48, 0x42, 0x19, 0xd0, 0x5f, - 0xd2, 0xea, 0x02, 0x17, 0xca, 0x40, 0xd7, 0x7e, 0x80, 0xda, 0xbe, 0x7c, 0xe0, 0x56, 0xe8, 0xaf, - 0xc8, 0x75, 0x9f, 0x18, 0x95, 0xf4, 0x21, 0x54, 0xf0, 0xa7, 0xb6, 0xfb, 0x08, 0x51, 0x74, 0xe2, - 0x3f, 0x06, 0x0d, 0x0b, 0x96, 0x42, 0xad, 0x0d, 0x9f, 0xc4, 0x90, 0x23, 0x81, 0x7c, 0x9a, 0xe6, - 0xc9, 0xad, 0x10, 0xc5, 0xa1, 0x2c, 0x3f, 0x9b, 0x86, 0x2b, 0xfb, 0xcf, 0x95, 0x10, 0x7f, 0xad, - 0x08, 0xe8, 0x0b, 0x25, 0xa4, 0xea, 0x14, 0xe9, 0x4b, 0x25, 0xa4, 0xea, 0x14, 0xb5, 0x90, 0xaf, - 0xd0, 0xb1, 0xbc, 0xd2, 0x72, 0x46, 0xbf, 0x86, 0xac, 0x55, 0x05, 0x0c, 0xdd, 0x6f, 0x90, 0x99, - 0x55, 0x85, 0xe8, 0x7f, 0x4f, 0xe8, 0xf5, 0x55, 0x41, 0x91, 0x4e, 0xec, 0x60, 0x72, 0xdc, 0x09, - 0xe8, 0x24, 0x7c, 0x0f, 0xa1, 0xc5, 0x27, 0x77, 0xe0, 0x5d, 0x4b, 0x54, 0x85, 0x23, 0xe9, 0x94, - 0x0e, 0x3c, 0xa0, 0xaa, 0xbb, 0x15, 0x9d, 0xaa, 0x4b, 0xe3, 0x22, 0x08, 0x05, 0x9d, 0xd6, 0xc1, - 0xc3, 0x41, 0x97, 0xb4, 0x92, 0xd3, 0x15, 0x91, 0x5b, 0x1a, 0x93, 0x74, 0x46, 0x07, 0x2e, 0xd6, - 0xfc, 0xad, 0x6b, 0xcf, 0xec, 0xc0, 0x6b, 0x32, 0xb7, 0xe1, 0xac, 0x0e, 0xbc, 0xbf, 0xd5, 0xdb, - 0x70, 0x36, 0x3c, 0x73, 0x55, 0x8e, 0x73, 0x4e, 0x87, 0xfa, 0x39, 0x49, 0x50, 0xa8, 0x54, 0x69, - 0x5d, 0x07, 0xce, 0x6e, 0xb5, 0x91, 0x10, 0x2d, 0x50, 0x19, 0x5b, 0xdf, 0x08, 0xaa, 0x74, 0x6d, - 0xe8, 0xd0, 0x93, 0x5d, 0x81, 0xf1, 0x0c, 0x6f, 0xfc, 0xb6, 0x2a, 0xe5, 0xb5, 0xa9, 0x91, 0x2a, - 0xeb, 0x15, 0xc5, 0x04, 0x6d, 0xee, 0xe0, 0x61, 0x9d, 0xf7, 0xf5, 0x78, 0x3b, 0x57, 0x15, 0x03, - 0xb7, 0x82, 0x55, 0xf7, 0xbc, 0x0e, 0xec, 0x2d, 0x81, 0x5b, 0x51, 0xec, 0xe7, 0x47, 0x65, 0x45, - 0x79, 0x01, 0xda, 0x32, 0xec, 0x1d, 0x2d, 0x26, 0x68, 0x8b, 0xfa, 0xae, 0x56, 0x45, 0x40, 0x5b, - 0x3b, 0x3a, 0xbf, 0xbb, 0x7d, 0xdf, 0x92, 0xc4, 0x8b, 0xfb, 0x96, 0x24, 0xde, 0xda, 0xb7, 0x24, - 0xb1, 0xed, 0xed, 0x25, 0xfb, 0x59, 0x8b, 0x0b, 0x7e, 0xa5, 0xbd, 0xea, 0x7a, 0xa5, 0x82, 0x53, - 0x6d, 0x97, 0x6e, 0x71, 0x04, 0xbf, 0x7e, 0x1a, 0x4c, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, - 0x9c, 0x1e, 0xa1, 0x4b, 0xcb, 0x26, 0x00, 0x00, + 0x96, 0xa6, 0x6d, 0x19, 0xec, 0x72, 0xba, 0x14, 0x36, 0xea, 0x61, 0xcf, 0xda, 0x32, 0x9a, 0xb3, + 0x62, 0x98, 0x5d, 0xf5, 0x8c, 0x31, 0xad, 0xfd, 0xb1, 0xa9, 0x15, 0x2c, 0x7a, 0x56, 0x92, 0x65, + 0x75, 0xcb, 0xcc, 0xfe, 0x9a, 0x53, 0xea, 0x7e, 0x6a, 0x15, 0x74, 0x57, 0x35, 0x55, 0xaf, 0x65, + 0x89, 0x0d, 0x87, 0x1c, 0x1d, 0x09, 0xb6, 0xc9, 0x19, 0x86, 0x1c, 0x66, 0xc8, 0x39, 0xdb, 0x98, + 0x38, 0x80, 0x03, 0x30, 0x0c, 0x63, 0x26, 0x11, 0x26, 0x30, 0xe4, 0x38, 0x7b, 0xee, 0xf7, 0xde, + 0xab, 0xae, 0x96, 0xf8, 0xa5, 0x7a, 0xdf, 0xbb, 0xf7, 0xbb, 0xdf, 0xbb, 0x2f, 0x3f, 0xb5, 0x45, + 0x62, 0xa2, 0x1a, 0x88, 0x30, 0x74, 0x7d, 0xaf, 0xbd, 0x1a, 0xf8, 0xd2, 0xb7, 0x9b, 0xa4, 0x5b, + 0x1d, 0x39, 0x64, 0x51, 0xc9, 0x2f, 0xf9, 0x00, 0x52, 0xfc, 0xa5, 0xea, 0x0e, 0xbd, 0x33, 0x61, + 0xcd, 0x59, 0xe9, 0x8a, 0x72, 0x31, 0x3f, 0x59, 0x15, 0xf6, 0x22, 0x6b, 0x86, 0xac, 0x26, 0x13, + 0x2d, 0x89, 0xc3, 0x66, 0x75, 0x36, 0x6d, 0x7f, 0x73, 0xe9, 0x7e, 0x43, 0x33, 0x64, 0xd5, 0x4e, + 0x5a, 0x4d, 0xa3, 0x65, 0xa7, 0x94, 0x9c, 0xd1, 0x92, 0x38, 0x6c, 0xbe, 0xc6, 0x81, 0xa8, 0x1a, + 0xe1, 0x25, 0x67, 0xc6, 0x3c, 0x80, 0xd8, 0x4b, 0xac, 0x03, 0x8a, 0xa2, 0xe0, 0x56, 0x9c, 0x72, + 0xb2, 0x29, 0x56, 0x69, 0x40, 0xae, 0x2f, 0xf8, 0xe5, 0xb2, 0x23, 0x45, 0x72, 0x56, 0xbc, 0x5e, + 0x83, 0xa8, 0x1f, 0x73, 0x82, 0x50, 0xc8, 0xe4, 0xfe, 0x2d, 0x89, 0xc3, 0xe6, 0x44, 0xf5, 0x0a, + 0x3c, 0xf4, 0xf1, 0x84, 0xd5, 0xd4, 0x33, 0x51, 0x0d, 0xec, 0xef, 0x46, 0x92, 0x17, 0x2c, 0x5f, + 0xd0, 0xce, 0x2d, 0x6d, 0x67, 0x9c, 0x9b, 0x13, 0x6b, 0x02, 0x59, 0x33, 0xc7, 0x9d, 0x32, 0x5a, + 0x30, 0x6f, 0x88, 0x3f, 0xed, 0x7f, 0xb0, 0x66, 0x17, 0xc6, 0xdc, 0x72, 0x31, 0x80, 0xfc, 0x99, + 0x87, 0xcd, 0x5d, 0x6e, 0xd5, 0xbd, 0x87, 0xa2, 0x3a, 0xfb, 0xfb, 0xd6, 0xcc, 0xd0, 0x2d, 0xa1, + 0x11, 0x0b, 0x96, 0x1f, 0xa4, 0x4c, 0x72, 0x05, 0xa7, 0xec, 0x04, 0x2b, 0x6b, 0x5e, 0x21, 0xe7, + 0x96, 0x74, 0x14, 0xb6, 0xb2, 0xdb, 0x2d, 0x6b, 0x94, 0x93, 0xf9, 0x13, 0x39, 0x59, 0x55, 0x0d, + 0x9b, 0xbb, 0x7c, 0xa1, 0xf2, 0x89, 0x92, 0x3c, 0x34, 0x67, 0xd4, 0x7c, 0x1e, 0xda, 0x69, 0xed, + 0xdf, 0x39, 0x99, 0x95, 0xa2, 0x62, 0x2f, 0xb1, 0x9a, 0xb8, 0xdf, 0xd0, 0x90, 0x46, 0x29, 0xc0, + 0x39, 0xd3, 0x45, 0x11, 0x16, 0xd0, 0x82, 0xd9, 0x26, 0xd3, 0x8c, 0x1c, 0xbe, 0xa5, 0xc9, 0x9a, + 0x6d, 0x5a, 0x6c, 0xcf, 0xb6, 0x9a, 0x06, 0x6a, 0xe5, 0x32, 0xed, 0x67, 0xcf, 0xb1, 0x66, 0x65, + 0x3d, 0x99, 0x5e, 0x41, 0x09, 0xdb, 0xb2, 0xf6, 0x1f, 0x76, 0xf1, 0x3d, 0xc3, 0x9e, 0x6b, 0x1d, + 0xb0, 0xb2, 0xec, 0x3b, 0xf2, 0x88, 0xe5, 0x34, 0x33, 0x2a, 0xa4, 0x57, 0x50, 0x13, 0x5b, 0xe5, + 0x64, 0xe0, 0x7a, 0x25, 0x9a, 0xc5, 0xce, 0x9d, 0x93, 0x52, 0x84, 0xb4, 0xbf, 0x3d, 0xcf, 0x9a, + 0xdd, 0x3f, 0x19, 0x1e, 0x57, 0xee, 0x74, 0x25, 0x09, 0x9b, 0xac, 0x79, 0x28, 0x75, 0xab, 0x6e, + 0xa4, 0x51, 0xfb, 0x40, 0x6b, 0xbe, 0x42, 0x6a, 0x81, 0x23, 0x5d, 0xdf, 0xa3, 0x92, 0x3d, 0xdf, + 0x9a, 0x03, 0xa8, 0xc7, 0xab, 0x55, 0x68, 0x2c, 0x62, 0x38, 0x4a, 0x4c, 0x90, 0x1b, 0x95, 0x72, + 0x42, 0xd2, 0x31, 0x91, 0x69, 0xde, 0xad, 0x08, 0x3a, 0x36, 0x2a, 0xfe, 0x28, 0xf4, 0x3d, 0x2a, + 0xdb, 0x0b, 0xac, 0x39, 0x6b, 0x9c, 0x72, 0x4d, 0xf4, 0xb9, 0xa1, 0xa4, 0xad, 0x09, 0x2e, 0x77, + 0xf9, 0xe5, 0x5a, 0xc5, 0x1b, 0x12, 0xa3, 0xb4, 0x83, 0x1b, 0x36, 0xab, 0xcb, 0xaf, 0x79, 0x92, + 0xee, 0x6d, 0xb6, 0x67, 0x5b, 0x33, 0x73, 0xb5, 0x0a, 0xdd, 0x87, 0xaf, 0xcc, 0x78, 0x89, 0xee, + 0xc7, 0x57, 0xbf, 0xeb, 0xd1, 0x03, 0xea, 0xcb, 0x99, 0xa0, 0x07, 0x9b, 0xd9, 0x67, 0xa5, 0x1b, + 0x84, 0x92, 0x1e, 0x6a, 0xb6, 0xc9, 0x9a, 0xdb, 0x1b, 0xf8, 0xb5, 0x6a, 0x97, 0xef, 0x15, 0x1c, + 0x49, 0x0f, 0x37, 0xdb, 0x0b, 0x2d, 0x2b, 0x53, 0x2a, 0xfd, 0xa4, 0xd3, 0x95, 0x19, 0xaf, 0x48, + 0x8f, 0x34, 0x73, 0x48, 0x0d, 0xac, 0x0a, 0xe8, 0xd1, 0xb8, 0xc1, 0x8f, 0xfd, 0x80, 0x1e, 0x53, + 0x71, 0x65, 0x91, 0x1e, 0x6f, 0xb6, 0xe7, 0x72, 0x02, 0x8b, 0x45, 0x31, 0x4e, 0x4f, 0xc0, 0x4f, + 0x15, 0x06, 0xfd, 0x2a, 0x3d, 0x09, 0x3f, 0x55, 0xce, 0x39, 0x95, 0x2a, 0x3d, 0x05, 0xeb, 0x35, + 0x4e, 0xc0, 0xb5, 0x4f, 0x37, 0xdb, 0xf3, 0xac, 0x03, 0xd6, 0x38, 0x01, 0xaa, 0xb6, 0x37, 0xdb, + 0xf3, 0xad, 0xd9, 0x6b, 0x9c, 0xc0, 0x75, 0xbc, 0x82, 0xa0, 0x1d, 0xcd, 0xf6, 0x81, 0xd6, 0x3c, + 0xce, 0x47, 0x26, 0x08, 0x9c, 0xc9, 0x4c, 0xa9, 0x44, 0xcf, 0x34, 0xdb, 0xb6, 0x35, 0x9f, 0xa1, + 0x55, 0x23, 0xc7, 0x88, 0x82, 0x64, 0x6c, 0xa7, 0x8a, 0x10, 0x8d, 0x4b, 0xda, 0x34, 0x70, 0xf8, + 0xed, 0x3d, 0xd6, 0xfc, 0x86, 0x91, 0xca, 0xbd, 0xd7, 0xe5, 0x84, 0x32, 0xeb, 0xc9, 0x4c, 0x98, + 0xf5, 0x24, 0xed, 0xc7, 0xbd, 0x17, 0x21, 0x43, 0xc2, 0x29, 0x53, 0xc2, 0x3e, 0xc8, 0x5a, 0x18, + 0x41, 0x7a, 0x40, 0xcc, 0xb0, 0x17, 0x59, 0x14, 0x81, 0xa6, 0xef, 0x67, 0x36, 0x78, 0xa3, 0x07, + 0x9b, 0xec, 0xc5, 0xd6, 0x81, 0x75, 0x43, 0x33, 0x24, 0x66, 0x35, 0x58, 0xa2, 0x73, 0xf7, 0x37, + 0x10, 0x47, 0x55, 0x6a, 0x2c, 0xdb, 0xb6, 0x16, 0xd4, 0x21, 0xc8, 0x99, 0x6b, 0x22, 0x2b, 0x4c, + 0xeb, 0x99, 0x67, 0xc2, 0x28, 0xd4, 0x08, 0x9a, 0xdf, 0x48, 0x00, 0x45, 0x0b, 0xec, 0x83, 0x2d, + 0x3b, 0x66, 0x6a, 0x24, 0x2d, 0x6c, 0xb4, 0x85, 0x26, 0x32, 0xc1, 0x34, 0xa1, 0x92, 0xb5, 0xc8, + 0x04, 0x8b, 0x50, 0x28, 0x5b, 0x6c, 0x37, 0x5b, 0x07, 0x35, 0xc0, 0x5a, 0xdc, 0xc1, 0x76, 0xd2, + 0x5a, 0xd4, 0x50, 0x61, 0xf4, 0x35, 0x4f, 0x63, 0x82, 0xc4, 0xa4, 0xfd, 0x1d, 0x6b, 0x71, 0xa3, + 0x83, 0x51, 0xf9, 0x9d, 0x69, 0x1e, 0x10, 0x7a, 0x88, 0xe9, 0x24, 0x15, 0x52, 0xe9, 0x5c, 0x62, + 0xd4, 0x1b, 0x10, 0x32, 0x97, 0x9a, 0xf6, 0x1b, 0x54, 0xab, 0x6c, 0x31, 0xf2, 0x0d, 0x6e, 0x44, + 0x2e, 0x9b, 0x4a, 0x03, 0x8d, 0x87, 0x9a, 0x46, 0x45, 0xe6, 0x46, 0x62, 0xeb, 0x54, 0x7b, 0x28, + 0xfc, 0xae, 0xe9, 0x5e, 0xf6, 0x56, 0xfa, 0x0e, 0x33, 0x19, 0x57, 0x10, 0xd4, 0x7d, 0xcf, 0x38, + 0x2b, 0x4c, 0x6b, 0x3b, 0xdc, 0xb4, 0x5a, 0xa1, 0x46, 0xd9, 0xf7, 0x1b, 0x09, 0xa0, 0xeb, 0x1f, + 0x4d, 0xf3, 0xb4, 0xa9, 0x51, 0xf5, 0x4f, 0x8d, 0xb6, 0xd0, 0xd4, 0x1e, 0x25, 0x53, 0x5b, 0x29, + 0x5d, 0xcb, 0x0d, 0x45, 0x1d, 0x86, 0xb6, 0x23, 0xa2, 0x7e, 0x8c, 0x70, 0xad, 0x6f, 0x45, 0xd4, + 0x61, 0x51, 0x8d, 0xd1, 0x78, 0xe4, 0x74, 0x32, 0xe8, 0x4c, 0xdb, 0x87, 0x58, 0x07, 0x4f, 0x71, + 0x31, 0x5a, 0x3b, 0xa6, 0xfb, 0x40, 0xef, 0x3f, 0x9b, 0x1c, 0x62, 0xf6, 0x43, 0xeb, 0xbf, 0x98, + 0x66, 0x29, 0x08, 0x3a, 0xff, 0xd5, 0xe4, 0x50, 0x61, 0x5a, 0xe3, 0xbf, 0x99, 0xc6, 0x2a, 0xd4, + 0xe8, 0xfb, 0xf7, 0x46, 0x02, 0x68, 0xfb, 0x0f, 0x13, 0x5f, 0x9b, 0x1a, 0x5d, 0x99, 0x46, 0x5b, + 0x68, 0xea, 0xe4, 0x35, 0xb3, 0xcb, 0x77, 0xca, 0x22, 0x2c, 0x08, 0x56, 0xf4, 0x4e, 0x0b, 0xaf, + 0x4f, 0x06, 0x81, 0xa0, 0x77, 0x5b, 0xec, 0x45, 0xd6, 0x42, 0x03, 0x99, 0xc8, 0xef, 0xb5, 0xd8, + 0x07, 0x59, 0x0b, 0x0c, 0xaa, 0x55, 0xbe, 0xdf, 0xe0, 0x0d, 0x35, 0x7f, 0x6c, 0xb1, 0x17, 0x5b, + 0x14, 0x79, 0x1b, 0x31, 0x7f, 0x6a, 0xb0, 0x84, 0x96, 0x3f, 0xb7, 0xf0, 0x3e, 0xd5, 0x97, 0x67, + 0x19, 0x45, 0xde, 0xbe, 0xfa, 0xf2, 0x88, 0x2f, 0x78, 0x1b, 0xe9, 0xcb, 0xd7, 0xb7, 0xa8, 0x79, + 0xd6, 0xec, 0xbe, 0xbc, 0x8e, 0x58, 0x52, 0x86, 0x08, 0x35, 0x66, 0x2f, 0xb0, 0xac, 0xbe, 0x7c, + 0x14, 0xc3, 0x55, 0x75, 0x20, 0x3f, 0x06, 0xdc, 0x3d, 0xcc, 0xed, 0x01, 0xee, 0x01, 0xb7, 0x0f, + 0xee, 0x1e, 0xc3, 0x5d, 0x05, 0x77, 0x8f, 0xe6, 0x3e, 0x4e, 0x19, 0x82, 0x3b, 0x00, 0x77, 0x4f, + 0xc4, 0x1d, 0xaa, 0x3a, 0x70, 0x4b, 0xe6, 0xee, 0x85, 0xee, 0x09, 0x86, 0x7b, 0x95, 0xee, 0x49, + 0xe6, 0xee, 0x8d, 0x74, 0x1f, 0xcf, 0xdc, 0xbd, 0x46, 0xf7, 0x7f, 0x2b, 0x43, 0x70, 0xff, 0x0f, + 0x73, 0xf7, 0xd6, 0x75, 0xff, 0xaf, 0xaa, 0x03, 0xf7, 0xff, 0xa9, 0x4d, 0x4d, 0x38, 0x52, 0x60, + 0xb9, 0xa5, 0x4f, 0x91, 0x38, 0x83, 0x20, 0xd0, 0x67, 0xe8, 0x20, 0x03, 0x99, 0x78, 0x9f, 0xa3, + 0x83, 0x0c, 0xaa, 0xc3, 0x7e, 0xd1, 0xe0, 0x8d, 0xe8, 0x5f, 0xb6, 0xf0, 0x06, 0xd5, 0x27, 0xd4, + 0x72, 0x4e, 0x5f, 0xb5, 0xf0, 0x5e, 0x87, 0x22, 0xc8, 0xbf, 0x86, 0x07, 0xca, 0x86, 0xf9, 0x9b, + 0x16, 0x16, 0x05, 0x48, 0xd3, 0xfe, 0xad, 0xee, 0x04, 0xce, 0x13, 0x96, 0xb1, 0x45, 0xd6, 0x93, + 0x22, 0x18, 0x77, 0xca, 0x4c, 0x7b, 0xe2, 0x32, 0xa6, 0x31, 0x08, 0x98, 0x4f, 0x5a, 0xc6, 0x9b, + 0x77, 0x2f, 0xfa, 0xe4, 0xa4, 0x04, 0x6f, 0xa0, 0xbd, 0xaa, 0x53, 0x4e, 0xc6, 0xc9, 0xa0, 0x37, + 0xea, 0x95, 0x53, 0x12, 0xac, 0xb0, 0xd7, 0x74, 0xcb, 0xa9, 0xda, 0x16, 0x91, 0x4e, 0x4b, 0xf0, + 0x46, 0xd9, 0x5b, 0xef, 0x98, 0xd3, 0x75, 0x2d, 0xb2, 0x77, 0x06, 0xce, 0x14, 0x3d, 0xab, 0x39, + 0xc4, 0x3a, 0x54, 0xf4, 0xac, 0x46, 0x88, 0xf5, 0x08, 0xd1, 0xb3, 0xda, 0x84, 0xd8, 0x80, 0x10, + 0x3d, 0xab, 0x75, 0x88, 0x8d, 0xda, 0x16, 0x21, 0x36, 0x21, 0x44, 0xcf, 0xea, 0x28, 0xc4, 0x66, + 0x5d, 0x8b, 0x10, 0xe7, 0x20, 0xc4, 0x00, 0x5a, 0xb1, 0x05, 0x15, 0x03, 0xaa, 0x15, 0xea, 0x7c, + 0x33, 0x10, 0xb5, 0x62, 0x1b, 0x42, 0x0c, 0x98, 0x56, 0x5c, 0xa0, 0x6d, 0x11, 0xe2, 0x42, 0x84, + 0x18, 0xa8, 0xb7, 0xe2, 0x22, 0x5d, 0x8b, 0x10, 0x17, 0x2b, 0xa6, 0x5a, 0xb9, 0xac, 0x5a, 0x72, + 0xb9, 0xb2, 0x46, 0x19, 0xa1, 0xae, 0x48, 0xf0, 0x09, 0x42, 0x01, 0x26, 0xdc, 0x95, 0x09, 0x4e, + 0xb8, 0xc2, 0x74, 0xc8, 0xab, 0x62, 0x7e, 0x08, 0x7b, 0x35, 0x9f, 0x0e, 0x16, 0x68, 0x3f, 0x13, + 0xfa, 0x9a, 0x98, 0x15, 0xc2, 0x5f, 0x0b, 0xe1, 0x83, 0xe5, 0x9a, 0x5a, 0x9f, 0xb6, 0x27, 0xb8, + 0x6f, 0xb9, 0x68, 0x42, 0xed, 0x48, 0xf0, 0x81, 0x87, 0x11, 0x56, 0xb7, 0x13, 0x6a, 0xfb, 0x5d, + 0x4f, 0xdb, 0x3f, 0x0b, 0x21, 0x28, 0x1b, 0x87, 0xe7, 0xc0, 0x08, 0x88, 0x3d, 0x5e, 0x50, 0x16, + 0xb5, 0xb2, 0x74, 0xab, 0xe5, 0x49, 0x38, 0xbd, 0x98, 0xe0, 0x21, 0x6d, 0x20, 0xe3, 0xf7, 0x12, + 0x42, 0x1b, 0x94, 0x5d, 0x7f, 0x01, 0xb1, 0xdd, 0xee, 0xb8, 0x5b, 0x54, 0x8b, 0xd5, 0xcb, 0x48, + 0x85, 0x02, 0x8c, 0xdb, 0x2b, 0x09, 0x3d, 0xf6, 0x14, 0xcc, 0x7e, 0xaf, 0x26, 0x78, 0x55, 0x8a, + 0x20, 0x63, 0xb9, 0x0b, 0x2d, 0xe9, 0xf7, 0x8b, 0xe0, 0xda, 0x0d, 0xf2, 0x7e, 0xbf, 0x68, 0xaa, + 0xf7, 0xa0, 0x57, 0xfa, 0xfd, 0x22, 0x53, 0xec, 0x4d, 0xd8, 0x49, 0xeb, 0xa0, 0x98, 0x98, 0x61, + 0x2f, 0x74, 0x4b, 0x9e, 0x28, 0xd2, 0x6b, 0x30, 0xcb, 0x8c, 0xa0, 0x71, 0x77, 0x12, 0x53, 0x66, + 0x46, 0xc2, 0x61, 0x2e, 0xdd, 0x65, 0x4a, 0x08, 0x70, 0x37, 0xe1, 0xfc, 0x39, 0x12, 0x25, 0xe6, + 0x1e, 0xc2, 0xaa, 0x28, 0x5c, 0x9e, 0x33, 0x79, 0xbf, 0x5b, 0x14, 0xe8, 0xde, 0x46, 0x88, 0x49, + 0xee, 0x8b, 0xa0, 0x6e, 0x51, 0x50, 0xd0, 0xfd, 0x8d, 0x10, 0x3b, 0x3e, 0x40, 0x9c, 0x64, 0x86, + 0x10, 0xeb, 0x41, 0xe2, 0xc4, 0xac, 0x2c, 0xfb, 0x7e, 0x10, 0x71, 0x3f, 0x34, 0x05, 0x63, 0xa6, + 0x87, 0xeb, 0x58, 0xc4, 0xfe, 0xc8, 0x14, 0x8c, 0x7d, 0x1f, 0x25, 0xee, 0x66, 0x60, 0xe0, 0x7f, + 0x0c, 0xe5, 0x21, 0xbf, 0xe6, 0xa9, 0xe4, 0xed, 0x40, 0x78, 0x94, 0x99, 0xe2, 0x99, 0x7a, 0x91, + 0xbd, 0x77, 0x92, 0x7d, 0xb0, 0x75, 0x20, 0x8a, 0x47, 0xbb, 0x72, 0x6c, 0x65, 0xe0, 0x14, 0xd4, + 0x60, 0x21, 0xee, 0x97, 0x06, 0x9c, 0xbd, 0x9f, 0x9b, 0x0e, 0x33, 0xcb, 0xf3, 0xc8, 0x66, 0x9f, + 0x5f, 0xfa, 0x61, 0x26, 0x28, 0xd1, 0xcb, 0x08, 0xd1, 0xe7, 0x97, 0x96, 0x67, 0x82, 0x52, 0x48, + 0xaf, 0x90, 0x3d, 0xc7, 0x6a, 0xe2, 0x22, 0xbd, 0x4a, 0x3c, 0x47, 0xd9, 0xee, 0x07, 0xb4, 0x0b, + 0xf0, 0x90, 0xe3, 0x15, 0x69, 0x37, 0x92, 0xc6, 0x9f, 0x4c, 0x9a, 0x13, 0xa2, 0x48, 0x7b, 0x88, + 0x2f, 0x00, 0x83, 0xfe, 0x5a, 0xda, 0x0b, 0xbb, 0x2e, 0xdf, 0x1b, 0xa7, 0xd7, 0xe0, 0xde, 0x35, + 0xd4, 0x75, 0xc4, 0x72, 0x7a, 0x1d, 0x70, 0xce, 0x2d, 0x79, 0xf4, 0x86, 0xfa, 0x3c, 0x2e, 0x90, + 0xf4, 0x4b, 0x7c, 0x66, 0x0a, 0x7e, 0x48, 0x6f, 0xaa, 0xcf, 0xd0, 0xf5, 0xe8, 0x57, 0x10, 0x94, + 0x91, 0x8e, 0x07, 0x7d, 0x6f, 0x21, 0x43, 0x5c, 0x54, 0x02, 0x7f, 0x8d, 0x58, 0x5d, 0x7e, 0x48, + 0xfb, 0xf4, 0x97, 0xa4, 0xb7, 0xd1, 0xa2, 0x6e, 0x51, 0x0a, 0x84, 0x08, 0xe9, 0x37, 0xc0, 0x7b, + 0x26, 0xaa, 0xf4, 0x5b, 0xb2, 0x0f, 0xb0, 0x66, 0x0c, 0x66, 0xe9, 0x77, 0x30, 0x18, 0x72, 0x8a, + 0xae, 0xe3, 0x85, 0xf4, 0x7b, 0x18, 0xe4, 0x5c, 0x8f, 0xfe, 0x80, 0xaf, 0xbc, 0xe3, 0xd1, 0x3b, + 0xc4, 0x93, 0x24, 0x1f, 0xd4, 0xf8, 0x0e, 0x84, 0xc1, 0xfe, 0x2e, 0xda, 0x69, 0x10, 0xe4, 0xf9, + 0x3d, 0x3e, 0x1b, 0x2f, 0x34, 0x90, 0x19, 0x7e, 0xef, 0x63, 0x3c, 0xf6, 0xf9, 0x25, 0xb7, 0xe0, + 0x94, 0xf9, 0xc2, 0x74, 0x49, 0x12, 0xeb, 0xba, 0x02, 0x56, 0x05, 0x74, 0x69, 0x32, 0x66, 0xc0, + 0x17, 0xa6, 0xcb, 0x92, 0xdc, 0xc4, 0x61, 0xcf, 0x09, 0x26, 0x07, 0x7c, 0x49, 0x97, 0x27, 0x79, + 0xa0, 0xa0, 0x18, 0xcd, 0xee, 0xab, 0x93, 0xbc, 0xc8, 0xd4, 0x31, 0xc4, 0xbf, 0x26, 0xc9, 0xfd, + 0x5f, 0x07, 0x8d, 0x82, 0x6b, 0x41, 0xa0, 0x4b, 0xd9, 0x10, 0x77, 0xdf, 0xeb, 0x40, 0x60, 0xd6, + 0x27, 0x0d, 0xfe, 0x14, 0x4a, 0x98, 0x4b, 0x03, 0xd7, 0x27, 0xb9, 0x91, 0x6a, 0xa5, 0xd3, 0xd0, + 0x0d, 0xb0, 0xe1, 0x95, 0x4e, 0x03, 0x37, 0x26, 0xed, 0xbf, 0xb3, 0x0e, 0xae, 0x03, 0xab, 0xbc, + 0x01, 0x5f, 0xf2, 0x47, 0x97, 0x5f, 0xa6, 0xa7, 0xd0, 0xd6, 0xac, 0x27, 0xb5, 0xf1, 0x4d, 0xf0, + 0xe6, 0x15, 0x50, 0x03, 0x37, 0xc3, 0x40, 0x5d, 0x25, 0x73, 0x6e, 0x89, 0x6e, 0x41, 0xdb, 0x71, + 0x93, 0xe4, 0xe2, 0xad, 0xa6, 0xfa, 0xc7, 0x3e, 0xca, 0xb7, 0x99, 0xf2, 0x80, 0x28, 0x71, 0xf9, + 0xf6, 0x3a, 0x7f, 0x3e, 0xa8, 0x09, 0xba, 0x23, 0xd6, 0x02, 0x00, 0x3f, 0x6b, 0x6c, 0x3b, 0xb0, + 0x9f, 0xc3, 0x08, 0x4e, 0x2b, 0x9d, 0x72, 0x28, 0xe8, 0xce, 0x24, 0xf7, 0xae, 0xf2, 0x52, 0xc8, + 0x5d, 0x2a, 0x3d, 0xc6, 0x4d, 0x81, 0x77, 0xab, 0x8e, 0x13, 0xa3, 0x32, 0x37, 0xe6, 0x8e, 0x4a, + 0xba, 0x57, 0x05, 0x73, 0x4b, 0x63, 0x1a, 0xb8, 0xcf, 0x88, 0x57, 0x17, 0xee, 0x7b, 0x40, 0xd2, + 0x2b, 0xe4, 0xa0, 0x13, 0x38, 0x15, 0xbd, 0x5f, 0xdc, 0x9f, 0xc4, 0x56, 0x2a, 0xe4, 0x1a, 0x27, + 0xa0, 0x07, 0x50, 0x18, 0xf2, 0xd7, 0x72, 0x5b, 0x1e, 0x44, 0x21, 0xa7, 0x6a, 0x1e, 0x82, 0x6e, + 0x5c, 0xec, 0xa3, 0x7e, 0x7c, 0x18, 0x7c, 0x1a, 0x33, 0x3b, 0xcb, 0x23, 0xc9, 0xe8, 0x05, 0x00, + 0x23, 0xe3, 0x51, 0x88, 0x52, 0xe5, 0x1f, 0xe5, 0x56, 0x0d, 0xd0, 0x63, 0x31, 0x00, 0xc3, 0xe4, + 0x71, 0x74, 0xaa, 0x02, 0xb4, 0xa8, 0x27, 0x62, 0x36, 0xd8, 0xc4, 0x9e, 0x4c, 0xf2, 0xec, 0xcc, + 0x7a, 0xcc, 0x78, 0xc5, 0x52, 0xd6, 0x95, 0xf5, 0xe0, 0x7c, 0xe5, 0x52, 0x95, 0x70, 0xa3, 0xe9, + 0xaa, 0xa5, 0xdc, 0xe4, 0xac, 0xa7, 0x89, 0xae, 0xd6, 0xb6, 0x20, 0xb9, 0x66, 0xa9, 0xca, 0x73, + 0xa4, 0xf5, 0x5a, 0x5d, 0x8b, 0x1d, 0xf0, 0x3a, 0xc5, 0x34, 0xca, 0xc3, 0x80, 0xc3, 0x9c, 0xda, + 0x02, 0x6b, 0x94, 0x11, 0xea, 0xb4, 0x16, 0x4e, 0x81, 0x02, 0x4c, 0xb8, 0xd3, 0x71, 0x70, 0x52, + 0x98, 0x0e, 0x79, 0x46, 0xcc, 0x0f, 0x61, 0xcf, 0xc4, 0x19, 0x4d, 0xfb, 0x99, 0xd0, 0x67, 0xb5, + 0xa0, 0x41, 0xa3, 0x1c, 0xe9, 0xec, 0x16, 0xc8, 0x18, 0x45, 0x94, 0x75, 0x2d, 0x4a, 0x86, 0x89, + 0xb0, 0x1e, 0x27, 0xb7, 0xec, 0xa8, 0x66, 0xdf, 0xa0, 0x6d, 0xc1, 0xbc, 0x51, 0x87, 0x8a, 0x58, + 0x37, 0xc5, 0x62, 0xa3, 0x51, 0x9b, 0xb5, 0xb9, 0x3a, 0xc5, 0xe0, 0x48, 0xd7, 0xe5, 0x84, 0xe2, + 0xe8, 0x31, 0x81, 0x54, 0xfe, 0x45, 0x1d, 0xd0, 0x35, 0x82, 0xf8, 0x1f, 0xa8, 0x8b, 0x80, 0x86, + 0x8c, 0x8a, 0xbf, 0xaa, 0x8b, 0x80, 0x46, 0xb5, 0x96, 0x0f, 0x1b, 0xbc, 0xa1, 0xe8, 0x23, 0x75, + 0x11, 0x30, 0xde, 0x46, 0xd7, 0xc7, 0x0d, 0x96, 0x10, 0xf3, 0x09, 0xa4, 0x66, 0x30, 0x9a, 0x82, + 0xc9, 0xaa, 0xa4, 0xf3, 0x5b, 0x35, 0xd0, 0xe3, 0x29, 0x60, 0x4b, 0x2b, 0xf6, 0x36, 0xbf, 0x82, + 0x97, 0x51, 0xda, 0xda, 0x8a, 0x07, 0xa1, 0xee, 0x23, 0x69, 0x1b, 0x2a, 0x06, 0x9d, 0x30, 0x5c, + 0xeb, 0x07, 0x45, 0xba, 0xa0, 0x15, 0xb3, 0xc5, 0xf1, 0x8a, 0x7e, 0x45, 0x3d, 0x80, 0x5d, 0xd8, + 0x8a, 0x45, 0xfb, 0xa8, 0xcc, 0x0f, 0xe9, 0x22, 0xf3, 0xb9, 0x9c, 0x2e, 0x46, 0x80, 0x61, 0xaf, + 0x60, 0x18, 0x2f, 0x69, 0xb5, 0x9b, 0x2d, 0xbb, 0x0e, 0x88, 0x62, 0x9f, 0xf0, 0x4a, 0x72, 0x8c, + 0x2e, 0x45, 0x80, 0x6e, 0x47, 0x3a, 0x23, 0x4e, 0x28, 0xe8, 0xfa, 0x56, 0xec, 0x82, 0xd8, 0xf5, + 0xfc, 0xb5, 0x21, 0xdd, 0x80, 0x80, 0x5d, 0xb5, 0x20, 0x10, 0x9e, 0x1c, 0x0e, 0x45, 0x40, 0x37, + 0x22, 0x0a, 0x3e, 0x6f, 0x6a, 0x55, 0x77, 0x1e, 0xcf, 0x13, 0x05, 0x2c, 0x65, 0xdd, 0x74, 0x33, + 0xa0, 0x3e, 0x9c, 0xbd, 0x43, 0x11, 0xc8, 0x6c, 0x37, 0xdd, 0x82, 0xd0, 0x71, 0x88, 0x77, 0xa7, + 0x6c, 0x37, 0xdd, 0xda, 0x8a, 0x77, 0x25, 0x11, 0x84, 0x9c, 0xb7, 0xdb, 0x10, 0x29, 0xef, 0x76, + 0x77, 0x1a, 0xe4, 0xf6, 0x56, 0xb5, 0xc5, 0xae, 0x55, 0x53, 0xfa, 0x8e, 0x56, 0x1e, 0x46, 0xb9, + 0xb2, 0x10, 0x55, 0x7a, 0xba, 0x55, 0xed, 0x85, 0x85, 0x63, 0x69, 0xbb, 0x4a, 0x89, 0x28, 0x0b, + 0x27, 0x14, 0x40, 0x76, 0xf0, 0x95, 0x7f, 0xa1, 0x79, 0x91, 0xf0, 0x26, 0x31, 0xb7, 0xe8, 0x99, + 0x56, 0xee, 0xae, 0xe8, 0x0a, 0x6b, 0xe0, 0x9d, 0xad, 0xfa, 0x64, 0x1f, 0x21, 0xcf, 0xa2, 0x09, + 0x3c, 0x7f, 0x23, 0xe8, 0x39, 0x40, 0x78, 0x89, 0x31, 0xd0, 0xf3, 0xad, 0x3c, 0x4a, 0xf4, 0x9b, + 0x82, 0x01, 0x5f, 0x80, 0x1d, 0xae, 0xf4, 0x06, 0x7a, 0xb1, 0x55, 0x4d, 0x52, 0x21, 0x33, 0xd2, + 0xf7, 0xe8, 0xa5, 0xa8, 0x38, 0x20, 0x7d, 0x87, 0x7e, 0xd1, 0xaa, 0xa6, 0xb4, 0x90, 0x69, 0x54, + 0xbf, 0x5c, 0x2f, 0xa3, 0xfe, 0x95, 0x56, 0x8c, 0xe9, 0x30, 0x3b, 0x38, 0xbe, 0x82, 0x5e, 0x05, + 0xbb, 0x2a, 0xf0, 0x50, 0x71, 0x24, 0xed, 0x8a, 0x41, 0xfd, 0x4e, 0xb5, 0x2a, 0x8a, 0xb4, 0xbb, + 0xee, 0x92, 0xa6, 0x3d, 0xaa, 0xb3, 0x86, 0xb3, 0xdd, 0xb4, 0x17, 0xd9, 0xee, 0x73, 0x8f, 0x15, + 0xbc, 0xe0, 0xed, 0x5a, 0xc6, 0x39, 0x1a, 0x12, 0x25, 0x31, 0x51, 0xed, 0x74, 0x79, 0xdb, 0x62, + 0x74, 0xf7, 0x32, 0x9c, 0x79, 0x80, 0x72, 0x79, 0xcf, 0x32, 0x6e, 0x24, 0x8f, 0xe1, 0x9e, 0x09, + 0x19, 0x38, 0x05, 0xc9, 0xe0, 0x99, 0x6d, 0x06, 0x1c, 0xf6, 0x8e, 0xab, 0xf9, 0x12, 0x7c, 0x67, + 0xb5, 0x71, 0x1a, 0x19, 0xcc, 0x4f, 0x56, 0x81, 0x9c, 0xdd, 0x66, 0xb6, 0x9b, 0x9c, 0x80, 0xdf, + 0xba, 0x36, 0xf3, 0x2c, 0xa8, 0xc6, 0x01, 0x63, 0xeb, 0x23, 0xae, 0x21, 0x51, 0x2d, 0x3b, 0x05, + 0x78, 0x6e, 0x88, 0x0c, 0x87, 0x44, 0xc5, 0x1f, 0x07, 0xb6, 0xb1, 0xcd, 0x3c, 0x33, 0xf6, 0x8b, + 0xa0, 0x04, 0x68, 0x53, 0x5b, 0xe3, 0x33, 0x23, 0x63, 0x9b, 0xdb, 0x1a, 0x5e, 0x23, 0x19, 0x3a, + 0xa7, 0x8d, 0xfb, 0x9d, 0xa1, 0x35, 0x4e, 0xd9, 0x2d, 0x42, 0x90, 0x5b, 0xa2, 0x73, 0xdb, 0x38, + 0x01, 0x5c, 0xea, 0xf2, 0x3d, 0xe9, 0xb8, 0x5e, 0xc8, 0xe8, 0x79, 0x6d, 0x3c, 0x56, 0xeb, 0xaf, + 0x99, 0xd5, 0xaa, 0x50, 0x7b, 0xe3, 0xf9, 0x8d, 0x15, 0xf5, 0x16, 0x6c, 0x69, 0xe3, 0x8d, 0x3f, + 0x12, 0x36, 0xe8, 0xc8, 0xc2, 0x18, 0xe3, 0x5b, 0xdb, 0xec, 0xef, 0x58, 0x8b, 0xea, 0x78, 0x20, + 0x42, 0x11, 0xa8, 0xb6, 0x6c, 0x6b, 0xe3, 0x83, 0x76, 0x3c, 0xf4, 0xa0, 0x23, 0xe1, 0x74, 0x41, + 0xd4, 0xa4, 0xc1, 0x40, 0x48, 0x09, 0xfd, 0x17, 0x46, 0x4d, 0x5a, 0x6d, 0x92, 0x7d, 0x51, 0x64, + 0x96, 0x13, 0x4e, 0xa0, 0xe2, 0x5d, 0x1c, 0x09, 0xcc, 0x49, 0x3f, 0x70, 0x38, 0x45, 0xc7, 0xc3, + 0xf8, 0x92, 0xc8, 0xbf, 0x5b, 0x54, 0x55, 0x98, 0x4b, 0xa3, 0xce, 0xfa, 0x4f, 0x31, 0x89, 0x76, + 0x5f, 0x16, 0x31, 0xaa, 0x65, 0x81, 0xb1, 0xcb, 0xa3, 0xc4, 0xb1, 0x15, 0x8e, 0x78, 0x0c, 0x5f, + 0x11, 0x05, 0x42, 0x3e, 0xd5, 0x0c, 0xe0, 0x8a, 0x2b, 0xc1, 0xd1, 0xed, 0x48, 0xb1, 0xd2, 0x0f, + 0x2a, 0x0e, 0xb2, 0xf3, 0x41, 0x3b, 0x47, 0x62, 0xac, 0xcf, 0x95, 0x22, 0xe0, 0xd5, 0xb5, 0x5d, + 0xaf, 0x37, 0xa2, 0xdb, 0x1d, 0x1d, 0xa5, 0x0f, 0xdb, 0xcd, 0xad, 0x8e, 0x67, 0x0d, 0xa0, 0x8f, + 0xda, 0x39, 0x00, 0x17, 0x15, 0x77, 0x54, 0xf1, 0x71, 0x3b, 0x9f, 0x76, 0xcc, 0x0c, 0x9e, 0x52, + 0xf9, 0x49, 0xbb, 0xfd, 0xf7, 0x56, 0xd2, 0x54, 0x9a, 0xbf, 0x51, 0xf5, 0xa7, 0x20, 0xad, 0xfb, + 0x44, 0x15, 0x9f, 0x81, 0x54, 0x55, 0x4c, 0xf3, 0xfa, 0xbc, 0x9d, 0x3b, 0x51, 0x37, 0xb1, 0x31, + 0xde, 0x17, 0xed, 0x9c, 0x1d, 0x43, 0x15, 0xc1, 0x5f, 0xb6, 0xf3, 0x84, 0xe3, 0xe6, 0xd1, 0x57, + 0xf8, 0x3c, 0xca, 0xaf, 0x05, 0xf4, 0x75, 0x3b, 0xee, 0x59, 0xae, 0x57, 0x93, 0x82, 0xbe, 0x69, + 0x57, 0x67, 0x8d, 0x82, 0xef, 0x15, 0xe9, 0x6f, 0x48, 0x50, 0xbf, 0x5b, 0x08, 0x7c, 0x8d, 0x9c, + 0x90, 0xe2, 0x65, 0xae, 0xdf, 0xf7, 0xe4, 0x18, 0x9d, 0x98, 0xc2, 0xd5, 0x93, 0xbf, 0x07, 0x9c, + 0x8a, 0xa0, 0x93, 0x52, 0xb8, 0xca, 0xfa, 0x6b, 0x79, 0x05, 0xe5, 0x23, 0xf8, 0xc9, 0x29, 0x5c, + 0x94, 0x15, 0xe0, 0xd7, 0x24, 0x63, 0xa7, 0xa4, 0x70, 0xe4, 0x76, 0x26, 0xe1, 0x72, 0x2a, 0x5c, + 0xba, 0x9d, 0xc9, 0x55, 0xa3, 0x8a, 0xf3, 0x34, 0x70, 0x02, 0x38, 0x5a, 0x88, 0x63, 0xe9, 0xf4, + 0x7a, 0xf9, 0xbf, 0x84, 0x13, 0xd0, 0x19, 0x29, 0xee, 0x11, 0xae, 0x62, 0xce, 0x7e, 0xbf, 0x28, + 0xe8, 0xcc, 0x14, 0xcf, 0x15, 0x03, 0xf9, 0x35, 0x09, 0xf4, 0x2c, 0xc4, 0x61, 0xb4, 0xdb, 0x99, + 0xa4, 0xb3, 0x11, 0x87, 0x4b, 0x9a, 0x67, 0x5d, 0x8a, 0x9b, 0x8f, 0xcf, 0xf5, 0x29, 0xce, 0x15, + 0x7f, 0x36, 0xd0, 0x6e, 0x48, 0xf1, 0x3c, 0x88, 0xc3, 0x86, 0x7a, 0x23, 0x34, 0xf5, 0x0a, 0xa9, + 0x46, 0x12, 0x6d, 0x4a, 0x61, 0xb1, 0x9d, 0x0c, 0x39, 0xb1, 0xb8, 0x30, 0x85, 0x55, 0xda, 0x9c, + 0xe2, 0x99, 0x17, 0x03, 0xfd, 0x9a, 0x64, 0xfc, 0x9c, 0x54, 0x6c, 0xcb, 0x42, 0x4f, 0x9c, 0x0b, + 0xfd, 0x1a, 0xe1, 0xae, 0xfa, 0x01, 0xe7, 0xe9, 0xbc, 0xa9, 0x28, 0x2e, 0x35, 0xe7, 0x43, 0x36, + 0x36, 0xf8, 0x2d, 0x29, 0xb5, 0x23, 0x55, 0xa2, 0xc1, 0xbb, 0x15, 0x4d, 0x1e, 0xce, 0x77, 0x81, + 0x76, 0x1b, 0xf4, 0x0f, 0xe7, 0xbb, 0xd8, 0x24, 0x94, 0x4e, 0xa5, 0x6a, 0xba, 0xe5, 0x82, 0x14, + 0x0f, 0xaa, 0xa9, 0x35, 0xba, 0x7f, 0x2e, 0x44, 0x65, 0xa6, 0x58, 0x64, 0x12, 0x89, 0xbd, 0xa2, + 0x58, 0x7f, 0x27, 0x49, 0xf1, 0x88, 0x6b, 0xac, 0xd4, 0x47, 0x90, 0x8b, 0x11, 0x2e, 0x53, 0x2c, + 0x62, 0xb0, 0x39, 0x12, 0x83, 0x0e, 0x07, 0xf9, 0x4b, 0x8c, 0x93, 0xd9, 0x8e, 0xea, 0x7c, 0x97, + 0xa6, 0x78, 0xdc, 0xc7, 0xab, 0x34, 0xdb, 0x65, 0xc8, 0x9e, 0x66, 0x53, 0x18, 0xb8, 0x2e, 0x8f, + 0xd4, 0x45, 0x3b, 0x65, 0x9d, 0xed, 0x8a, 0x48, 0x5d, 0xbd, 0x52, 0xf3, 0x5d, 0xd9, 0xa0, 0x4e, + 0x57, 0x83, 0xf1, 0x2a, 0x23, 0x81, 0x35, 0xc7, 0xd9, 0xae, 0xc6, 0xb0, 0xa8, 0x57, 0x68, 0xa6, + 0x6b, 0xa0, 0x20, 0x57, 0x1b, 0xf9, 0xb6, 0xfc, 0x5c, 0x0b, 0x05, 0x8d, 0x95, 0xda, 0xef, 0x3a, + 0x28, 0xc8, 0xd5, 0x46, 0xa6, 0xe5, 0xe7, 0xa7, 0xc6, 0x69, 0x7a, 0x7e, 0xae, 0x87, 0xb8, 0x78, + 0x95, 0x66, 0xbb, 0x41, 0x8d, 0x2e, 0xc5, 0x16, 0xcb, 0xcf, 0x8d, 0x91, 0xba, 0x6f, 0xc9, 0xcf, + 0x4d, 0x91, 0xba, 0x69, 0xf9, 0xb9, 0xb9, 0x41, 0x5d, 0x3c, 0x3f, 0xb7, 0x18, 0x09, 0x53, 0xf3, + 0x73, 0x2b, 0xf2, 0x53, 0xaf, 0xd0, 0x4c, 0xb7, 0x21, 0xc8, 0xb0, 0xe7, 0x4e, 0x44, 0xa3, 0x4b, + 0x0f, 0x62, 0xba, 0x1d, 0x1e, 0x0d, 0x55, 0x7c, 0xf4, 0xbd, 0x63, 0x3a, 0xdc, 0x2d, 0x0a, 0xf4, + 0xb3, 0x94, 0xfa, 0x87, 0xa5, 0x37, 0x2e, 0x02, 0x99, 0x3f, 0x9e, 0x7e, 0x9e, 0xc2, 0x2b, 0x96, + 0x73, 0x2c, 0xb2, 0x47, 0x77, 0x46, 0x45, 0xcc, 0x86, 0xbb, 0x60, 0x3d, 0x28, 0x02, 0xd7, 0x2f, + 0x66, 0x8a, 0x45, 0xba, 0x1b, 0x13, 0x5e, 0x95, 0xb1, 0xf4, 0xdd, 0x83, 0xc9, 0xb1, 0xba, 0xe6, + 0x04, 0x52, 0x04, 0x74, 0x2f, 0xcc, 0x73, 0xa2, 0x90, 0xf7, 0xe1, 0x7e, 0x1f, 0xca, 0x58, 0x2b, + 0x79, 0xa5, 0xa3, 0xfb, 0x53, 0xe6, 0xa8, 0x04, 0x3d, 0xcc, 0xf8, 0x40, 0x8a, 0x17, 0xc6, 0xbc, + 0xdf, 0xed, 0x4c, 0x86, 0xf4, 0xa0, 0xb2, 0xd7, 0xab, 0x62, 0x48, 0x0f, 0x61, 0x09, 0xd0, 0x53, + 0xca, 0xcc, 0xb3, 0x87, 0xd1, 0x49, 0x31, 0x50, 0x4f, 0xb1, 0x47, 0xb0, 0x2c, 0x46, 0xe4, 0x98, + 0xd8, 0x8f, 0x82, 0x20, 0xc2, 0xd4, 0x93, 0xc5, 0x63, 0x29, 0xb3, 0x8a, 0x03, 0x34, 0xf3, 0xfc, + 0x71, 0x34, 0x85, 0x8f, 0xac, 0xbc, 0xb4, 0x3d, 0x01, 0xb6, 0x9c, 0x0c, 0x58, 0x9a, 0x54, 0xc9, + 0x79, 0x52, 0x0d, 0x8f, 0x38, 0xc6, 0xa3, 0x91, 0x9e, 0x9a, 0x82, 0x9b, 0xbe, 0x7c, 0x1a, 0x81, + 0x56, 0x06, 0x7e, 0xc5, 0x74, 0x03, 0x44, 0x6d, 0x9f, 0x06, 0xb3, 0x2e, 0xda, 0x81, 0xa5, 0x49, + 0x9f, 0xb9, 0x22, 0xee, 0x67, 0x1a, 0x50, 0xc3, 0xbc, 0xd3, 0x4c, 0x3c, 0xb6, 0x8b, 0x6f, 0x55, + 0xf4, 0x6c, 0x7c, 0x7e, 0xe9, 0x87, 0x04, 0x4f, 0xd2, 0x73, 0xf1, 0x25, 0x46, 0x6f, 0x7c, 0xfa, + 0xea, 0xf3, 0x7c, 0xdc, 0x23, 0xeb, 0x99, 0xd7, 0xf0, 0x17, 0x90, 0x80, 0x3a, 0xcc, 0x2c, 0x2f, + 0xa6, 0xec, 0x43, 0xac, 0xc5, 0x1a, 0x33, 0x12, 0xb5, 0xfd, 0x4b, 0xf1, 0x19, 0x6f, 0xea, 0xf0, + 0xba, 0x69, 0x26, 0xc1, 0x34, 0xad, 0x2f, 0xc7, 0xc7, 0x7a, 0x5d, 0xeb, 0x2b, 0xf1, 0xe9, 0xde, + 0xa8, 0xf5, 0xd5, 0xb8, 0x47, 0x5d, 0xeb, 0x2e, 0xd5, 0x59, 0x11, 0xcc, 0x2c, 0xbb, 0xa1, 0x55, + 0x63, 0x53, 0xb4, 0xee, 0x89, 0xcf, 0xbe, 0xb8, 0xd6, 0xbd, 0x18, 0xfe, 0xdc, 0x35, 0x18, 0x8f, + 0xaf, 0xa5, 0xcc, 0xdb, 0x8b, 0xde, 0x93, 0x5e, 0x6f, 0x1c, 0x63, 0x98, 0x02, 0x6f, 0xa4, 0xf4, + 0x13, 0x89, 0xbe, 0x5c, 0xed, 0x4d, 0xf3, 0x3d, 0xae, 0xd3, 0xf5, 0xe8, 0xb5, 0x34, 0xef, 0xea, + 0x99, 0x5c, 0x57, 0x36, 0x4b, 0xaf, 0xa7, 0xf1, 0x12, 0x37, 0xe6, 0x04, 0xf4, 0x46, 0x9a, 0x59, + 0xf9, 0x53, 0x7b, 0xfc, 0x32, 0xcd, 0x73, 0x40, 0xff, 0xbf, 0xff, 0xcd, 0xb4, 0xba, 0x15, 0x72, + 0xe1, 0xe8, 0x1c, 0xfd, 0x2a, 0xcd, 0xa3, 0x52, 0xcf, 0x57, 0x7a, 0x0b, 0xdc, 0x3d, 0x65, 0x49, + 0xbf, 0x4e, 0xb3, 0x92, 0x9e, 0x89, 0xaa, 0x1f, 0xc8, 0x9c, 0x90, 0x47, 0xf0, 0x08, 0xda, 0xd7, + 0x88, 0xad, 0x60, 0xec, 0xed, 0x46, 0xec, 0x48, 0xc6, 0x7e, 0x83, 0x10, 0xf8, 0xed, 0x07, 0x37, + 0xfa, 0xb7, 0x69, 0x5c, 0xff, 0xb8, 0x88, 0x1b, 0xf2, 0xef, 0xd2, 0xbc, 0x05, 0xa2, 0xac, 0xf3, + 0xf5, 0x7b, 0x6d, 0xe1, 0x15, 0xb3, 0x7c, 0xb0, 0xa7, 0x3f, 0x40, 0xb0, 0xce, 0xc9, 0x3b, 0x69, + 0x0c, 0x67, 0x14, 0x78, 0x3a, 0xf6, 0xf9, 0x05, 0xa7, 0x2c, 0xe8, 0x5d, 0xb4, 0x92, 0x53, 0xd9, + 0xe9, 0x84, 0x22, 0xbd, 0x82, 0xde, 0x03, 0xc9, 0x51, 0x62, 0x82, 0xef, 0x5d, 0x41, 0x89, 0xde, + 0x37, 0xe5, 0x9c, 0x0c, 0xb8, 0xfc, 0xc7, 0xb4, 0x7a, 0xac, 0xe0, 0x43, 0x36, 0xfd, 0x29, 0xad, + 0x5e, 0xbb, 0xb9, 0xa0, 0xae, 0x2a, 0xf4, 0xe7, 0xb4, 0x7a, 0x22, 0x09, 0x65, 0x40, 0x7f, 0x49, + 0xab, 0x0b, 0x5c, 0x28, 0x03, 0x5d, 0xfb, 0x01, 0x6a, 0xfb, 0xf2, 0x81, 0x5b, 0xa1, 0xbf, 0x22, + 0xd7, 0x7d, 0x62, 0x54, 0xd2, 0x87, 0x50, 0xc1, 0x9f, 0xda, 0xee, 0x23, 0x44, 0xd1, 0x89, 0xff, + 0x18, 0x34, 0x2c, 0x58, 0x0a, 0xb5, 0x36, 0x7c, 0x12, 0x43, 0x8e, 0x00, 0xf2, 0x69, 0x9a, 0x27, + 0xb7, 0x42, 0x14, 0x87, 0xb2, 0xfc, 0x6c, 0x1a, 0xae, 0xec, 0x3f, 0x57, 0x42, 0xfc, 0xb5, 0x22, + 0xa0, 0x2f, 0x94, 0x90, 0xaa, 0x53, 0xa4, 0x2f, 0x95, 0x90, 0xaa, 0x53, 0xd4, 0x42, 0xbe, 0x42, + 0xc7, 0xf2, 0x4a, 0xcb, 0x19, 0xfd, 0x1a, 0xb2, 0x56, 0x15, 0x30, 0x74, 0xbf, 0x41, 0x66, 0x56, + 0x15, 0xa2, 0x7f, 0x4c, 0xa1, 0xd7, 0x57, 0x05, 0x45, 0x3a, 0xa1, 0x83, 0xc9, 0x71, 0x27, 0xa0, + 0x13, 0xf1, 0x3d, 0x84, 0x16, 0x9f, 0xd4, 0x81, 0x77, 0x2d, 0x51, 0x15, 0x8e, 0xa4, 0x93, 0x3b, + 0xf0, 0xba, 0xaa, 0xee, 0x56, 0x74, 0x8a, 0x2e, 0x8d, 0x8b, 0x20, 0x14, 0x74, 0x6a, 0x07, 0x0f, + 0x07, 0x5d, 0xd2, 0x4a, 0x4e, 0x53, 0x44, 0x6e, 0x69, 0x4c, 0xd2, 0xe9, 0x1d, 0xb8, 0x58, 0xf3, + 0xb7, 0xae, 0x3d, 0xa3, 0x03, 0x4f, 0xcd, 0xdc, 0x86, 0x33, 0x3b, 0xf0, 0xfe, 0x56, 0x6f, 0xc3, + 0x59, 0xf0, 0xcc, 0x55, 0x39, 0xce, 0xd9, 0x1d, 0xea, 0xb7, 0x26, 0x41, 0xa1, 0x52, 0xa5, 0x75, + 0x1d, 0x38, 0xbb, 0xd5, 0x46, 0x42, 0xb4, 0x40, 0x65, 0x6c, 0x7d, 0x23, 0xa8, 0xd2, 0xb5, 0xa1, + 0x43, 0x4f, 0x76, 0x05, 0xc6, 0x33, 0xbc, 0xf1, 0xdb, 0xaa, 0x94, 0xd7, 0xa6, 0x46, 0xaa, 0xac, + 0x57, 0x14, 0x13, 0xb4, 0xb9, 0x83, 0x87, 0x75, 0xde, 0xd7, 0xe3, 0xed, 0x1c, 0x55, 0x0c, 0xdc, + 0x0a, 0x56, 0xdd, 0x73, 0x3b, 0xb0, 0xb7, 0x04, 0x6e, 0x45, 0xb1, 0x9f, 0x17, 0x95, 0x15, 0xe5, + 0xf9, 0x68, 0xcb, 0xb0, 0x77, 0x94, 0x98, 0xa0, 0x2d, 0xea, 0xbb, 0x5a, 0x15, 0x01, 0x6d, 0xed, + 0xe8, 0xfc, 0xde, 0xf6, 0x7d, 0x4b, 0x12, 0x2f, 0xee, 0x5b, 0x92, 0x78, 0x6b, 0xdf, 0x92, 0xc4, + 0xb6, 0xb7, 0x97, 0xec, 0x67, 0x2d, 0x2e, 0xf8, 0x95, 0xf6, 0xaa, 0xeb, 0x95, 0x0a, 0x4e, 0xb5, + 0x5d, 0xba, 0xc5, 0x11, 0xfc, 0x34, 0x6a, 0x30, 0xf1, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x30, + 0x3a, 0x91, 0x1d, 0xe8, 0x26, 0x00, 0x00, } diff --git a/proto/expression.proto b/proto/expression.proto index d71aa99b3..18b757b69 100644 --- a/proto/expression.proto +++ b/proto/expression.proto @@ -282,6 +282,7 @@ enum ScalarFuncSig { RealIsNull = 3113; StringIsNull = 3114; TimeIsNull = 3115; + TimeIsNullOnNotNullCol = 3142; IntIsNull = 3116; // unimplemented in tidb JsonIsNull = 3117; diff --git a/src/prost/tipb.rs b/src/prost/tipb.rs index 448ef97f1..c0b70c11e 100644 --- a/src/prost/tipb.rs +++ b/src/prost/tipb.rs @@ -1,181 +1,181 @@ #[derive(Clone, PartialEq, ::prost::Message)] pub struct TableInfo { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub table_id: ::std::option::Option, - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub columns: ::std::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ColumnInfo { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub column_id: ::std::option::Option, /// MySQL type. - #[prost(int32, optional, tag="2")] + #[prost(int32, optional, tag = "2")] pub tp: ::std::option::Option, - #[prost(int32, optional, tag="3")] + #[prost(int32, optional, tag = "3")] pub collation: ::std::option::Option, - #[prost(int32, optional, tag="4")] + #[prost(int32, optional, tag = "4")] pub column_len: ::std::option::Option, - #[prost(int32, optional, tag="5")] + #[prost(int32, optional, tag = "5")] pub decimal: ::std::option::Option, - #[prost(int32, optional, tag="6")] + #[prost(int32, optional, tag = "6")] pub flag: ::std::option::Option, - #[prost(string, repeated, tag="7")] + #[prost(string, repeated, tag = "7")] pub elems: ::std::vec::Vec, /// Encoded datum. - #[prost(bytes, optional, tag="8")] + #[prost(bytes, optional, tag = "8")] pub default_val: ::std::option::Option>, /// PK handle column value is row handle. - #[prost(bool, optional, tag="21")] + #[prost(bool, optional, tag = "21")] pub pk_handle: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct IndexInfo { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub table_id: ::std::option::Option, - #[prost(int64, optional, tag="2")] + #[prost(int64, optional, tag = "2")] pub index_id: ::std::option::Option, - #[prost(message, repeated, tag="3")] + #[prost(message, repeated, tag = "3")] pub columns: ::std::vec::Vec, - #[prost(bool, optional, tag="4")] + #[prost(bool, optional, tag = "4")] pub unique: ::std::option::Option, } /// KeyRange is the encoded index key range, low is closed, high is open. (low <= x < high) #[derive(Clone, PartialEq, ::prost::Message)] pub struct KeyRange { - #[prost(bytes, optional, tag="1")] + #[prost(bytes, optional, tag = "1")] pub low: ::std::option::Option>, - #[prost(bytes, optional, tag="2")] + #[prost(bytes, optional, tag = "2")] pub high: ::std::option::Option>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnalyzeReq { - #[prost(enumeration="AnalyzeType", optional, tag="1")] + #[prost(enumeration = "AnalyzeType", optional, tag = "1")] pub tp: ::std::option::Option, - #[prost(uint64, optional, tag="2")] + #[prost(uint64, optional, tag = "2")] pub start_ts: ::std::option::Option, - #[prost(uint64, optional, tag="3")] + #[prost(uint64, optional, tag = "3")] pub flags: ::std::option::Option, - #[prost(int64, optional, tag="4")] + #[prost(int64, optional, tag = "4")] pub time_zone_offset: ::std::option::Option, - #[prost(message, optional, tag="5")] + #[prost(message, optional, tag = "5")] pub idx_req: ::std::option::Option, - #[prost(message, optional, tag="6")] + #[prost(message, optional, tag = "6")] pub col_req: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnalyzeIndexReq { /// bucket_size is the max histograms bucket size. - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub bucket_size: ::std::option::Option, /// num_columns is the number of columns in the index. - #[prost(int32, optional, tag="2")] + #[prost(int32, optional, tag = "2")] pub num_columns: ::std::option::Option, - #[prost(int32, optional, tag="3")] + #[prost(int32, optional, tag = "3")] pub cmsketch_depth: ::std::option::Option, - #[prost(int32, optional, tag="4")] + #[prost(int32, optional, tag = "4")] pub cmsketch_width: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnalyzeColumnsReq { /// bucket_size is the max histograms bucket size, we need this because when primary key is handle, /// the histogram will be directly built. - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub bucket_size: ::std::option::Option, /// sample_size is the max number of samples that will be collected. - #[prost(int64, optional, tag="2")] + #[prost(int64, optional, tag = "2")] pub sample_size: ::std::option::Option, /// sketch_size is the max sketch size. - #[prost(int64, optional, tag="3")] + #[prost(int64, optional, tag = "3")] pub sketch_size: ::std::option::Option, /// columns_info is the info of all the columns that needs to be analyzed. - #[prost(message, repeated, tag="4")] + #[prost(message, repeated, tag = "4")] pub columns_info: ::std::vec::Vec, - #[prost(int32, optional, tag="5")] + #[prost(int32, optional, tag = "5")] pub cmsketch_depth: ::std::option::Option, - #[prost(int32, optional, tag="6")] + #[prost(int32, optional, tag = "6")] pub cmsketch_width: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnalyzeColumnsResp { /// collectors is the sample collectors for columns. - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub collectors: ::std::vec::Vec, /// pk_hist is the histogram for primary key when it is the handle. - #[prost(message, optional, tag="2")] + #[prost(message, optional, tag = "2")] pub pk_hist: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct AnalyzeIndexResp { - #[prost(message, optional, tag="1")] + #[prost(message, optional, tag = "1")] pub hist: ::std::option::Option, - #[prost(message, optional, tag="2")] + #[prost(message, optional, tag = "2")] pub cms: ::std::option::Option, } /// Bucket is an element of histogram. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Bucket { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub count: ::std::option::Option, - #[prost(bytes, optional, tag="2")] + #[prost(bytes, optional, tag = "2")] pub lower_bound: ::std::option::Option>, - #[prost(bytes, optional, tag="3")] + #[prost(bytes, optional, tag = "3")] pub upper_bound: ::std::option::Option>, - #[prost(int64, optional, tag="4")] + #[prost(int64, optional, tag = "4")] pub repeats: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Histogram { /// ndv is the number of distinct values. - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub ndv: ::std::option::Option, /// buckets represents all the buckets. - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub buckets: ::std::vec::Vec, } /// FMSketch is used to count distinct values for columns. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FmSketch { - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub mask: ::std::option::Option, - #[prost(uint64, repeated, packed="false", tag="2")] + #[prost(uint64, repeated, packed = "false", tag = "2")] pub hashset: ::std::vec::Vec, } /// SampleCollector is used for collect samples and calculate the count and ndv of an column. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SampleCollector { - #[prost(bytes, repeated, tag="1")] + #[prost(bytes, repeated, tag = "1")] pub samples: ::std::vec::Vec>, - #[prost(int64, optional, tag="2")] + #[prost(int64, optional, tag = "2")] pub null_count: ::std::option::Option, - #[prost(int64, optional, tag="3")] + #[prost(int64, optional, tag = "3")] pub count: ::std::option::Option, - #[prost(message, optional, tag="4")] + #[prost(message, optional, tag = "4")] pub fm_sketch: ::std::option::Option, - #[prost(message, optional, tag="5")] + #[prost(message, optional, tag = "5")] pub cm_sketch: ::std::option::Option, - #[prost(int64, optional, tag="6")] + #[prost(int64, optional, tag = "6")] pub total_size: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct CmSketchRow { - #[prost(uint32, repeated, packed="false", tag="1")] + #[prost(uint32, repeated, packed = "false", tag = "1")] pub counters: ::std::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct CmSketchTopN { - #[prost(bytes, optional, tag="1")] + #[prost(bytes, optional, tag = "1")] pub data: ::std::option::Option>, - #[prost(uint64, optional, tag="2")] + #[prost(uint64, optional, tag = "2")] pub count: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct CmSketch { - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub rows: ::std::vec::Vec, - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub top_n: ::std::vec::Vec, - #[prost(uint64, optional, tag="3")] + #[prost(uint64, optional, tag = "3")] pub default_value: ::std::option::Option, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -186,20 +186,20 @@ pub enum AnalyzeType { } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ChecksumRequest { - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub start_ts: ::std::option::Option, - #[prost(enumeration="ChecksumScanOn", optional, tag="2")] + #[prost(enumeration = "ChecksumScanOn", optional, tag = "2")] pub scan_on: ::std::option::Option, - #[prost(enumeration="ChecksumAlgorithm", optional, tag="3")] + #[prost(enumeration = "ChecksumAlgorithm", optional, tag = "3")] pub algorithm: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ChecksumResponse { - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub checksum: ::std::option::Option, - #[prost(uint64, optional, tag="2")] + #[prost(uint64, optional, tag = "2")] pub total_kvs: ::std::option::Option, - #[prost(uint64, optional, tag="3")] + #[prost(uint64, optional, tag = "3")] pub total_bytes: ::std::option::Option, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -215,42 +215,42 @@ pub enum ChecksumAlgorithm { } #[derive(Clone, PartialEq, ::prost::Message)] pub struct FieldType { - #[prost(int32, optional, tag="1")] + #[prost(int32, optional, tag = "1")] pub tp: ::std::option::Option, - #[prost(uint32, optional, tag="2")] + #[prost(uint32, optional, tag = "2")] pub flag: ::std::option::Option, - #[prost(int32, optional, tag="3")] + #[prost(int32, optional, tag = "3")] pub flen: ::std::option::Option, - #[prost(int32, optional, tag="4")] + #[prost(int32, optional, tag = "4")] pub decimal: ::std::option::Option, - #[prost(int32, optional, tag="5")] + #[prost(int32, optional, tag = "5")] pub collate: ::std::option::Option, - #[prost(string, optional, tag="6")] + #[prost(string, optional, tag = "6")] pub charset: ::std::option::Option, } /// Evaluators should implement evaluation functions for every expression type. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Expr { - #[prost(enumeration="ExprType", optional, tag="1")] + #[prost(enumeration = "ExprType", optional, tag = "1")] pub tp: ::std::option::Option, - #[prost(bytes, optional, tag="2")] + #[prost(bytes, optional, tag = "2")] pub val: ::std::option::Option>, - #[prost(message, repeated, tag="3")] + #[prost(message, repeated, tag = "3")] pub children: ::std::vec::Vec, - #[prost(enumeration="ScalarFuncSig", optional, tag="4")] + #[prost(enumeration = "ScalarFuncSig", optional, tag = "4")] pub sig: ::std::option::Option, - #[prost(message, optional, tag="5")] + #[prost(message, optional, tag = "5")] pub field_type: ::std::option::Option, } /// ByItem type for group by and order by. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ByItem { - #[prost(message, optional, tag="1")] + #[prost(message, optional, tag = "1")] pub expr: ::std::option::Option, - #[prost(bool, optional, tag="2")] + #[prost(bool, optional, tag = "2")] pub desc: ::std::option::Option, } -/// Children count 0. +/// Children count 0. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ExprType { @@ -275,8 +275,7 @@ pub enum ExprType { ValueList = 151, /// Column reference. value is int64 column ID. ColumnRef = 201, - // Mysql functions, children count is function specific. - + // Mysql functions, children count is function specific. /// Aggregate functions. Count = 3001, Sum = 3002, @@ -297,13 +296,13 @@ pub enum ExprType { Variance = 3017, JsonArrayAgg = 3018, JsonObjectAgg = 3019, - /// Scalar Function + /// Scalar Function ScalarFunc = 10000, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ScalarFuncSig { - /// Casting + /// Casting CastIntAsInt = 0, CastIntAsReal = 1, CastIntAsString = 2, @@ -501,6 +500,7 @@ pub enum ScalarFuncSig { RealIsNull = 3113, StringIsNull = 3114, TimeIsNull = 3115, + TimeIsNullOnNotNullCol = 3142, IntIsNull = 3116, /// unimplemented in tidb JsonIsNull = 3117, @@ -559,7 +559,7 @@ pub enum ScalarFuncSig { CaseWhenDuration = 4213, /// unimplemented in tidb CaseWhenJson = 4214, - /// encryption + /// encryption AesDecrypt = 4501, AesEncrypt = 4502, Compress = 4503, @@ -741,7 +741,7 @@ pub enum ScalarFuncSig { FromDays = 6106, TimeFormat = 6107, TimestampDiff = 6108, - /// String functions + /// String functions BitLength = 7001, Bin = 7002, Ascii = 7003, @@ -809,94 +809,94 @@ pub enum ScalarFuncSig { /// It represents a Executor. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Executor { - #[prost(enumeration="ExecType", optional, tag="1")] + #[prost(enumeration = "ExecType", optional, tag = "1")] pub tp: ::std::option::Option, - #[prost(message, optional, tag="2")] + #[prost(message, optional, tag = "2")] pub tbl_scan: ::std::option::Option, - #[prost(message, optional, tag="3")] + #[prost(message, optional, tag = "3")] pub idx_scan: ::std::option::Option, - #[prost(message, optional, tag="4")] + #[prost(message, optional, tag = "4")] pub selection: ::std::option::Option, - #[prost(message, optional, tag="5")] + #[prost(message, optional, tag = "5")] pub aggregation: ::std::option::Option, - #[prost(message, optional, tag="6")] + #[prost(message, optional, tag = "6")] pub top_n: ::std::option::Option, - #[prost(message, optional, tag="7")] + #[prost(message, optional, tag = "7")] pub limit: ::std::option::Option, - #[prost(message, optional, tag="8")] + #[prost(message, optional, tag = "8")] pub stream_agg: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct TableScan { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub table_id: ::std::option::Option, - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub columns: ::std::vec::Vec, - #[prost(bool, optional, tag="3")] + #[prost(bool, optional, tag = "3")] pub desc: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct IndexScan { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub table_id: ::std::option::Option, - #[prost(int64, optional, tag="2")] + #[prost(int64, optional, tag = "2")] pub index_id: ::std::option::Option, - #[prost(message, repeated, tag="3")] + #[prost(message, repeated, tag = "3")] pub columns: ::std::vec::Vec, - #[prost(bool, optional, tag="4")] + #[prost(bool, optional, tag = "4")] pub desc: ::std::option::Option, /// check whether it is a unique index. - #[prost(bool, optional, tag="5")] + #[prost(bool, optional, tag = "5")] pub unique: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Selection { /// Where conditions. - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub conditions: ::std::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Projection { /// Projection expressions. - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub exprs: ::std::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Aggregation { /// Group by clause. - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub group_by: ::std::vec::Vec, /// Aggregate functions. - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub agg_func: ::std::vec::Vec, /// If it is a stream aggregation. - #[prost(bool, optional, tag="3")] + #[prost(bool, optional, tag = "3")] pub streamed: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct TopN { /// Order by clause. - #[prost(message, repeated, tag="1")] + #[prost(message, repeated, tag = "1")] pub order_by: ::std::vec::Vec, - #[prost(uint64, optional, tag="2")] + #[prost(uint64, optional, tag = "2")] pub limit: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Limit { /// Limit the result to be returned. - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub limit: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct ExecutorExecutionSummary { /// Total time cost in this executor. Includes self time cost and children time cost. - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub time_processed_ns: ::std::option::Option, /// How many rows this executor produced totally. - #[prost(uint64, optional, tag="2")] + #[prost(uint64, optional, tag = "2")] pub num_produced_rows: ::std::option::Option, /// How many times executor's `next()` is called. - #[prost(uint64, optional, tag="3")] + #[prost(uint64, optional, tag = "3")] pub num_iterations: ::std::option::Option, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -914,71 +914,71 @@ pub enum ExecType { /// values are all in text format. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Row { - #[prost(bytes, optional, tag="1")] + #[prost(bytes, optional, tag = "1")] pub handle: ::std::option::Option>, - #[prost(bytes, optional, tag="2")] + #[prost(bytes, optional, tag = "2")] pub data: ::std::option::Option>, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct Error { - #[prost(int32, optional, tag="1")] + #[prost(int32, optional, tag = "1")] pub code: ::std::option::Option, - #[prost(string, optional, tag="2")] + #[prost(string, optional, tag = "2")] pub msg: ::std::option::Option, } /// Response for SelectRequest. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SelectResponse { - #[prost(message, optional, tag="1")] + #[prost(message, optional, tag = "1")] pub error: ::std::option::Option, /// Result rows. - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub rows: ::std::vec::Vec, /// Use multiple chunks to reduce memory allocation and /// avoid allocating large contiguous memory. - #[prost(message, repeated, tag="3")] + #[prost(message, repeated, tag = "3")] pub chunks: ::std::vec::Vec, - #[prost(message, repeated, tag="4")] + #[prost(message, repeated, tag = "4")] pub warnings: ::std::vec::Vec, - #[prost(int64, repeated, packed="false", tag="5")] + #[prost(int64, repeated, packed = "false", tag = "5")] pub output_counts: ::std::vec::Vec, - #[prost(int64, optional, tag="6")] + #[prost(int64, optional, tag = "6")] pub warning_count: ::std::option::Option, - #[prost(bytes, optional, tag="7")] + #[prost(bytes, optional, tag = "7")] pub row_batch_data: ::std::option::Option>, /// The execution summary of each executor, in the order in request. - #[prost(message, repeated, tag="8")] + #[prost(message, repeated, tag = "8")] pub execution_summaries: ::std::vec::Vec, } /// Chunk contains multiple rows data and rows meta. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Chunk { /// Data for all rows in the chunk. - #[prost(bytes, optional, tag="3")] + #[prost(bytes, optional, tag = "3")] pub rows_data: ::std::option::Option>, /// Meta data for every row. - #[prost(message, repeated, tag="4")] + #[prost(message, repeated, tag = "4")] pub rows_meta: ::std::vec::Vec, } /// RowMeta contains row handle and length of a row. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RowMeta { - #[prost(int64, optional, tag="1")] + #[prost(int64, optional, tag = "1")] pub handle: ::std::option::Option, - #[prost(int64, optional, tag="2")] + #[prost(int64, optional, tag = "2")] pub length: ::std::option::Option, } /// DAGRequest represents the request that will be handled with DAG mode. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DagRequest { /// Transaction start timestamp. - #[prost(uint64, optional, tag="1")] + #[prost(uint64, optional, tag = "1")] pub start_ts: ::std::option::Option, /// It represents push down Executors. - #[prost(message, repeated, tag="2")] + #[prost(message, repeated, tag = "2")] pub executors: ::std::vec::Vec, /// time zone offset in seconds - #[prost(int64, optional, tag="3")] + #[prost(int64, optional, tag = "3")] pub time_zone_offset: ::std::option::Option, /// flags are used to store flags that change the execution mode, it contains: /// ignore_truncate = 1 @@ -987,50 +987,49 @@ pub struct DagRequest { /// when ignored_truncate is not set, return warning instead of error if this flag is set. /// ... /// add more when needed. - #[prost(uint64, optional, tag="4")] + #[prost(uint64, optional, tag = "4")] pub flags: ::std::option::Option, /// It represents which columns we should output. - #[prost(uint32, repeated, packed="false", tag="5")] + #[prost(uint32, repeated, packed = "false", tag = "5")] pub output_offsets: ::std::vec::Vec, /// It represents whether we collect the detailed scan counts in each range. - #[prost(bool, optional, tag="6")] + #[prost(bool, optional, tag = "6")] pub collect_range_counts: ::std::option::Option, /// It indicates the maximum number of warning, /// which is the number of messages that SHOW WARNINGS displays. - #[prost(uint64, optional, tag="7")] + #[prost(uint64, optional, tag = "7")] pub max_warning_count: ::std::option::Option, /// It indicates the encode type of response. - #[prost(enumeration="EncodeType", optional, tag="8")] + #[prost(enumeration = "EncodeType", optional, tag = "8")] pub encode_type: ::std::option::Option, /// It indicates the sql_mode. - #[prost(uint64, optional, tag="9")] + #[prost(uint64, optional, tag = "9")] pub sql_mode: ::std::option::Option, // It indicates whether the sql mode is strict. // Deprecated. Don't use. // optional bool is_strict_sql_mode = 10; - /// supply offset is not enough since we have daylight saving time present in some regions - #[prost(string, optional, tag="11")] + #[prost(string, optional, tag = "11")] pub time_zone_name: ::std::option::Option, /// It represents whether or not TiKV should collect execution summaries. /// Execution summaries will be collected into `execution_summaries` field /// in the response. - #[prost(bool, optional, tag="12")] + #[prost(bool, optional, tag = "12")] pub collect_execution_summaries: ::std::option::Option, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct StreamResponse { - #[prost(message, optional, tag="1")] + #[prost(message, optional, tag = "1")] pub error: ::std::option::Option, /// Data for all rows - #[prost(bytes, optional, tag="3")] + #[prost(bytes, optional, tag = "3")] pub data: ::std::option::Option>, - #[prost(message, repeated, tag="4")] + #[prost(message, repeated, tag = "4")] pub warnings: ::std::vec::Vec, /// output row count for each executor - #[prost(int64, repeated, packed="false", tag="5")] + #[prost(int64, repeated, packed = "false", tag = "5")] pub output_counts: ::std::vec::Vec, - #[prost(int64, optional, tag="6")] + #[prost(int64, optional, tag = "6")] pub warning_count: ::std::option::Option, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] diff --git a/src/prost/wrapper_tipb.rs b/src/prost/wrapper_tipb.rs index 2c64d203d..517638005 100644 --- a/src/prost/wrapper_tipb.rs +++ b/src/prost/wrapper_tipb.rs @@ -1,2932 +1,5552 @@ impl TableInfo { -pub fn new_() -> TableInfo { ::std::default::Default::default() } -pub fn has_table_id(&self) -> bool { self.table_id.is_some() } -pub fn clear_table_id(&mut self) { self.table_id = ::std::option::Option::None } -pub fn set_table_id(&mut self, v: i64) { self.table_id = ::std::option::Option::Some(v); } -pub fn get_table_id(&self) -> i64 { match self.table_id { - Some(v) => v, - None => 0, - } } -pub fn clear_columns(&mut self) { self.columns.clear(); } -pub fn set_columns(&mut self, v: :: std :: vec :: Vec < ColumnInfo >) { self.columns = v; } -pub fn get_columns(&self) -> &:: std :: vec :: Vec < ColumnInfo > { &self.columns } -pub fn mut_columns(&mut self) -> &mut :: std :: vec :: Vec < ColumnInfo > { &mut self.columns } -pub fn take_columns(&mut self) -> :: std :: vec :: Vec < ColumnInfo > { ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for TableInfo {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for TableInfo {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static TableInfo { - ::lazy_static::lazy_static! { - static ref INSTANCE: TableInfo = TableInfo::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> TableInfo { + ::std::default::Default::default() + } + pub fn has_table_id(&self) -> bool { + self.table_id.is_some() + } + pub fn clear_table_id(&mut self) { + self.table_id = ::std::option::Option::None + } + pub fn set_table_id(&mut self, v: i64) { + self.table_id = ::std::option::Option::Some(v); + } + pub fn get_table_id(&self) -> i64 { + match self.table_id { + Some(v) => v, + None => 0, } + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + pub fn set_columns(&mut self, v: ::std::vec::Vec) { + self.columns = v; + } + pub fn get_columns(&self) -> &::std::vec::Vec { + &self.columns + } + pub fn mut_columns(&mut self) -> &mut ::std::vec::Vec { + &mut self.columns + } + pub fn take_columns(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for TableInfo { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for TableInfo { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static TableInfo { + ::lazy_static::lazy_static! { + static ref INSTANCE: TableInfo = TableInfo::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl ColumnInfo { -pub fn new_() -> ColumnInfo { ::std::default::Default::default() } -pub fn has_column_id(&self) -> bool { self.column_id.is_some() } -pub fn clear_column_id(&mut self) { self.column_id = ::std::option::Option::None } -pub fn set_column_id(&mut self, v: i64) { self.column_id = ::std::option::Option::Some(v); } -pub fn get_column_id(&self) -> i64 { match self.column_id { - Some(v) => v, - None => 0, - } } -pub fn has_tp(&self) -> bool { self.tp.is_some() } -pub fn clear_tp(&mut self) { self.tp = ::std::option::Option::None } -pub fn set_tp(&mut self, v: i32) { self.tp = ::std::option::Option::Some(v); } -pub fn get_tp(&self) -> i32 { match self.tp { - Some(v) => v, - None => 0, - } } -pub fn has_collation(&self) -> bool { self.collation.is_some() } -pub fn clear_collation(&mut self) { self.collation = ::std::option::Option::None } -pub fn set_collation(&mut self, v: i32) { self.collation = ::std::option::Option::Some(v); } -pub fn get_collation(&self) -> i32 { match self.collation { - Some(v) => v, - None => 0, - } } -pub fn has_column_len(&self) -> bool { self.column_len.is_some() } -pub fn clear_column_len(&mut self) { self.column_len = ::std::option::Option::None } -pub fn set_column_len(&mut self, v: i32) { self.column_len = ::std::option::Option::Some(v); } -pub fn get_column_len(&self) -> i32 { match self.column_len { - Some(v) => v, - None => 0, - } } -pub fn has_decimal(&self) -> bool { self.decimal.is_some() } -pub fn clear_decimal(&mut self) { self.decimal = ::std::option::Option::None } -pub fn set_decimal(&mut self, v: i32) { self.decimal = ::std::option::Option::Some(v); } -pub fn get_decimal(&self) -> i32 { match self.decimal { - Some(v) => v, - None => 0, - } } -pub fn has_flag(&self) -> bool { self.flag.is_some() } -pub fn clear_flag(&mut self) { self.flag = ::std::option::Option::None } -pub fn set_flag(&mut self, v: i32) { self.flag = ::std::option::Option::Some(v); } -pub fn get_flag(&self) -> i32 { match self.flag { - Some(v) => v, - None => 0, - } } -pub fn clear_elems(&mut self) { self.elems.clear(); } -pub fn set_elems(&mut self, v: :: std :: vec :: Vec < std :: string :: String >) { self.elems = v; } -pub fn get_elems(&self) -> &:: std :: vec :: Vec < std :: string :: String > { &self.elems } -pub fn mut_elems(&mut self) -> &mut :: std :: vec :: Vec < std :: string :: String > { &mut self.elems } -pub fn take_elems(&mut self) -> :: std :: vec :: Vec < std :: string :: String > { ::std::mem::replace(&mut self.elems, ::std::vec::Vec::new()) } -pub fn has_default_val(&self) -> bool { self.default_val.is_some() } -pub fn clear_default_val(&mut self) { self.default_val = ::std::option::Option::None } -pub fn set_default_val(&mut self, v: std :: vec :: Vec < u8 >) { self.default_val = ::std::option::Option::Some(v); } -pub fn get_default_val(&self) -> &[u8] { match self.default_val.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_default_val(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.default_val.is_none() { - self.default_val = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.default_val.as_mut().unwrap() } -pub fn take_default_val(&mut self) -> std :: vec :: Vec < u8 > { self.default_val.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_pk_handle(&self) -> bool { self.pk_handle.is_some() } -pub fn clear_pk_handle(&mut self) { self.pk_handle = ::std::option::Option::None } -pub fn set_pk_handle(&mut self, v: bool) { self.pk_handle = ::std::option::Option::Some(v); } -pub fn get_pk_handle(&self) -> bool { match self.pk_handle { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for ColumnInfo {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for ColumnInfo {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static ColumnInfo { - ::lazy_static::lazy_static! { - static ref INSTANCE: ColumnInfo = ColumnInfo::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> ColumnInfo { + ::std::default::Default::default() + } + pub fn has_column_id(&self) -> bool { + self.column_id.is_some() + } + pub fn clear_column_id(&mut self) { + self.column_id = ::std::option::Option::None + } + pub fn set_column_id(&mut self, v: i64) { + self.column_id = ::std::option::Option::Some(v); + } + pub fn get_column_id(&self) -> i64 { + match self.column_id { + Some(v) => v, + None => 0, + } + } + pub fn has_tp(&self) -> bool { + self.tp.is_some() + } + pub fn clear_tp(&mut self) { + self.tp = ::std::option::Option::None + } + pub fn set_tp(&mut self, v: i32) { + self.tp = ::std::option::Option::Some(v); + } + pub fn get_tp(&self) -> i32 { + match self.tp { + Some(v) => v, + None => 0, + } + } + pub fn has_collation(&self) -> bool { + self.collation.is_some() + } + pub fn clear_collation(&mut self) { + self.collation = ::std::option::Option::None + } + pub fn set_collation(&mut self, v: i32) { + self.collation = ::std::option::Option::Some(v); + } + pub fn get_collation(&self) -> i32 { + match self.collation { + Some(v) => v, + None => 0, + } + } + pub fn has_column_len(&self) -> bool { + self.column_len.is_some() + } + pub fn clear_column_len(&mut self) { + self.column_len = ::std::option::Option::None + } + pub fn set_column_len(&mut self, v: i32) { + self.column_len = ::std::option::Option::Some(v); + } + pub fn get_column_len(&self) -> i32 { + match self.column_len { + Some(v) => v, + None => 0, + } + } + pub fn has_decimal(&self) -> bool { + self.decimal.is_some() + } + pub fn clear_decimal(&mut self) { + self.decimal = ::std::option::Option::None + } + pub fn set_decimal(&mut self, v: i32) { + self.decimal = ::std::option::Option::Some(v); + } + pub fn get_decimal(&self) -> i32 { + match self.decimal { + Some(v) => v, + None => 0, + } + } + pub fn has_flag(&self) -> bool { + self.flag.is_some() + } + pub fn clear_flag(&mut self) { + self.flag = ::std::option::Option::None + } + pub fn set_flag(&mut self, v: i32) { + self.flag = ::std::option::Option::Some(v); + } + pub fn get_flag(&self) -> i32 { + match self.flag { + Some(v) => v, + None => 0, } + } + pub fn clear_elems(&mut self) { + self.elems.clear(); + } + pub fn set_elems(&mut self, v: ::std::vec::Vec) { + self.elems = v; + } + pub fn get_elems(&self) -> &::std::vec::Vec { + &self.elems + } + pub fn mut_elems(&mut self) -> &mut ::std::vec::Vec { + &mut self.elems + } + pub fn take_elems(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.elems, ::std::vec::Vec::new()) + } + pub fn has_default_val(&self) -> bool { + self.default_val.is_some() + } + pub fn clear_default_val(&mut self) { + self.default_val = ::std::option::Option::None + } + pub fn set_default_val(&mut self, v: std::vec::Vec) { + self.default_val = ::std::option::Option::Some(v); + } + pub fn get_default_val(&self) -> &[u8] { + match self.default_val.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_default_val(&mut self) -> &mut std::vec::Vec { + if self.default_val.is_none() { + self.default_val = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.default_val.as_mut().unwrap() + } + pub fn take_default_val(&mut self) -> std::vec::Vec { + self.default_val.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_pk_handle(&self) -> bool { + self.pk_handle.is_some() + } + pub fn clear_pk_handle(&mut self) { + self.pk_handle = ::std::option::Option::None + } + pub fn set_pk_handle(&mut self, v: bool) { + self.pk_handle = ::std::option::Option::Some(v); + } + pub fn get_pk_handle(&self) -> bool { + match self.pk_handle { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for ColumnInfo { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for ColumnInfo { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static ColumnInfo { + ::lazy_static::lazy_static! { + static ref INSTANCE: ColumnInfo = ColumnInfo::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl IndexInfo { -pub fn new_() -> IndexInfo { ::std::default::Default::default() } -pub fn has_table_id(&self) -> bool { self.table_id.is_some() } -pub fn clear_table_id(&mut self) { self.table_id = ::std::option::Option::None } -pub fn set_table_id(&mut self, v: i64) { self.table_id = ::std::option::Option::Some(v); } -pub fn get_table_id(&self) -> i64 { match self.table_id { - Some(v) => v, - None => 0, - } } -pub fn has_index_id(&self) -> bool { self.index_id.is_some() } -pub fn clear_index_id(&mut self) { self.index_id = ::std::option::Option::None } -pub fn set_index_id(&mut self, v: i64) { self.index_id = ::std::option::Option::Some(v); } -pub fn get_index_id(&self) -> i64 { match self.index_id { - Some(v) => v, - None => 0, - } } -pub fn clear_columns(&mut self) { self.columns.clear(); } -pub fn set_columns(&mut self, v: :: std :: vec :: Vec < ColumnInfo >) { self.columns = v; } -pub fn get_columns(&self) -> &:: std :: vec :: Vec < ColumnInfo > { &self.columns } -pub fn mut_columns(&mut self) -> &mut :: std :: vec :: Vec < ColumnInfo > { &mut self.columns } -pub fn take_columns(&mut self) -> :: std :: vec :: Vec < ColumnInfo > { ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) } -pub fn has_unique(&self) -> bool { self.unique.is_some() } -pub fn clear_unique(&mut self) { self.unique = ::std::option::Option::None } -pub fn set_unique(&mut self, v: bool) { self.unique = ::std::option::Option::Some(v); } -pub fn get_unique(&self) -> bool { match self.unique { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for IndexInfo {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for IndexInfo {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static IndexInfo { - ::lazy_static::lazy_static! { - static ref INSTANCE: IndexInfo = IndexInfo::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> IndexInfo { + ::std::default::Default::default() + } + pub fn has_table_id(&self) -> bool { + self.table_id.is_some() + } + pub fn clear_table_id(&mut self) { + self.table_id = ::std::option::Option::None + } + pub fn set_table_id(&mut self, v: i64) { + self.table_id = ::std::option::Option::Some(v); + } + pub fn get_table_id(&self) -> i64 { + match self.table_id { + Some(v) => v, + None => 0, + } + } + pub fn has_index_id(&self) -> bool { + self.index_id.is_some() + } + pub fn clear_index_id(&mut self) { + self.index_id = ::std::option::Option::None + } + pub fn set_index_id(&mut self, v: i64) { + self.index_id = ::std::option::Option::Some(v); + } + pub fn get_index_id(&self) -> i64 { + match self.index_id { + Some(v) => v, + None => 0, } + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + pub fn set_columns(&mut self, v: ::std::vec::Vec) { + self.columns = v; + } + pub fn get_columns(&self) -> &::std::vec::Vec { + &self.columns + } + pub fn mut_columns(&mut self) -> &mut ::std::vec::Vec { + &mut self.columns + } + pub fn take_columns(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) + } + pub fn has_unique(&self) -> bool { + self.unique.is_some() + } + pub fn clear_unique(&mut self) { + self.unique = ::std::option::Option::None + } + pub fn set_unique(&mut self, v: bool) { + self.unique = ::std::option::Option::Some(v); + } + pub fn get_unique(&self) -> bool { + match self.unique { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for IndexInfo { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for IndexInfo { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static IndexInfo { + ::lazy_static::lazy_static! { + static ref INSTANCE: IndexInfo = IndexInfo::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl KeyRange { -pub fn new_() -> KeyRange { ::std::default::Default::default() } -pub fn has_low(&self) -> bool { self.low.is_some() } -pub fn clear_low(&mut self) { self.low = ::std::option::Option::None } -pub fn set_low(&mut self, v: std :: vec :: Vec < u8 >) { self.low = ::std::option::Option::Some(v); } -pub fn get_low(&self) -> &[u8] { match self.low.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_low(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.low.is_none() { - self.low = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.low.as_mut().unwrap() } -pub fn take_low(&mut self) -> std :: vec :: Vec < u8 > { self.low.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_high(&self) -> bool { self.high.is_some() } -pub fn clear_high(&mut self) { self.high = ::std::option::Option::None } -pub fn set_high(&mut self, v: std :: vec :: Vec < u8 >) { self.high = ::std::option::Option::Some(v); } -pub fn get_high(&self) -> &[u8] { match self.high.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_high(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.high.is_none() { - self.high = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.high.as_mut().unwrap() } -pub fn take_high(&mut self) -> std :: vec :: Vec < u8 > { self.high.take().unwrap_or_else(::std::vec::Vec::new) } -} -impl ::protobuf::Clear for KeyRange {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for KeyRange {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static KeyRange { - ::lazy_static::lazy_static! { - static ref INSTANCE: KeyRange = KeyRange::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> KeyRange { + ::std::default::Default::default() + } + pub fn has_low(&self) -> bool { + self.low.is_some() + } + pub fn clear_low(&mut self) { + self.low = ::std::option::Option::None + } + pub fn set_low(&mut self, v: std::vec::Vec) { + self.low = ::std::option::Option::Some(v); + } + pub fn get_low(&self) -> &[u8] { + match self.low.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_low(&mut self) -> &mut std::vec::Vec { + if self.low.is_none() { + self.low = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.low.as_mut().unwrap() + } + pub fn take_low(&mut self) -> std::vec::Vec { + self.low.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_high(&self) -> bool { + self.high.is_some() + } + pub fn clear_high(&mut self) { + self.high = ::std::option::Option::None + } + pub fn set_high(&mut self, v: std::vec::Vec) { + self.high = ::std::option::Option::Some(v); + } + pub fn get_high(&self) -> &[u8] { + match self.high.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_high(&mut self) -> &mut std::vec::Vec { + if self.high.is_none() { + self.high = ::std::option::Option::Some(::std::vec::Vec::default()); } + self.high.as_mut().unwrap() + } + pub fn take_high(&mut self) -> std::vec::Vec { + self.high.take().unwrap_or_else(::std::vec::Vec::new) + } +} +impl ::protobuf::Clear for KeyRange { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for KeyRange { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static KeyRange { + ::lazy_static::lazy_static! { + static ref INSTANCE: KeyRange = KeyRange::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl AnalyzeReq { -pub fn new_() -> AnalyzeReq { ::std::default::Default::default() } -pub fn has_tp(&self) -> bool { self.tp.is_some() } -pub fn clear_tp(&mut self) { self.tp = ::std::option::Option::None } -pub fn set_tp_(&mut self, v: AnalyzeType) { self.tp = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_tp(&self) -> AnalyzeType { unsafe { ::std::mem::transmute::(match self.tp { - Some(v) => v, - None => 0, - }) } } -pub fn has_start_ts(&self) -> bool { self.start_ts.is_some() } -pub fn clear_start_ts(&mut self) { self.start_ts = ::std::option::Option::None } -pub fn set_start_ts(&mut self, v: u64) { self.start_ts = ::std::option::Option::Some(v); } -pub fn get_start_ts(&self) -> u64 { match self.start_ts { - Some(v) => v, - None => 0, - } } -pub fn has_flags(&self) -> bool { self.flags.is_some() } -pub fn clear_flags(&mut self) { self.flags = ::std::option::Option::None } -pub fn set_flags(&mut self, v: u64) { self.flags = ::std::option::Option::Some(v); } -pub fn get_flags(&self) -> u64 { match self.flags { - Some(v) => v, - None => 0, - } } -pub fn has_time_zone_offset(&self) -> bool { self.time_zone_offset.is_some() } -pub fn clear_time_zone_offset(&mut self) { self.time_zone_offset = ::std::option::Option::None } -pub fn set_time_zone_offset(&mut self, v: i64) { self.time_zone_offset = ::std::option::Option::Some(v); } -pub fn get_time_zone_offset(&self) -> i64 { match self.time_zone_offset { - Some(v) => v, - None => 0, - } } -pub fn has_idx_req(&self) -> bool { self.idx_req.is_some() } -pub fn clear_idx_req(&mut self) { self.idx_req = ::std::option::Option::None } -pub fn set_idx_req(&mut self, v: AnalyzeIndexReq) { self.idx_req = ::std::option::Option::Some(v); } -pub fn get_idx_req(&self) -> &AnalyzeIndexReq { match self.idx_req.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_idx_req(&mut self) -> &mut AnalyzeIndexReq { if self.idx_req.is_none() { - self.idx_req = ::std::option::Option::Some(AnalyzeIndexReq::default()); - } - self.idx_req.as_mut().unwrap() } -pub fn take_idx_req(&mut self) -> AnalyzeIndexReq { self.idx_req.take().unwrap_or_else(AnalyzeIndexReq::default) } -pub fn has_col_req(&self) -> bool { self.col_req.is_some() } -pub fn clear_col_req(&mut self) { self.col_req = ::std::option::Option::None } -pub fn set_col_req(&mut self, v: AnalyzeColumnsReq) { self.col_req = ::std::option::Option::Some(v); } -pub fn get_col_req(&self) -> &AnalyzeColumnsReq { match self.col_req.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_col_req(&mut self) -> &mut AnalyzeColumnsReq { if self.col_req.is_none() { - self.col_req = ::std::option::Option::Some(AnalyzeColumnsReq::default()); - } - self.col_req.as_mut().unwrap() } -pub fn take_col_req(&mut self) -> AnalyzeColumnsReq { self.col_req.take().unwrap_or_else(AnalyzeColumnsReq::default) } -} -impl ::protobuf::Clear for AnalyzeReq {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for AnalyzeReq {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static AnalyzeReq { - ::lazy_static::lazy_static! { - static ref INSTANCE: AnalyzeReq = AnalyzeReq::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> AnalyzeReq { + ::std::default::Default::default() + } + pub fn has_tp(&self) -> bool { + self.tp.is_some() + } + pub fn clear_tp(&mut self) { + self.tp = ::std::option::Option::None + } + pub fn set_tp_(&mut self, v: AnalyzeType) { + self.tp = + ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_tp(&self) -> AnalyzeType { + unsafe { + ::std::mem::transmute::(match self.tp { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_start_ts(&self) -> bool { + self.start_ts.is_some() + } + pub fn clear_start_ts(&mut self) { + self.start_ts = ::std::option::Option::None + } + pub fn set_start_ts(&mut self, v: u64) { + self.start_ts = ::std::option::Option::Some(v); + } + pub fn get_start_ts(&self) -> u64 { + match self.start_ts { + Some(v) => v, + None => 0, + } + } + pub fn has_flags(&self) -> bool { + self.flags.is_some() + } + pub fn clear_flags(&mut self) { + self.flags = ::std::option::Option::None + } + pub fn set_flags(&mut self, v: u64) { + self.flags = ::std::option::Option::Some(v); + } + pub fn get_flags(&self) -> u64 { + match self.flags { + Some(v) => v, + None => 0, + } + } + pub fn has_time_zone_offset(&self) -> bool { + self.time_zone_offset.is_some() + } + pub fn clear_time_zone_offset(&mut self) { + self.time_zone_offset = ::std::option::Option::None + } + pub fn set_time_zone_offset(&mut self, v: i64) { + self.time_zone_offset = ::std::option::Option::Some(v); + } + pub fn get_time_zone_offset(&self) -> i64 { + match self.time_zone_offset { + Some(v) => v, + None => 0, + } + } + pub fn has_idx_req(&self) -> bool { + self.idx_req.is_some() + } + pub fn clear_idx_req(&mut self) { + self.idx_req = ::std::option::Option::None + } + pub fn set_idx_req(&mut self, v: AnalyzeIndexReq) { + self.idx_req = ::std::option::Option::Some(v); + } + pub fn get_idx_req(&self) -> &AnalyzeIndexReq { + match self.idx_req.as_ref() { + Some(v) => v, + None => ::default_instance(), } + } + pub fn mut_idx_req(&mut self) -> &mut AnalyzeIndexReq { + if self.idx_req.is_none() { + self.idx_req = ::std::option::Option::Some(AnalyzeIndexReq::default()); + } + self.idx_req.as_mut().unwrap() + } + pub fn take_idx_req(&mut self) -> AnalyzeIndexReq { + self.idx_req.take().unwrap_or_else(AnalyzeIndexReq::default) + } + pub fn has_col_req(&self) -> bool { + self.col_req.is_some() + } + pub fn clear_col_req(&mut self) { + self.col_req = ::std::option::Option::None + } + pub fn set_col_req(&mut self, v: AnalyzeColumnsReq) { + self.col_req = ::std::option::Option::Some(v); + } + pub fn get_col_req(&self) -> &AnalyzeColumnsReq { + match self.col_req.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_col_req(&mut self) -> &mut AnalyzeColumnsReq { + if self.col_req.is_none() { + self.col_req = ::std::option::Option::Some(AnalyzeColumnsReq::default()); + } + self.col_req.as_mut().unwrap() + } + pub fn take_col_req(&mut self) -> AnalyzeColumnsReq { + self.col_req + .take() + .unwrap_or_else(AnalyzeColumnsReq::default) + } +} +impl ::protobuf::Clear for AnalyzeReq { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for AnalyzeReq { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static AnalyzeReq { + ::lazy_static::lazy_static! { + static ref INSTANCE: AnalyzeReq = AnalyzeReq::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl AnalyzeIndexReq { -pub fn new_() -> AnalyzeIndexReq { ::std::default::Default::default() } -pub fn has_bucket_size(&self) -> bool { self.bucket_size.is_some() } -pub fn clear_bucket_size(&mut self) { self.bucket_size = ::std::option::Option::None } -pub fn set_bucket_size(&mut self, v: i64) { self.bucket_size = ::std::option::Option::Some(v); } -pub fn get_bucket_size(&self) -> i64 { match self.bucket_size { - Some(v) => v, - None => 0, - } } -pub fn has_num_columns(&self) -> bool { self.num_columns.is_some() } -pub fn clear_num_columns(&mut self) { self.num_columns = ::std::option::Option::None } -pub fn set_num_columns(&mut self, v: i32) { self.num_columns = ::std::option::Option::Some(v); } -pub fn get_num_columns(&self) -> i32 { match self.num_columns { - Some(v) => v, - None => 0, - } } -pub fn has_cmsketch_depth(&self) -> bool { self.cmsketch_depth.is_some() } -pub fn clear_cmsketch_depth(&mut self) { self.cmsketch_depth = ::std::option::Option::None } -pub fn set_cmsketch_depth(&mut self, v: i32) { self.cmsketch_depth = ::std::option::Option::Some(v); } -pub fn get_cmsketch_depth(&self) -> i32 { match self.cmsketch_depth { - Some(v) => v, - None => 0, - } } -pub fn has_cmsketch_width(&self) -> bool { self.cmsketch_width.is_some() } -pub fn clear_cmsketch_width(&mut self) { self.cmsketch_width = ::std::option::Option::None } -pub fn set_cmsketch_width(&mut self, v: i32) { self.cmsketch_width = ::std::option::Option::Some(v); } -pub fn get_cmsketch_width(&self) -> i32 { match self.cmsketch_width { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for AnalyzeIndexReq {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for AnalyzeIndexReq {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static AnalyzeIndexReq { - ::lazy_static::lazy_static! { - static ref INSTANCE: AnalyzeIndexReq = AnalyzeIndexReq::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> AnalyzeIndexReq { + ::std::default::Default::default() + } + pub fn has_bucket_size(&self) -> bool { + self.bucket_size.is_some() + } + pub fn clear_bucket_size(&mut self) { + self.bucket_size = ::std::option::Option::None + } + pub fn set_bucket_size(&mut self, v: i64) { + self.bucket_size = ::std::option::Option::Some(v); + } + pub fn get_bucket_size(&self) -> i64 { + match self.bucket_size { + Some(v) => v, + None => 0, + } + } + pub fn has_num_columns(&self) -> bool { + self.num_columns.is_some() + } + pub fn clear_num_columns(&mut self) { + self.num_columns = ::std::option::Option::None + } + pub fn set_num_columns(&mut self, v: i32) { + self.num_columns = ::std::option::Option::Some(v); + } + pub fn get_num_columns(&self) -> i32 { + match self.num_columns { + Some(v) => v, + None => 0, + } + } + pub fn has_cmsketch_depth(&self) -> bool { + self.cmsketch_depth.is_some() + } + pub fn clear_cmsketch_depth(&mut self) { + self.cmsketch_depth = ::std::option::Option::None + } + pub fn set_cmsketch_depth(&mut self, v: i32) { + self.cmsketch_depth = ::std::option::Option::Some(v); + } + pub fn get_cmsketch_depth(&self) -> i32 { + match self.cmsketch_depth { + Some(v) => v, + None => 0, } + } + pub fn has_cmsketch_width(&self) -> bool { + self.cmsketch_width.is_some() + } + pub fn clear_cmsketch_width(&mut self) { + self.cmsketch_width = ::std::option::Option::None + } + pub fn set_cmsketch_width(&mut self, v: i32) { + self.cmsketch_width = ::std::option::Option::Some(v); + } + pub fn get_cmsketch_width(&self) -> i32 { + match self.cmsketch_width { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for AnalyzeIndexReq { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for AnalyzeIndexReq { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static AnalyzeIndexReq { + ::lazy_static::lazy_static! { + static ref INSTANCE: AnalyzeIndexReq = AnalyzeIndexReq::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl AnalyzeColumnsReq { -pub fn new_() -> AnalyzeColumnsReq { ::std::default::Default::default() } -pub fn has_bucket_size(&self) -> bool { self.bucket_size.is_some() } -pub fn clear_bucket_size(&mut self) { self.bucket_size = ::std::option::Option::None } -pub fn set_bucket_size(&mut self, v: i64) { self.bucket_size = ::std::option::Option::Some(v); } -pub fn get_bucket_size(&self) -> i64 { match self.bucket_size { - Some(v) => v, - None => 0, - } } -pub fn has_sample_size(&self) -> bool { self.sample_size.is_some() } -pub fn clear_sample_size(&mut self) { self.sample_size = ::std::option::Option::None } -pub fn set_sample_size(&mut self, v: i64) { self.sample_size = ::std::option::Option::Some(v); } -pub fn get_sample_size(&self) -> i64 { match self.sample_size { - Some(v) => v, - None => 0, - } } -pub fn has_sketch_size(&self) -> bool { self.sketch_size.is_some() } -pub fn clear_sketch_size(&mut self) { self.sketch_size = ::std::option::Option::None } -pub fn set_sketch_size(&mut self, v: i64) { self.sketch_size = ::std::option::Option::Some(v); } -pub fn get_sketch_size(&self) -> i64 { match self.sketch_size { - Some(v) => v, - None => 0, - } } -pub fn clear_columns_info(&mut self) { self.columns_info.clear(); } -pub fn set_columns_info(&mut self, v: :: std :: vec :: Vec < ColumnInfo >) { self.columns_info = v; } -pub fn get_columns_info(&self) -> &:: std :: vec :: Vec < ColumnInfo > { &self.columns_info } -pub fn mut_columns_info(&mut self) -> &mut :: std :: vec :: Vec < ColumnInfo > { &mut self.columns_info } -pub fn take_columns_info(&mut self) -> :: std :: vec :: Vec < ColumnInfo > { ::std::mem::replace(&mut self.columns_info, ::std::vec::Vec::new()) } -pub fn has_cmsketch_depth(&self) -> bool { self.cmsketch_depth.is_some() } -pub fn clear_cmsketch_depth(&mut self) { self.cmsketch_depth = ::std::option::Option::None } -pub fn set_cmsketch_depth(&mut self, v: i32) { self.cmsketch_depth = ::std::option::Option::Some(v); } -pub fn get_cmsketch_depth(&self) -> i32 { match self.cmsketch_depth { - Some(v) => v, - None => 0, - } } -pub fn has_cmsketch_width(&self) -> bool { self.cmsketch_width.is_some() } -pub fn clear_cmsketch_width(&mut self) { self.cmsketch_width = ::std::option::Option::None } -pub fn set_cmsketch_width(&mut self, v: i32) { self.cmsketch_width = ::std::option::Option::Some(v); } -pub fn get_cmsketch_width(&self) -> i32 { match self.cmsketch_width { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for AnalyzeColumnsReq {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for AnalyzeColumnsReq {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static AnalyzeColumnsReq { - ::lazy_static::lazy_static! { - static ref INSTANCE: AnalyzeColumnsReq = AnalyzeColumnsReq::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> AnalyzeColumnsReq { + ::std::default::Default::default() + } + pub fn has_bucket_size(&self) -> bool { + self.bucket_size.is_some() + } + pub fn clear_bucket_size(&mut self) { + self.bucket_size = ::std::option::Option::None + } + pub fn set_bucket_size(&mut self, v: i64) { + self.bucket_size = ::std::option::Option::Some(v); + } + pub fn get_bucket_size(&self) -> i64 { + match self.bucket_size { + Some(v) => v, + None => 0, + } + } + pub fn has_sample_size(&self) -> bool { + self.sample_size.is_some() + } + pub fn clear_sample_size(&mut self) { + self.sample_size = ::std::option::Option::None + } + pub fn set_sample_size(&mut self, v: i64) { + self.sample_size = ::std::option::Option::Some(v); + } + pub fn get_sample_size(&self) -> i64 { + match self.sample_size { + Some(v) => v, + None => 0, + } + } + pub fn has_sketch_size(&self) -> bool { + self.sketch_size.is_some() + } + pub fn clear_sketch_size(&mut self) { + self.sketch_size = ::std::option::Option::None + } + pub fn set_sketch_size(&mut self, v: i64) { + self.sketch_size = ::std::option::Option::Some(v); + } + pub fn get_sketch_size(&self) -> i64 { + match self.sketch_size { + Some(v) => v, + None => 0, + } + } + pub fn clear_columns_info(&mut self) { + self.columns_info.clear(); + } + pub fn set_columns_info(&mut self, v: ::std::vec::Vec) { + self.columns_info = v; + } + pub fn get_columns_info(&self) -> &::std::vec::Vec { + &self.columns_info + } + pub fn mut_columns_info(&mut self) -> &mut ::std::vec::Vec { + &mut self.columns_info + } + pub fn take_columns_info(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.columns_info, ::std::vec::Vec::new()) + } + pub fn has_cmsketch_depth(&self) -> bool { + self.cmsketch_depth.is_some() + } + pub fn clear_cmsketch_depth(&mut self) { + self.cmsketch_depth = ::std::option::Option::None + } + pub fn set_cmsketch_depth(&mut self, v: i32) { + self.cmsketch_depth = ::std::option::Option::Some(v); + } + pub fn get_cmsketch_depth(&self) -> i32 { + match self.cmsketch_depth { + Some(v) => v, + None => 0, } + } + pub fn has_cmsketch_width(&self) -> bool { + self.cmsketch_width.is_some() + } + pub fn clear_cmsketch_width(&mut self) { + self.cmsketch_width = ::std::option::Option::None + } + pub fn set_cmsketch_width(&mut self, v: i32) { + self.cmsketch_width = ::std::option::Option::Some(v); + } + pub fn get_cmsketch_width(&self) -> i32 { + match self.cmsketch_width { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for AnalyzeColumnsReq { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for AnalyzeColumnsReq { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static AnalyzeColumnsReq { + ::lazy_static::lazy_static! { + static ref INSTANCE: AnalyzeColumnsReq = AnalyzeColumnsReq::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl AnalyzeColumnsResp { -pub fn new_() -> AnalyzeColumnsResp { ::std::default::Default::default() } -pub fn clear_collectors(&mut self) { self.collectors.clear(); } -pub fn set_collectors(&mut self, v: :: std :: vec :: Vec < SampleCollector >) { self.collectors = v; } -pub fn get_collectors(&self) -> &:: std :: vec :: Vec < SampleCollector > { &self.collectors } -pub fn mut_collectors(&mut self) -> &mut :: std :: vec :: Vec < SampleCollector > { &mut self.collectors } -pub fn take_collectors(&mut self) -> :: std :: vec :: Vec < SampleCollector > { ::std::mem::replace(&mut self.collectors, ::std::vec::Vec::new()) } -pub fn has_pk_hist(&self) -> bool { self.pk_hist.is_some() } -pub fn clear_pk_hist(&mut self) { self.pk_hist = ::std::option::Option::None } -pub fn set_pk_hist(&mut self, v: Histogram) { self.pk_hist = ::std::option::Option::Some(v); } -pub fn get_pk_hist(&self) -> &Histogram { match self.pk_hist.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_pk_hist(&mut self) -> &mut Histogram { if self.pk_hist.is_none() { - self.pk_hist = ::std::option::Option::Some(Histogram::default()); - } - self.pk_hist.as_mut().unwrap() } -pub fn take_pk_hist(&mut self) -> Histogram { self.pk_hist.take().unwrap_or_else(Histogram::default) } -} -impl ::protobuf::Clear for AnalyzeColumnsResp {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for AnalyzeColumnsResp {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static AnalyzeColumnsResp { - ::lazy_static::lazy_static! { - static ref INSTANCE: AnalyzeColumnsResp = AnalyzeColumnsResp::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> AnalyzeColumnsResp { + ::std::default::Default::default() + } + pub fn clear_collectors(&mut self) { + self.collectors.clear(); + } + pub fn set_collectors(&mut self, v: ::std::vec::Vec) { + self.collectors = v; + } + pub fn get_collectors(&self) -> &::std::vec::Vec { + &self.collectors + } + pub fn mut_collectors(&mut self) -> &mut ::std::vec::Vec { + &mut self.collectors + } + pub fn take_collectors(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.collectors, ::std::vec::Vec::new()) + } + pub fn has_pk_hist(&self) -> bool { + self.pk_hist.is_some() + } + pub fn clear_pk_hist(&mut self) { + self.pk_hist = ::std::option::Option::None + } + pub fn set_pk_hist(&mut self, v: Histogram) { + self.pk_hist = ::std::option::Option::Some(v); + } + pub fn get_pk_hist(&self) -> &Histogram { + match self.pk_hist.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_pk_hist(&mut self) -> &mut Histogram { + if self.pk_hist.is_none() { + self.pk_hist = ::std::option::Option::Some(Histogram::default()); + } + self.pk_hist.as_mut().unwrap() + } + pub fn take_pk_hist(&mut self) -> Histogram { + self.pk_hist.take().unwrap_or_else(Histogram::default) + } +} +impl ::protobuf::Clear for AnalyzeColumnsResp { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for AnalyzeColumnsResp { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static AnalyzeColumnsResp { + ::lazy_static::lazy_static! { + static ref INSTANCE: AnalyzeColumnsResp = AnalyzeColumnsResp::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl AnalyzeIndexResp { -pub fn new_() -> AnalyzeIndexResp { ::std::default::Default::default() } -pub fn has_hist(&self) -> bool { self.hist.is_some() } -pub fn clear_hist(&mut self) { self.hist = ::std::option::Option::None } -pub fn set_hist(&mut self, v: Histogram) { self.hist = ::std::option::Option::Some(v); } -pub fn get_hist(&self) -> &Histogram { match self.hist.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_hist(&mut self) -> &mut Histogram { if self.hist.is_none() { - self.hist = ::std::option::Option::Some(Histogram::default()); - } - self.hist.as_mut().unwrap() } -pub fn take_hist(&mut self) -> Histogram { self.hist.take().unwrap_or_else(Histogram::default) } -pub fn has_cms(&self) -> bool { self.cms.is_some() } -pub fn clear_cms(&mut self) { self.cms = ::std::option::Option::None } -pub fn set_cms(&mut self, v: CmSketch) { self.cms = ::std::option::Option::Some(v); } -pub fn get_cms(&self) -> &CmSketch { match self.cms.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_cms(&mut self) -> &mut CmSketch { if self.cms.is_none() { - self.cms = ::std::option::Option::Some(CmSketch::default()); - } - self.cms.as_mut().unwrap() } -pub fn take_cms(&mut self) -> CmSketch { self.cms.take().unwrap_or_else(CmSketch::default) } -} -impl ::protobuf::Clear for AnalyzeIndexResp {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for AnalyzeIndexResp {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static AnalyzeIndexResp { - ::lazy_static::lazy_static! { - static ref INSTANCE: AnalyzeIndexResp = AnalyzeIndexResp::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> AnalyzeIndexResp { + ::std::default::Default::default() + } + pub fn has_hist(&self) -> bool { + self.hist.is_some() + } + pub fn clear_hist(&mut self) { + self.hist = ::std::option::Option::None + } + pub fn set_hist(&mut self, v: Histogram) { + self.hist = ::std::option::Option::Some(v); + } + pub fn get_hist(&self) -> &Histogram { + match self.hist.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_hist(&mut self) -> &mut Histogram { + if self.hist.is_none() { + self.hist = ::std::option::Option::Some(Histogram::default()); + } + self.hist.as_mut().unwrap() + } + pub fn take_hist(&mut self) -> Histogram { + self.hist.take().unwrap_or_else(Histogram::default) + } + pub fn has_cms(&self) -> bool { + self.cms.is_some() + } + pub fn clear_cms(&mut self) { + self.cms = ::std::option::Option::None + } + pub fn set_cms(&mut self, v: CmSketch) { + self.cms = ::std::option::Option::Some(v); + } + pub fn get_cms(&self) -> &CmSketch { + match self.cms.as_ref() { + Some(v) => v, + None => ::default_instance(), } + } + pub fn mut_cms(&mut self) -> &mut CmSketch { + if self.cms.is_none() { + self.cms = ::std::option::Option::Some(CmSketch::default()); + } + self.cms.as_mut().unwrap() + } + pub fn take_cms(&mut self) -> CmSketch { + self.cms.take().unwrap_or_else(CmSketch::default) + } +} +impl ::protobuf::Clear for AnalyzeIndexResp { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for AnalyzeIndexResp { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static AnalyzeIndexResp { + ::lazy_static::lazy_static! { + static ref INSTANCE: AnalyzeIndexResp = AnalyzeIndexResp::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Bucket { -pub fn new_() -> Bucket { ::std::default::Default::default() } -pub fn has_count(&self) -> bool { self.count.is_some() } -pub fn clear_count(&mut self) { self.count = ::std::option::Option::None } -pub fn set_count(&mut self, v: i64) { self.count = ::std::option::Option::Some(v); } -pub fn get_count(&self) -> i64 { match self.count { - Some(v) => v, - None => 0, - } } -pub fn has_lower_bound(&self) -> bool { self.lower_bound.is_some() } -pub fn clear_lower_bound(&mut self) { self.lower_bound = ::std::option::Option::None } -pub fn set_lower_bound(&mut self, v: std :: vec :: Vec < u8 >) { self.lower_bound = ::std::option::Option::Some(v); } -pub fn get_lower_bound(&self) -> &[u8] { match self.lower_bound.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_lower_bound(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.lower_bound.is_none() { - self.lower_bound = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.lower_bound.as_mut().unwrap() } -pub fn take_lower_bound(&mut self) -> std :: vec :: Vec < u8 > { self.lower_bound.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_upper_bound(&self) -> bool { self.upper_bound.is_some() } -pub fn clear_upper_bound(&mut self) { self.upper_bound = ::std::option::Option::None } -pub fn set_upper_bound(&mut self, v: std :: vec :: Vec < u8 >) { self.upper_bound = ::std::option::Option::Some(v); } -pub fn get_upper_bound(&self) -> &[u8] { match self.upper_bound.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_upper_bound(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.upper_bound.is_none() { - self.upper_bound = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.upper_bound.as_mut().unwrap() } -pub fn take_upper_bound(&mut self) -> std :: vec :: Vec < u8 > { self.upper_bound.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_repeats(&self) -> bool { self.repeats.is_some() } -pub fn clear_repeats(&mut self) { self.repeats = ::std::option::Option::None } -pub fn set_repeats(&mut self, v: i64) { self.repeats = ::std::option::Option::Some(v); } -pub fn get_repeats(&self) -> i64 { match self.repeats { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for Bucket {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Bucket {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Bucket { - ::lazy_static::lazy_static! { - static ref INSTANCE: Bucket = Bucket::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Bucket { + ::std::default::Default::default() + } + pub fn has_count(&self) -> bool { + self.count.is_some() + } + pub fn clear_count(&mut self) { + self.count = ::std::option::Option::None + } + pub fn set_count(&mut self, v: i64) { + self.count = ::std::option::Option::Some(v); + } + pub fn get_count(&self) -> i64 { + match self.count { + Some(v) => v, + None => 0, + } + } + pub fn has_lower_bound(&self) -> bool { + self.lower_bound.is_some() + } + pub fn clear_lower_bound(&mut self) { + self.lower_bound = ::std::option::Option::None + } + pub fn set_lower_bound(&mut self, v: std::vec::Vec) { + self.lower_bound = ::std::option::Option::Some(v); + } + pub fn get_lower_bound(&self) -> &[u8] { + match self.lower_bound.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_lower_bound(&mut self) -> &mut std::vec::Vec { + if self.lower_bound.is_none() { + self.lower_bound = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.lower_bound.as_mut().unwrap() + } + pub fn take_lower_bound(&mut self) -> std::vec::Vec { + self.lower_bound.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_upper_bound(&self) -> bool { + self.upper_bound.is_some() + } + pub fn clear_upper_bound(&mut self) { + self.upper_bound = ::std::option::Option::None + } + pub fn set_upper_bound(&mut self, v: std::vec::Vec) { + self.upper_bound = ::std::option::Option::Some(v); + } + pub fn get_upper_bound(&self) -> &[u8] { + match self.upper_bound.as_ref() { + Some(v) => v, + None => &[], } + } + pub fn mut_upper_bound(&mut self) -> &mut std::vec::Vec { + if self.upper_bound.is_none() { + self.upper_bound = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.upper_bound.as_mut().unwrap() + } + pub fn take_upper_bound(&mut self) -> std::vec::Vec { + self.upper_bound.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_repeats(&self) -> bool { + self.repeats.is_some() + } + pub fn clear_repeats(&mut self) { + self.repeats = ::std::option::Option::None + } + pub fn set_repeats(&mut self, v: i64) { + self.repeats = ::std::option::Option::Some(v); + } + pub fn get_repeats(&self) -> i64 { + match self.repeats { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for Bucket { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Bucket { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Bucket { + ::lazy_static::lazy_static! { + static ref INSTANCE: Bucket = Bucket::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Histogram { -pub fn new_() -> Histogram { ::std::default::Default::default() } -pub fn has_ndv(&self) -> bool { self.ndv.is_some() } -pub fn clear_ndv(&mut self) { self.ndv = ::std::option::Option::None } -pub fn set_ndv(&mut self, v: i64) { self.ndv = ::std::option::Option::Some(v); } -pub fn get_ndv(&self) -> i64 { match self.ndv { - Some(v) => v, - None => 0, - } } -pub fn clear_buckets(&mut self) { self.buckets.clear(); } -pub fn set_buckets(&mut self, v: :: std :: vec :: Vec < Bucket >) { self.buckets = v; } -pub fn get_buckets(&self) -> &:: std :: vec :: Vec < Bucket > { &self.buckets } -pub fn mut_buckets(&mut self) -> &mut :: std :: vec :: Vec < Bucket > { &mut self.buckets } -pub fn take_buckets(&mut self) -> :: std :: vec :: Vec < Bucket > { ::std::mem::replace(&mut self.buckets, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for Histogram {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Histogram {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Histogram { - ::lazy_static::lazy_static! { - static ref INSTANCE: Histogram = Histogram::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Histogram { + ::std::default::Default::default() + } + pub fn has_ndv(&self) -> bool { + self.ndv.is_some() + } + pub fn clear_ndv(&mut self) { + self.ndv = ::std::option::Option::None + } + pub fn set_ndv(&mut self, v: i64) { + self.ndv = ::std::option::Option::Some(v); + } + pub fn get_ndv(&self) -> i64 { + match self.ndv { + Some(v) => v, + None => 0, } + } + pub fn clear_buckets(&mut self) { + self.buckets.clear(); + } + pub fn set_buckets(&mut self, v: ::std::vec::Vec) { + self.buckets = v; + } + pub fn get_buckets(&self) -> &::std::vec::Vec { + &self.buckets + } + pub fn mut_buckets(&mut self) -> &mut ::std::vec::Vec { + &mut self.buckets + } + pub fn take_buckets(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.buckets, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for Histogram { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Histogram { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Histogram { + ::lazy_static::lazy_static! { + static ref INSTANCE: Histogram = Histogram::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl FmSketch { -pub fn new_() -> FmSketch { ::std::default::Default::default() } -pub fn has_mask(&self) -> bool { self.mask.is_some() } -pub fn clear_mask(&mut self) { self.mask = ::std::option::Option::None } -pub fn set_mask(&mut self, v: u64) { self.mask = ::std::option::Option::Some(v); } -pub fn get_mask(&self) -> u64 { match self.mask { - Some(v) => v, - None => 0, - } } -pub fn clear_hashset(&mut self) { self.hashset.clear(); } -pub fn set_hashset(&mut self, v: :: std :: vec :: Vec < u64 >) { self.hashset = v; } -pub fn get_hashset(&self) -> &:: std :: vec :: Vec < u64 > { &self.hashset } -pub fn mut_hashset(&mut self) -> &mut :: std :: vec :: Vec < u64 > { &mut self.hashset } -pub fn take_hashset(&mut self) -> :: std :: vec :: Vec < u64 > { ::std::mem::replace(&mut self.hashset, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for FmSketch {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for FmSketch {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static FmSketch { - ::lazy_static::lazy_static! { - static ref INSTANCE: FmSketch = FmSketch::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> FmSketch { + ::std::default::Default::default() + } + pub fn has_mask(&self) -> bool { + self.mask.is_some() + } + pub fn clear_mask(&mut self) { + self.mask = ::std::option::Option::None + } + pub fn set_mask(&mut self, v: u64) { + self.mask = ::std::option::Option::Some(v); + } + pub fn get_mask(&self) -> u64 { + match self.mask { + Some(v) => v, + None => 0, } + } + pub fn clear_hashset(&mut self) { + self.hashset.clear(); + } + pub fn set_hashset(&mut self, v: ::std::vec::Vec) { + self.hashset = v; + } + pub fn get_hashset(&self) -> &::std::vec::Vec { + &self.hashset + } + pub fn mut_hashset(&mut self) -> &mut ::std::vec::Vec { + &mut self.hashset + } + pub fn take_hashset(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.hashset, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for FmSketch { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for FmSketch { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static FmSketch { + ::lazy_static::lazy_static! { + static ref INSTANCE: FmSketch = FmSketch::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl SampleCollector { -pub fn new_() -> SampleCollector { ::std::default::Default::default() } -pub fn clear_samples(&mut self) { self.samples.clear(); } -pub fn set_samples(&mut self, v: :: std :: vec :: Vec < std :: vec :: Vec < u8 > >) { self.samples = v; } -pub fn get_samples(&self) -> &:: std :: vec :: Vec < std :: vec :: Vec < u8 > > { &self.samples } -pub fn mut_samples(&mut self) -> &mut :: std :: vec :: Vec < std :: vec :: Vec < u8 > > { &mut self.samples } -pub fn take_samples(&mut self) -> :: std :: vec :: Vec < std :: vec :: Vec < u8 > > { ::std::mem::replace(&mut self.samples, ::std::vec::Vec::new()) } -pub fn has_null_count(&self) -> bool { self.null_count.is_some() } -pub fn clear_null_count(&mut self) { self.null_count = ::std::option::Option::None } -pub fn set_null_count(&mut self, v: i64) { self.null_count = ::std::option::Option::Some(v); } -pub fn get_null_count(&self) -> i64 { match self.null_count { - Some(v) => v, - None => 0, - } } -pub fn has_count(&self) -> bool { self.count.is_some() } -pub fn clear_count(&mut self) { self.count = ::std::option::Option::None } -pub fn set_count(&mut self, v: i64) { self.count = ::std::option::Option::Some(v); } -pub fn get_count(&self) -> i64 { match self.count { - Some(v) => v, - None => 0, - } } -pub fn has_fm_sketch(&self) -> bool { self.fm_sketch.is_some() } -pub fn clear_fm_sketch(&mut self) { self.fm_sketch = ::std::option::Option::None } -pub fn set_fm_sketch(&mut self, v: FmSketch) { self.fm_sketch = ::std::option::Option::Some(v); } -pub fn get_fm_sketch(&self) -> &FmSketch { match self.fm_sketch.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_fm_sketch(&mut self) -> &mut FmSketch { if self.fm_sketch.is_none() { - self.fm_sketch = ::std::option::Option::Some(FmSketch::default()); - } - self.fm_sketch.as_mut().unwrap() } -pub fn take_fm_sketch(&mut self) -> FmSketch { self.fm_sketch.take().unwrap_or_else(FmSketch::default) } -pub fn has_cm_sketch(&self) -> bool { self.cm_sketch.is_some() } -pub fn clear_cm_sketch(&mut self) { self.cm_sketch = ::std::option::Option::None } -pub fn set_cm_sketch(&mut self, v: CmSketch) { self.cm_sketch = ::std::option::Option::Some(v); } -pub fn get_cm_sketch(&self) -> &CmSketch { match self.cm_sketch.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_cm_sketch(&mut self) -> &mut CmSketch { if self.cm_sketch.is_none() { - self.cm_sketch = ::std::option::Option::Some(CmSketch::default()); - } - self.cm_sketch.as_mut().unwrap() } -pub fn take_cm_sketch(&mut self) -> CmSketch { self.cm_sketch.take().unwrap_or_else(CmSketch::default) } -pub fn has_total_size(&self) -> bool { self.total_size.is_some() } -pub fn clear_total_size(&mut self) { self.total_size = ::std::option::Option::None } -pub fn set_total_size(&mut self, v: i64) { self.total_size = ::std::option::Option::Some(v); } -pub fn get_total_size(&self) -> i64 { match self.total_size { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for SampleCollector {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for SampleCollector {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static SampleCollector { - ::lazy_static::lazy_static! { - static ref INSTANCE: SampleCollector = SampleCollector::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> SampleCollector { + ::std::default::Default::default() + } + pub fn clear_samples(&mut self) { + self.samples.clear(); + } + pub fn set_samples(&mut self, v: ::std::vec::Vec>) { + self.samples = v; + } + pub fn get_samples(&self) -> &::std::vec::Vec> { + &self.samples + } + pub fn mut_samples(&mut self) -> &mut ::std::vec::Vec> { + &mut self.samples + } + pub fn take_samples(&mut self) -> ::std::vec::Vec> { + ::std::mem::replace(&mut self.samples, ::std::vec::Vec::new()) + } + pub fn has_null_count(&self) -> bool { + self.null_count.is_some() + } + pub fn clear_null_count(&mut self) { + self.null_count = ::std::option::Option::None + } + pub fn set_null_count(&mut self, v: i64) { + self.null_count = ::std::option::Option::Some(v); + } + pub fn get_null_count(&self) -> i64 { + match self.null_count { + Some(v) => v, + None => 0, + } + } + pub fn has_count(&self) -> bool { + self.count.is_some() + } + pub fn clear_count(&mut self) { + self.count = ::std::option::Option::None + } + pub fn set_count(&mut self, v: i64) { + self.count = ::std::option::Option::Some(v); + } + pub fn get_count(&self) -> i64 { + match self.count { + Some(v) => v, + None => 0, + } + } + pub fn has_fm_sketch(&self) -> bool { + self.fm_sketch.is_some() + } + pub fn clear_fm_sketch(&mut self) { + self.fm_sketch = ::std::option::Option::None + } + pub fn set_fm_sketch(&mut self, v: FmSketch) { + self.fm_sketch = ::std::option::Option::Some(v); + } + pub fn get_fm_sketch(&self) -> &FmSketch { + match self.fm_sketch.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_fm_sketch(&mut self) -> &mut FmSketch { + if self.fm_sketch.is_none() { + self.fm_sketch = ::std::option::Option::Some(FmSketch::default()); + } + self.fm_sketch.as_mut().unwrap() + } + pub fn take_fm_sketch(&mut self) -> FmSketch { + self.fm_sketch.take().unwrap_or_else(FmSketch::default) + } + pub fn has_cm_sketch(&self) -> bool { + self.cm_sketch.is_some() + } + pub fn clear_cm_sketch(&mut self) { + self.cm_sketch = ::std::option::Option::None + } + pub fn set_cm_sketch(&mut self, v: CmSketch) { + self.cm_sketch = ::std::option::Option::Some(v); + } + pub fn get_cm_sketch(&self) -> &CmSketch { + match self.cm_sketch.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_cm_sketch(&mut self) -> &mut CmSketch { + if self.cm_sketch.is_none() { + self.cm_sketch = ::std::option::Option::Some(CmSketch::default()); + } + self.cm_sketch.as_mut().unwrap() + } + pub fn take_cm_sketch(&mut self) -> CmSketch { + self.cm_sketch.take().unwrap_or_else(CmSketch::default) + } + pub fn has_total_size(&self) -> bool { + self.total_size.is_some() + } + pub fn clear_total_size(&mut self) { + self.total_size = ::std::option::Option::None + } + pub fn set_total_size(&mut self, v: i64) { + self.total_size = ::std::option::Option::Some(v); + } + pub fn get_total_size(&self) -> i64 { + match self.total_size { + Some(v) => v, + None => 0, } + } +} +impl ::protobuf::Clear for SampleCollector { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for SampleCollector { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static SampleCollector { + ::lazy_static::lazy_static! { + static ref INSTANCE: SampleCollector = SampleCollector::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl CmSketchRow { -pub fn new_() -> CmSketchRow { ::std::default::Default::default() } -pub fn clear_counters(&mut self) { self.counters.clear(); } -pub fn set_counters(&mut self, v: :: std :: vec :: Vec < u32 >) { self.counters = v; } -pub fn get_counters(&self) -> &:: std :: vec :: Vec < u32 > { &self.counters } -pub fn mut_counters(&mut self) -> &mut :: std :: vec :: Vec < u32 > { &mut self.counters } -pub fn take_counters(&mut self) -> :: std :: vec :: Vec < u32 > { ::std::mem::replace(&mut self.counters, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for CmSketchRow {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for CmSketchRow {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static CmSketchRow { - ::lazy_static::lazy_static! { - static ref INSTANCE: CmSketchRow = CmSketchRow::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> CmSketchRow { + ::std::default::Default::default() + } + pub fn clear_counters(&mut self) { + self.counters.clear(); + } + pub fn set_counters(&mut self, v: ::std::vec::Vec) { + self.counters = v; + } + pub fn get_counters(&self) -> &::std::vec::Vec { + &self.counters + } + pub fn mut_counters(&mut self) -> &mut ::std::vec::Vec { + &mut self.counters + } + pub fn take_counters(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.counters, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for CmSketchRow { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for CmSketchRow { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static CmSketchRow { + ::lazy_static::lazy_static! { + static ref INSTANCE: CmSketchRow = CmSketchRow::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl CmSketchTopN { -pub fn new_() -> CmSketchTopN { ::std::default::Default::default() } -pub fn has_data(&self) -> bool { self.data.is_some() } -pub fn clear_data(&mut self) { self.data = ::std::option::Option::None } -pub fn set_data(&mut self, v: std :: vec :: Vec < u8 >) { self.data = ::std::option::Option::Some(v); } -pub fn get_data(&self) -> &[u8] { match self.data.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_data(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.data.is_none() { - self.data = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.data.as_mut().unwrap() } -pub fn take_data(&mut self) -> std :: vec :: Vec < u8 > { self.data.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_count(&self) -> bool { self.count.is_some() } -pub fn clear_count(&mut self) { self.count = ::std::option::Option::None } -pub fn set_count(&mut self, v: u64) { self.count = ::std::option::Option::Some(v); } -pub fn get_count(&self) -> u64 { match self.count { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for CmSketchTopN {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for CmSketchTopN {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static CmSketchTopN { - ::lazy_static::lazy_static! { - static ref INSTANCE: CmSketchTopN = CmSketchTopN::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> CmSketchTopN { + ::std::default::Default::default() + } + pub fn has_data(&self) -> bool { + self.data.is_some() + } + pub fn clear_data(&mut self) { + self.data = ::std::option::Option::None + } + pub fn set_data(&mut self, v: std::vec::Vec) { + self.data = ::std::option::Option::Some(v); + } + pub fn get_data(&self) -> &[u8] { + match self.data.as_ref() { + Some(v) => v, + None => &[], } + } + pub fn mut_data(&mut self) -> &mut std::vec::Vec { + if self.data.is_none() { + self.data = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.data.as_mut().unwrap() + } + pub fn take_data(&mut self) -> std::vec::Vec { + self.data.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_count(&self) -> bool { + self.count.is_some() + } + pub fn clear_count(&mut self) { + self.count = ::std::option::Option::None + } + pub fn set_count(&mut self, v: u64) { + self.count = ::std::option::Option::Some(v); + } + pub fn get_count(&self) -> u64 { + match self.count { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for CmSketchTopN { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for CmSketchTopN { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static CmSketchTopN { + ::lazy_static::lazy_static! { + static ref INSTANCE: CmSketchTopN = CmSketchTopN::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl CmSketch { -pub fn new_() -> CmSketch { ::std::default::Default::default() } -pub fn clear_rows(&mut self) { self.rows.clear(); } -pub fn set_rows(&mut self, v: :: std :: vec :: Vec < CmSketchRow >) { self.rows = v; } -pub fn get_rows(&self) -> &:: std :: vec :: Vec < CmSketchRow > { &self.rows } -pub fn mut_rows(&mut self) -> &mut :: std :: vec :: Vec < CmSketchRow > { &mut self.rows } -pub fn take_rows(&mut self) -> :: std :: vec :: Vec < CmSketchRow > { ::std::mem::replace(&mut self.rows, ::std::vec::Vec::new()) } -pub fn clear_top_n(&mut self) { self.top_n.clear(); } -pub fn set_top_n(&mut self, v: :: std :: vec :: Vec < CmSketchTopN >) { self.top_n = v; } -pub fn get_top_n(&self) -> &:: std :: vec :: Vec < CmSketchTopN > { &self.top_n } -pub fn mut_top_n(&mut self) -> &mut :: std :: vec :: Vec < CmSketchTopN > { &mut self.top_n } -pub fn take_top_n(&mut self) -> :: std :: vec :: Vec < CmSketchTopN > { ::std::mem::replace(&mut self.top_n, ::std::vec::Vec::new()) } -pub fn has_default_value(&self) -> bool { self.default_value.is_some() } -pub fn clear_default_value(&mut self) { self.default_value = ::std::option::Option::None } -pub fn set_default_value(&mut self, v: u64) { self.default_value = ::std::option::Option::Some(v); } -pub fn get_default_value(&self) -> u64 { match self.default_value { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for CmSketch {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for CmSketch {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static CmSketch { - ::lazy_static::lazy_static! { - static ref INSTANCE: CmSketch = CmSketch::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> CmSketch { + ::std::default::Default::default() + } + pub fn clear_rows(&mut self) { + self.rows.clear(); + } + pub fn set_rows(&mut self, v: ::std::vec::Vec) { + self.rows = v; + } + pub fn get_rows(&self) -> &::std::vec::Vec { + &self.rows + } + pub fn mut_rows(&mut self) -> &mut ::std::vec::Vec { + &mut self.rows + } + pub fn take_rows(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.rows, ::std::vec::Vec::new()) + } + pub fn clear_top_n(&mut self) { + self.top_n.clear(); + } + pub fn set_top_n(&mut self, v: ::std::vec::Vec) { + self.top_n = v; + } + pub fn get_top_n(&self) -> &::std::vec::Vec { + &self.top_n + } + pub fn mut_top_n(&mut self) -> &mut ::std::vec::Vec { + &mut self.top_n + } + pub fn take_top_n(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.top_n, ::std::vec::Vec::new()) + } + pub fn has_default_value(&self) -> bool { + self.default_value.is_some() + } + pub fn clear_default_value(&mut self) { + self.default_value = ::std::option::Option::None + } + pub fn set_default_value(&mut self, v: u64) { + self.default_value = ::std::option::Option::Some(v); + } + pub fn get_default_value(&self) -> u64 { + match self.default_value { + Some(v) => v, + None => 0, } + } } -impl AnalyzeType { -pub fn values() -> &'static [Self] { -static VALUES: &'static [AnalyzeType] = &[ -AnalyzeType::TypeIndex, -AnalyzeType::TypeColumn, -]; -VALUES +impl ::protobuf::Clear for CmSketch { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for CmSketch { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static CmSketch { + ::lazy_static::lazy_static! { + static ref INSTANCE: CmSketch = CmSketch::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } +impl AnalyzeType { + pub fn values() -> &'static [Self] { + static VALUES: &'static [AnalyzeType] = &[AnalyzeType::TypeIndex, AnalyzeType::TypeColumn]; + VALUES + } } impl ChecksumRequest { -pub fn new_() -> ChecksumRequest { ::std::default::Default::default() } -pub fn has_start_ts(&self) -> bool { self.start_ts.is_some() } -pub fn clear_start_ts(&mut self) { self.start_ts = ::std::option::Option::None } -pub fn set_start_ts(&mut self, v: u64) { self.start_ts = ::std::option::Option::Some(v); } -pub fn get_start_ts(&self) -> u64 { match self.start_ts { - Some(v) => v, - None => 0, - } } -pub fn has_scan_on(&self) -> bool { self.scan_on.is_some() } -pub fn clear_scan_on(&mut self) { self.scan_on = ::std::option::Option::None } -pub fn set_scan_on_(&mut self, v: ChecksumScanOn) { self.scan_on = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_scan_on(&self) -> ChecksumScanOn { unsafe { ::std::mem::transmute::(match self.scan_on { - Some(v) => v, - None => 0, - }) } } -pub fn has_algorithm(&self) -> bool { self.algorithm.is_some() } -pub fn clear_algorithm(&mut self) { self.algorithm = ::std::option::Option::None } -pub fn set_algorithm_(&mut self, v: ChecksumAlgorithm) { self.algorithm = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_algorithm(&self) -> ChecksumAlgorithm { unsafe { ::std::mem::transmute::(match self.algorithm { - Some(v) => v, - None => 0, - }) } } -} -impl ::protobuf::Clear for ChecksumRequest {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for ChecksumRequest {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static ChecksumRequest { - ::lazy_static::lazy_static! { - static ref INSTANCE: ChecksumRequest = ChecksumRequest::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> ChecksumRequest { + ::std::default::Default::default() + } + pub fn has_start_ts(&self) -> bool { + self.start_ts.is_some() + } + pub fn clear_start_ts(&mut self) { + self.start_ts = ::std::option::Option::None + } + pub fn set_start_ts(&mut self, v: u64) { + self.start_ts = ::std::option::Option::Some(v); + } + pub fn get_start_ts(&self) -> u64 { + match self.start_ts { + Some(v) => v, + None => 0, + } + } + pub fn has_scan_on(&self) -> bool { + self.scan_on.is_some() + } + pub fn clear_scan_on(&mut self) { + self.scan_on = ::std::option::Option::None + } + pub fn set_scan_on_(&mut self, v: ChecksumScanOn) { + self.scan_on = + ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_scan_on(&self) -> ChecksumScanOn { + unsafe { + ::std::mem::transmute::(match self.scan_on { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_algorithm(&self) -> bool { + self.algorithm.is_some() + } + pub fn clear_algorithm(&mut self) { + self.algorithm = ::std::option::Option::None + } + pub fn set_algorithm_(&mut self, v: ChecksumAlgorithm) { + self.algorithm = ::std::option::Option::Some(unsafe { + ::std::mem::transmute::(v) + }); + } + pub fn get_algorithm(&self) -> ChecksumAlgorithm { + unsafe { + ::std::mem::transmute::(match self.algorithm { + Some(v) => v, + None => 0, + }) + } + } +} +impl ::protobuf::Clear for ChecksumRequest { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for ChecksumRequest { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static ChecksumRequest { + ::lazy_static::lazy_static! { + static ref INSTANCE: ChecksumRequest = ChecksumRequest::new_(); } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl ChecksumResponse { -pub fn new_() -> ChecksumResponse { ::std::default::Default::default() } -pub fn has_checksum(&self) -> bool { self.checksum.is_some() } -pub fn clear_checksum(&mut self) { self.checksum = ::std::option::Option::None } -pub fn set_checksum(&mut self, v: u64) { self.checksum = ::std::option::Option::Some(v); } -pub fn get_checksum(&self) -> u64 { match self.checksum { - Some(v) => v, - None => 0, - } } -pub fn has_total_kvs(&self) -> bool { self.total_kvs.is_some() } -pub fn clear_total_kvs(&mut self) { self.total_kvs = ::std::option::Option::None } -pub fn set_total_kvs(&mut self, v: u64) { self.total_kvs = ::std::option::Option::Some(v); } -pub fn get_total_kvs(&self) -> u64 { match self.total_kvs { - Some(v) => v, - None => 0, - } } -pub fn has_total_bytes(&self) -> bool { self.total_bytes.is_some() } -pub fn clear_total_bytes(&mut self) { self.total_bytes = ::std::option::Option::None } -pub fn set_total_bytes(&mut self, v: u64) { self.total_bytes = ::std::option::Option::Some(v); } -pub fn get_total_bytes(&self) -> u64 { match self.total_bytes { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for ChecksumResponse {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for ChecksumResponse {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static ChecksumResponse { - ::lazy_static::lazy_static! { - static ref INSTANCE: ChecksumResponse = ChecksumResponse::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> ChecksumResponse { + ::std::default::Default::default() + } + pub fn has_checksum(&self) -> bool { + self.checksum.is_some() + } + pub fn clear_checksum(&mut self) { + self.checksum = ::std::option::Option::None + } + pub fn set_checksum(&mut self, v: u64) { + self.checksum = ::std::option::Option::Some(v); + } + pub fn get_checksum(&self) -> u64 { + match self.checksum { + Some(v) => v, + None => 0, + } + } + pub fn has_total_kvs(&self) -> bool { + self.total_kvs.is_some() + } + pub fn clear_total_kvs(&mut self) { + self.total_kvs = ::std::option::Option::None + } + pub fn set_total_kvs(&mut self, v: u64) { + self.total_kvs = ::std::option::Option::Some(v); + } + pub fn get_total_kvs(&self) -> u64 { + match self.total_kvs { + Some(v) => v, + None => 0, } + } + pub fn has_total_bytes(&self) -> bool { + self.total_bytes.is_some() + } + pub fn clear_total_bytes(&mut self) { + self.total_bytes = ::std::option::Option::None + } + pub fn set_total_bytes(&mut self, v: u64) { + self.total_bytes = ::std::option::Option::Some(v); + } + pub fn get_total_bytes(&self) -> u64 { + match self.total_bytes { + Some(v) => v, + None => 0, + } + } } -impl ChecksumScanOn { -pub fn values() -> &'static [Self] { -static VALUES: &'static [ChecksumScanOn] = &[ -ChecksumScanOn::Table, -ChecksumScanOn::Index, -]; -VALUES +impl ::protobuf::Clear for ChecksumResponse { + fn clear(&mut self) { + ::prost::Message::clear(self); + } } +impl ::protobuf::Message for ChecksumResponse { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static ChecksumResponse { + ::lazy_static::lazy_static! { + static ref INSTANCE: ChecksumResponse = ChecksumResponse::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } -impl ChecksumAlgorithm { -pub fn values() -> &'static [Self] { -static VALUES: &'static [ChecksumAlgorithm] = &[ -ChecksumAlgorithm::Crc64Xor, -]; -VALUES +impl ChecksumScanOn { + pub fn values() -> &'static [Self] { + static VALUES: &'static [ChecksumScanOn] = &[ChecksumScanOn::Table, ChecksumScanOn::Index]; + VALUES + } } +impl ChecksumAlgorithm { + pub fn values() -> &'static [Self] { + static VALUES: &'static [ChecksumAlgorithm] = &[ChecksumAlgorithm::Crc64Xor]; + VALUES + } } impl FieldType { -pub fn new_() -> FieldType { ::std::default::Default::default() } -pub fn has_tp(&self) -> bool { self.tp.is_some() } -pub fn clear_tp(&mut self) { self.tp = ::std::option::Option::None } -pub fn set_tp(&mut self, v: i32) { self.tp = ::std::option::Option::Some(v); } -pub fn get_tp(&self) -> i32 { match self.tp { - Some(v) => v, - None => 0, - } } -pub fn has_flag(&self) -> bool { self.flag.is_some() } -pub fn clear_flag(&mut self) { self.flag = ::std::option::Option::None } -pub fn set_flag(&mut self, v: u32) { self.flag = ::std::option::Option::Some(v); } -pub fn get_flag(&self) -> u32 { match self.flag { - Some(v) => v, - None => 0, - } } -pub fn has_flen(&self) -> bool { self.flen.is_some() } -pub fn clear_flen(&mut self) { self.flen = ::std::option::Option::None } -pub fn set_flen(&mut self, v: i32) { self.flen = ::std::option::Option::Some(v); } -pub fn get_flen(&self) -> i32 { match self.flen { - Some(v) => v, - None => 0, - } } -pub fn has_decimal(&self) -> bool { self.decimal.is_some() } -pub fn clear_decimal(&mut self) { self.decimal = ::std::option::Option::None } -pub fn set_decimal(&mut self, v: i32) { self.decimal = ::std::option::Option::Some(v); } -pub fn get_decimal(&self) -> i32 { match self.decimal { - Some(v) => v, - None => 0, - } } -pub fn has_collate(&self) -> bool { self.collate.is_some() } -pub fn clear_collate(&mut self) { self.collate = ::std::option::Option::None } -pub fn set_collate(&mut self, v: i32) { self.collate = ::std::option::Option::Some(v); } -pub fn get_collate(&self) -> i32 { match self.collate { - Some(v) => v, - None => 0, - } } -pub fn has_charset(&self) -> bool { self.charset.is_some() } -pub fn clear_charset(&mut self) { self.charset = ::std::option::Option::None } -pub fn set_charset(&mut self, v: std :: string :: String) { self.charset = ::std::option::Option::Some(v); } -pub fn get_charset(&self) -> &str { match self.charset.as_ref() { - Some(v) => v, - None => "", - } } -pub fn mut_charset(&mut self) -> &mut std :: string :: String { if self.charset.is_none() { - self.charset = ::std::option::Option::Some(std :: string :: String::default()); - } - self.charset.as_mut().unwrap() } -pub fn take_charset(&mut self) -> std :: string :: String { self.charset.take().unwrap_or_else(::std::string::String::new) } -} -impl ::protobuf::Clear for FieldType {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for FieldType {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static FieldType { - ::lazy_static::lazy_static! { - static ref INSTANCE: FieldType = FieldType::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> FieldType { + ::std::default::Default::default() + } + pub fn has_tp(&self) -> bool { + self.tp.is_some() + } + pub fn clear_tp(&mut self) { + self.tp = ::std::option::Option::None + } + pub fn set_tp(&mut self, v: i32) { + self.tp = ::std::option::Option::Some(v); + } + pub fn get_tp(&self) -> i32 { + match self.tp { + Some(v) => v, + None => 0, + } + } + pub fn has_flag(&self) -> bool { + self.flag.is_some() + } + pub fn clear_flag(&mut self) { + self.flag = ::std::option::Option::None + } + pub fn set_flag(&mut self, v: u32) { + self.flag = ::std::option::Option::Some(v); + } + pub fn get_flag(&self) -> u32 { + match self.flag { + Some(v) => v, + None => 0, + } + } + pub fn has_flen(&self) -> bool { + self.flen.is_some() + } + pub fn clear_flen(&mut self) { + self.flen = ::std::option::Option::None + } + pub fn set_flen(&mut self, v: i32) { + self.flen = ::std::option::Option::Some(v); + } + pub fn get_flen(&self) -> i32 { + match self.flen { + Some(v) => v, + None => 0, + } + } + pub fn has_decimal(&self) -> bool { + self.decimal.is_some() + } + pub fn clear_decimal(&mut self) { + self.decimal = ::std::option::Option::None + } + pub fn set_decimal(&mut self, v: i32) { + self.decimal = ::std::option::Option::Some(v); + } + pub fn get_decimal(&self) -> i32 { + match self.decimal { + Some(v) => v, + None => 0, + } + } + pub fn has_collate(&self) -> bool { + self.collate.is_some() + } + pub fn clear_collate(&mut self) { + self.collate = ::std::option::Option::None + } + pub fn set_collate(&mut self, v: i32) { + self.collate = ::std::option::Option::Some(v); + } + pub fn get_collate(&self) -> i32 { + match self.collate { + Some(v) => v, + None => 0, + } + } + pub fn has_charset(&self) -> bool { + self.charset.is_some() + } + pub fn clear_charset(&mut self) { + self.charset = ::std::option::Option::None + } + pub fn set_charset(&mut self, v: std::string::String) { + self.charset = ::std::option::Option::Some(v); + } + pub fn get_charset(&self) -> &str { + match self.charset.as_ref() { + Some(v) => v, + None => "", + } + } + pub fn mut_charset(&mut self) -> &mut std::string::String { + if self.charset.is_none() { + self.charset = ::std::option::Option::Some(std::string::String::default()); + } + self.charset.as_mut().unwrap() + } + pub fn take_charset(&mut self) -> std::string::String { + self.charset + .take() + .unwrap_or_else(::std::string::String::new) + } +} +impl ::protobuf::Clear for FieldType { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for FieldType { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static FieldType { + ::lazy_static::lazy_static! { + static ref INSTANCE: FieldType = FieldType::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Expr { -pub fn new_() -> Expr { ::std::default::Default::default() } -pub fn has_tp(&self) -> bool { self.tp.is_some() } -pub fn clear_tp(&mut self) { self.tp = ::std::option::Option::None } -pub fn set_tp_(&mut self, v: ExprType) { self.tp = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_tp(&self) -> ExprType { unsafe { ::std::mem::transmute::(match self.tp { - Some(v) => v, - None => 0, - }) } } -pub fn has_val(&self) -> bool { self.val.is_some() } -pub fn clear_val(&mut self) { self.val = ::std::option::Option::None } -pub fn set_val(&mut self, v: std :: vec :: Vec < u8 >) { self.val = ::std::option::Option::Some(v); } -pub fn get_val(&self) -> &[u8] { match self.val.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_val(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.val.is_none() { - self.val = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.val.as_mut().unwrap() } -pub fn take_val(&mut self) -> std :: vec :: Vec < u8 > { self.val.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn clear_children(&mut self) { self.children.clear(); } -pub fn set_children(&mut self, v: :: std :: vec :: Vec < Expr >) { self.children = v; } -pub fn get_children(&self) -> &:: std :: vec :: Vec < Expr > { &self.children } -pub fn mut_children(&mut self) -> &mut :: std :: vec :: Vec < Expr > { &mut self.children } -pub fn take_children(&mut self) -> :: std :: vec :: Vec < Expr > { ::std::mem::replace(&mut self.children, ::std::vec::Vec::new()) } -pub fn has_sig(&self) -> bool { self.sig.is_some() } -pub fn clear_sig(&mut self) { self.sig = ::std::option::Option::None } -pub fn set_sig_(&mut self, v: ScalarFuncSig) { self.sig = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_sig(&self) -> ScalarFuncSig { unsafe { ::std::mem::transmute::(match self.sig { - Some(v) => v, - None => 0, - }) } } -pub fn has_field_type(&self) -> bool { self.field_type.is_some() } -pub fn clear_field_type(&mut self) { self.field_type = ::std::option::Option::None } -pub fn set_field_type(&mut self, v: FieldType) { self.field_type = ::std::option::Option::Some(v); } -pub fn get_field_type(&self) -> &FieldType { match self.field_type.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_field_type(&mut self) -> &mut FieldType { if self.field_type.is_none() { - self.field_type = ::std::option::Option::Some(FieldType::default()); - } - self.field_type.as_mut().unwrap() } -pub fn take_field_type(&mut self) -> FieldType { self.field_type.take().unwrap_or_else(FieldType::default) } -} -impl ::protobuf::Clear for Expr {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Expr {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Expr { - ::lazy_static::lazy_static! { - static ref INSTANCE: Expr = Expr::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Expr { + ::std::default::Default::default() + } + pub fn has_tp(&self) -> bool { + self.tp.is_some() + } + pub fn clear_tp(&mut self) { + self.tp = ::std::option::Option::None + } + pub fn set_tp_(&mut self, v: ExprType) { + self.tp = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_tp(&self) -> ExprType { + unsafe { + ::std::mem::transmute::(match self.tp { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_val(&self) -> bool { + self.val.is_some() + } + pub fn clear_val(&mut self) { + self.val = ::std::option::Option::None + } + pub fn set_val(&mut self, v: std::vec::Vec) { + self.val = ::std::option::Option::Some(v); + } + pub fn get_val(&self) -> &[u8] { + match self.val.as_ref() { + Some(v) => v, + None => &[], } + } + pub fn mut_val(&mut self) -> &mut std::vec::Vec { + if self.val.is_none() { + self.val = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.val.as_mut().unwrap() + } + pub fn take_val(&mut self) -> std::vec::Vec { + self.val.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn clear_children(&mut self) { + self.children.clear(); + } + pub fn set_children(&mut self, v: ::std::vec::Vec) { + self.children = v; + } + pub fn get_children(&self) -> &::std::vec::Vec { + &self.children + } + pub fn mut_children(&mut self) -> &mut ::std::vec::Vec { + &mut self.children + } + pub fn take_children(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.children, ::std::vec::Vec::new()) + } + pub fn has_sig(&self) -> bool { + self.sig.is_some() + } + pub fn clear_sig(&mut self) { + self.sig = ::std::option::Option::None + } + pub fn set_sig_(&mut self, v: ScalarFuncSig) { + self.sig = + ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_sig(&self) -> ScalarFuncSig { + unsafe { + ::std::mem::transmute::(match self.sig { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_field_type(&self) -> bool { + self.field_type.is_some() + } + pub fn clear_field_type(&mut self) { + self.field_type = ::std::option::Option::None + } + pub fn set_field_type(&mut self, v: FieldType) { + self.field_type = ::std::option::Option::Some(v); + } + pub fn get_field_type(&self) -> &FieldType { + match self.field_type.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_field_type(&mut self) -> &mut FieldType { + if self.field_type.is_none() { + self.field_type = ::std::option::Option::Some(FieldType::default()); + } + self.field_type.as_mut().unwrap() + } + pub fn take_field_type(&mut self) -> FieldType { + self.field_type.take().unwrap_or_else(FieldType::default) + } +} +impl ::protobuf::Clear for Expr { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Expr { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Expr { + ::lazy_static::lazy_static! { + static ref INSTANCE: Expr = Expr::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl ByItem { -pub fn new_() -> ByItem { ::std::default::Default::default() } -pub fn has_expr(&self) -> bool { self.expr.is_some() } -pub fn clear_expr(&mut self) { self.expr = ::std::option::Option::None } -pub fn set_expr(&mut self, v: Expr) { self.expr = ::std::option::Option::Some(v); } -pub fn get_expr(&self) -> &Expr { match self.expr.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_expr(&mut self) -> &mut Expr { if self.expr.is_none() { - self.expr = ::std::option::Option::Some(Expr::default()); - } - self.expr.as_mut().unwrap() } -pub fn take_expr(&mut self) -> Expr { self.expr.take().unwrap_or_else(Expr::default) } -pub fn has_desc(&self) -> bool { self.desc.is_some() } -pub fn clear_desc(&mut self) { self.desc = ::std::option::Option::None } -pub fn set_desc(&mut self, v: bool) { self.desc = ::std::option::Option::Some(v); } -pub fn get_desc(&self) -> bool { match self.desc { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for ByItem {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for ByItem {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static ByItem { - ::lazy_static::lazy_static! { - static ref INSTANCE: ByItem = ByItem::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> ByItem { + ::std::default::Default::default() + } + pub fn has_expr(&self) -> bool { + self.expr.is_some() + } + pub fn clear_expr(&mut self) { + self.expr = ::std::option::Option::None + } + pub fn set_expr(&mut self, v: Expr) { + self.expr = ::std::option::Option::Some(v); + } + pub fn get_expr(&self) -> &Expr { + match self.expr.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_expr(&mut self) -> &mut Expr { + if self.expr.is_none() { + self.expr = ::std::option::Option::Some(Expr::default()); } + self.expr.as_mut().unwrap() + } + pub fn take_expr(&mut self) -> Expr { + self.expr.take().unwrap_or_else(Expr::default) + } + pub fn has_desc(&self) -> bool { + self.desc.is_some() + } + pub fn clear_desc(&mut self) { + self.desc = ::std::option::Option::None + } + pub fn set_desc(&mut self, v: bool) { + self.desc = ::std::option::Option::Some(v); + } + pub fn get_desc(&self) -> bool { + match self.desc { + Some(v) => v, + None => false, + } + } } -impl ExprType { -pub fn values() -> &'static [Self] { -static VALUES: &'static [ExprType] = &[ -ExprType::Null, -ExprType::Int64, -ExprType::Uint64, -ExprType::Float32, -ExprType::Float64, -ExprType::String, -ExprType::Bytes, -ExprType::MysqlBit, -ExprType::MysqlDecimal, -ExprType::MysqlDuration, -ExprType::MysqlEnum, -ExprType::MysqlHex, -ExprType::MysqlSet, -ExprType::MysqlTime, -ExprType::MysqlJson, -ExprType::ValueList, -ExprType::ColumnRef, -ExprType::Count, -ExprType::Sum, -ExprType::Avg, -ExprType::Min, -ExprType::Max, -ExprType::First, -ExprType::GroupConcat, -ExprType::AggBitAnd, -ExprType::AggBitOr, -ExprType::AggBitXor, -ExprType::Std, -ExprType::Stddev, -ExprType::StddevPop, -ExprType::StddevSamp, -ExprType::VarPop, -ExprType::VarSamp, -ExprType::Variance, -ExprType::JsonArrayAgg, -ExprType::JsonObjectAgg, -ExprType::ScalarFunc, -]; -VALUES +impl ::protobuf::Clear for ByItem { + fn clear(&mut self) { + ::prost::Message::clear(self); + } } +impl ::protobuf::Message for ByItem { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static ByItem { + ::lazy_static::lazy_static! { + static ref INSTANCE: ByItem = ByItem::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } -impl ScalarFuncSig { -pub fn values() -> &'static [Self] { -static VALUES: &'static [ScalarFuncSig] = &[ -ScalarFuncSig::CastIntAsInt, -ScalarFuncSig::CastIntAsReal, -ScalarFuncSig::CastIntAsString, -ScalarFuncSig::CastIntAsDecimal, -ScalarFuncSig::CastIntAsTime, -ScalarFuncSig::CastIntAsDuration, -ScalarFuncSig::CastIntAsJson, -ScalarFuncSig::CastRealAsInt, -ScalarFuncSig::CastRealAsReal, -ScalarFuncSig::CastRealAsString, -ScalarFuncSig::CastRealAsDecimal, -ScalarFuncSig::CastRealAsTime, -ScalarFuncSig::CastRealAsDuration, -ScalarFuncSig::CastRealAsJson, -ScalarFuncSig::CastDecimalAsInt, -ScalarFuncSig::CastDecimalAsReal, -ScalarFuncSig::CastDecimalAsString, -ScalarFuncSig::CastDecimalAsDecimal, -ScalarFuncSig::CastDecimalAsTime, -ScalarFuncSig::CastDecimalAsDuration, -ScalarFuncSig::CastDecimalAsJson, -ScalarFuncSig::CastStringAsInt, -ScalarFuncSig::CastStringAsReal, -ScalarFuncSig::CastStringAsString, -ScalarFuncSig::CastStringAsDecimal, -ScalarFuncSig::CastStringAsTime, -ScalarFuncSig::CastStringAsDuration, -ScalarFuncSig::CastStringAsJson, -ScalarFuncSig::CastTimeAsInt, -ScalarFuncSig::CastTimeAsReal, -ScalarFuncSig::CastTimeAsString, -ScalarFuncSig::CastTimeAsDecimal, -ScalarFuncSig::CastTimeAsTime, -ScalarFuncSig::CastTimeAsDuration, -ScalarFuncSig::CastTimeAsJson, -ScalarFuncSig::CastDurationAsInt, -ScalarFuncSig::CastDurationAsReal, -ScalarFuncSig::CastDurationAsString, -ScalarFuncSig::CastDurationAsDecimal, -ScalarFuncSig::CastDurationAsTime, -ScalarFuncSig::CastDurationAsDuration, -ScalarFuncSig::CastDurationAsJson, -ScalarFuncSig::CastJsonAsInt, -ScalarFuncSig::CastJsonAsReal, -ScalarFuncSig::CastJsonAsString, -ScalarFuncSig::CastJsonAsDecimal, -ScalarFuncSig::CastJsonAsTime, -ScalarFuncSig::CastJsonAsDuration, -ScalarFuncSig::CastJsonAsJson, -ScalarFuncSig::CoalesceInt, -ScalarFuncSig::CoalesceReal, -ScalarFuncSig::CoalesceDecimal, -ScalarFuncSig::CoalesceString, -ScalarFuncSig::CoalesceTime, -ScalarFuncSig::CoalesceDuration, -ScalarFuncSig::CoalesceJson, -ScalarFuncSig::LtInt, -ScalarFuncSig::LtReal, -ScalarFuncSig::LtDecimal, -ScalarFuncSig::LtString, -ScalarFuncSig::LtTime, -ScalarFuncSig::LtDuration, -ScalarFuncSig::LtJson, -ScalarFuncSig::LeInt, -ScalarFuncSig::LeReal, -ScalarFuncSig::LeDecimal, -ScalarFuncSig::LeString, -ScalarFuncSig::LeTime, -ScalarFuncSig::LeDuration, -ScalarFuncSig::LeJson, -ScalarFuncSig::GtInt, -ScalarFuncSig::GtReal, -ScalarFuncSig::GtDecimal, -ScalarFuncSig::GtString, -ScalarFuncSig::GtTime, -ScalarFuncSig::GtDuration, -ScalarFuncSig::GtJson, -ScalarFuncSig::GreatestInt, -ScalarFuncSig::GreatestReal, -ScalarFuncSig::GreatestDecimal, -ScalarFuncSig::GreatestString, -ScalarFuncSig::GreatestTime, -ScalarFuncSig::LeastInt, -ScalarFuncSig::LeastReal, -ScalarFuncSig::LeastDecimal, -ScalarFuncSig::LeastString, -ScalarFuncSig::LeastTime, -ScalarFuncSig::IntervalInt, -ScalarFuncSig::IntervalReal, -ScalarFuncSig::GeInt, -ScalarFuncSig::GeReal, -ScalarFuncSig::GeDecimal, -ScalarFuncSig::GeString, -ScalarFuncSig::GeTime, -ScalarFuncSig::GeDuration, -ScalarFuncSig::GeJson, -ScalarFuncSig::EqInt, -ScalarFuncSig::EqReal, -ScalarFuncSig::EqDecimal, -ScalarFuncSig::EqString, -ScalarFuncSig::EqTime, -ScalarFuncSig::EqDuration, -ScalarFuncSig::EqJson, -ScalarFuncSig::NeInt, -ScalarFuncSig::NeReal, -ScalarFuncSig::NeDecimal, -ScalarFuncSig::NeString, -ScalarFuncSig::NeTime, -ScalarFuncSig::NeDuration, -ScalarFuncSig::NeJson, -ScalarFuncSig::NullEqInt, -ScalarFuncSig::NullEqReal, -ScalarFuncSig::NullEqDecimal, -ScalarFuncSig::NullEqString, -ScalarFuncSig::NullEqTime, -ScalarFuncSig::NullEqDuration, -ScalarFuncSig::NullEqJson, -ScalarFuncSig::PlusReal, -ScalarFuncSig::PlusDecimal, -ScalarFuncSig::PlusInt, -ScalarFuncSig::MinusReal, -ScalarFuncSig::MinusDecimal, -ScalarFuncSig::MinusInt, -ScalarFuncSig::MultiplyReal, -ScalarFuncSig::MultiplyDecimal, -ScalarFuncSig::MultiplyInt, -ScalarFuncSig::DivideReal, -ScalarFuncSig::DivideDecimal, -ScalarFuncSig::IntDivideInt, -ScalarFuncSig::IntDivideDecimal, -ScalarFuncSig::ModReal, -ScalarFuncSig::ModDecimal, -ScalarFuncSig::ModInt, -ScalarFuncSig::MultiplyIntUnsigned, -ScalarFuncSig::AbsInt, -ScalarFuncSig::AbsUInt, -ScalarFuncSig::AbsReal, -ScalarFuncSig::AbsDecimal, -ScalarFuncSig::CeilIntToDec, -ScalarFuncSig::CeilIntToInt, -ScalarFuncSig::CeilDecToInt, -ScalarFuncSig::CeilDecToDec, -ScalarFuncSig::CeilReal, -ScalarFuncSig::FloorIntToDec, -ScalarFuncSig::FloorIntToInt, -ScalarFuncSig::FloorDecToInt, -ScalarFuncSig::FloorDecToDec, -ScalarFuncSig::FloorReal, -ScalarFuncSig::RoundReal, -ScalarFuncSig::RoundInt, -ScalarFuncSig::RoundDec, -ScalarFuncSig::RoundWithFracReal, -ScalarFuncSig::RoundWithFracInt, -ScalarFuncSig::RoundWithFracDec, -ScalarFuncSig::Log1Arg, -ScalarFuncSig::Log2Args, -ScalarFuncSig::Log2, -ScalarFuncSig::Log10, -ScalarFuncSig::Rand, -ScalarFuncSig::RandWithSeed, -ScalarFuncSig::Pow, -ScalarFuncSig::Conv, -ScalarFuncSig::Crc32, -ScalarFuncSig::Sign, -ScalarFuncSig::Sqrt, -ScalarFuncSig::Acos, -ScalarFuncSig::Asin, -ScalarFuncSig::Atan1Arg, -ScalarFuncSig::Atan2Args, -ScalarFuncSig::Cos, -ScalarFuncSig::Cot, -ScalarFuncSig::Degrees, -ScalarFuncSig::Exp, -ScalarFuncSig::Pi, -ScalarFuncSig::Radians, -ScalarFuncSig::Sin, -ScalarFuncSig::Tan, -ScalarFuncSig::TruncateInt, -ScalarFuncSig::TruncateReal, -ScalarFuncSig::TruncateDecimal, -ScalarFuncSig::LogicalAnd, -ScalarFuncSig::LogicalOr, -ScalarFuncSig::LogicalXor, -ScalarFuncSig::UnaryNot, -ScalarFuncSig::UnaryMinusInt, -ScalarFuncSig::UnaryMinusReal, -ScalarFuncSig::UnaryMinusDecimal, -ScalarFuncSig::DecimalIsNull, -ScalarFuncSig::DurationIsNull, -ScalarFuncSig::RealIsNull, -ScalarFuncSig::StringIsNull, -ScalarFuncSig::TimeIsNull, -ScalarFuncSig::IntIsNull, -ScalarFuncSig::JsonIsNull, -ScalarFuncSig::BitAndSig, -ScalarFuncSig::BitOrSig, -ScalarFuncSig::BitXorSig, -ScalarFuncSig::BitNegSig, -ScalarFuncSig::IntIsTrue, -ScalarFuncSig::RealIsTrue, -ScalarFuncSig::DecimalIsTrue, -ScalarFuncSig::IntIsFalse, -ScalarFuncSig::RealIsFalse, -ScalarFuncSig::DecimalIsFalse, -ScalarFuncSig::LeftShift, -ScalarFuncSig::RightShift, -ScalarFuncSig::BitCount, -ScalarFuncSig::GetParamString, -ScalarFuncSig::GetVar, -ScalarFuncSig::RowSig, -ScalarFuncSig::SetVar, -ScalarFuncSig::ValuesDecimal, -ScalarFuncSig::ValuesDuration, -ScalarFuncSig::ValuesInt, -ScalarFuncSig::ValuesJson, -ScalarFuncSig::ValuesReal, -ScalarFuncSig::ValuesString, -ScalarFuncSig::ValuesTime, -ScalarFuncSig::InInt, -ScalarFuncSig::InReal, -ScalarFuncSig::InDecimal, -ScalarFuncSig::InString, -ScalarFuncSig::InTime, -ScalarFuncSig::InDuration, -ScalarFuncSig::InJson, -ScalarFuncSig::IfNullInt, -ScalarFuncSig::IfNullReal, -ScalarFuncSig::IfNullDecimal, -ScalarFuncSig::IfNullString, -ScalarFuncSig::IfNullTime, -ScalarFuncSig::IfNullDuration, -ScalarFuncSig::IfInt, -ScalarFuncSig::IfReal, -ScalarFuncSig::IfDecimal, -ScalarFuncSig::IfString, -ScalarFuncSig::IfTime, -ScalarFuncSig::IfDuration, -ScalarFuncSig::IfNullJson, -ScalarFuncSig::IfJson, -ScalarFuncSig::CaseWhenInt, -ScalarFuncSig::CaseWhenReal, -ScalarFuncSig::CaseWhenDecimal, -ScalarFuncSig::CaseWhenString, -ScalarFuncSig::CaseWhenTime, -ScalarFuncSig::CaseWhenDuration, -ScalarFuncSig::CaseWhenJson, -ScalarFuncSig::AesDecrypt, -ScalarFuncSig::AesEncrypt, -ScalarFuncSig::Compress, -ScalarFuncSig::Md5, -ScalarFuncSig::Password, -ScalarFuncSig::RandomBytes, -ScalarFuncSig::Sha1, -ScalarFuncSig::Sha2, -ScalarFuncSig::Uncompress, -ScalarFuncSig::UncompressedLength, -ScalarFuncSig::Database, -ScalarFuncSig::FoundRows, -ScalarFuncSig::CurrentUser, -ScalarFuncSig::User, -ScalarFuncSig::ConnectionId, -ScalarFuncSig::LastInsertId, -ScalarFuncSig::LastInsertIdWithId, -ScalarFuncSig::Version, -ScalarFuncSig::TiDbVersion, -ScalarFuncSig::RowCount, -ScalarFuncSig::Sleep, -ScalarFuncSig::Lock, -ScalarFuncSig::ReleaseLock, -ScalarFuncSig::DecimalAnyValue, -ScalarFuncSig::DurationAnyValue, -ScalarFuncSig::IntAnyValue, -ScalarFuncSig::JsonAnyValue, -ScalarFuncSig::RealAnyValue, -ScalarFuncSig::StringAnyValue, -ScalarFuncSig::TimeAnyValue, -ScalarFuncSig::InetAton, -ScalarFuncSig::InetNtoa, -ScalarFuncSig::Inet6Aton, -ScalarFuncSig::Inet6Ntoa, -ScalarFuncSig::IsIPv4, -ScalarFuncSig::IsIPv4Compat, -ScalarFuncSig::IsIPv4Mapped, -ScalarFuncSig::IsIPv6, -ScalarFuncSig::Uuid, -ScalarFuncSig::LikeSig, -ScalarFuncSig::RegexpBinarySig, -ScalarFuncSig::RegexpSig, -ScalarFuncSig::JsonExtractSig, -ScalarFuncSig::JsonUnquoteSig, -ScalarFuncSig::JsonTypeSig, -ScalarFuncSig::JsonSetSig, -ScalarFuncSig::JsonInsertSig, -ScalarFuncSig::JsonReplaceSig, -ScalarFuncSig::JsonRemoveSig, -ScalarFuncSig::JsonMergeSig, -ScalarFuncSig::JsonObjectSig, -ScalarFuncSig::JsonArraySig, -ScalarFuncSig::JsonValidJsonSig, -ScalarFuncSig::JsonContainsSig, -ScalarFuncSig::JsonArrayAppendSig, -ScalarFuncSig::JsonArrayInsertSig, -ScalarFuncSig::JsonMergePatchSig, -ScalarFuncSig::JsonMergePreserveSig, -ScalarFuncSig::JsonContainsPathSig, -ScalarFuncSig::JsonPrettySig, -ScalarFuncSig::JsonQuoteSig, -ScalarFuncSig::JsonSearchSig, -ScalarFuncSig::JsonStorageSizeSig, -ScalarFuncSig::JsonDepthSig, -ScalarFuncSig::JsonKeysSig, -ScalarFuncSig::JsonLengthSig, -ScalarFuncSig::JsonKeys2ArgsSig, -ScalarFuncSig::JsonValidStringSig, -ScalarFuncSig::DateFormatSig, -ScalarFuncSig::DateLiteral, -ScalarFuncSig::DateDiff, -ScalarFuncSig::NullTimeDiff, -ScalarFuncSig::TimeStringTimeDiff, -ScalarFuncSig::DurationStringTimeDiff, -ScalarFuncSig::DurationDurationTimeDiff, -ScalarFuncSig::StringTimeTimeDiff, -ScalarFuncSig::StringDurationTimeDiff, -ScalarFuncSig::StringStringTimeDiff, -ScalarFuncSig::TimeTimeTimeDiff, -ScalarFuncSig::Date, -ScalarFuncSig::Hour, -ScalarFuncSig::Minute, -ScalarFuncSig::Second, -ScalarFuncSig::MicroSecond, -ScalarFuncSig::Month, -ScalarFuncSig::MonthName, -ScalarFuncSig::NowWithArg, -ScalarFuncSig::NowWithoutArg, -ScalarFuncSig::DayName, -ScalarFuncSig::DayOfMonth, -ScalarFuncSig::DayOfWeek, -ScalarFuncSig::DayOfYear, -ScalarFuncSig::WeekWithMode, -ScalarFuncSig::WeekWithoutMode, -ScalarFuncSig::WeekDay, -ScalarFuncSig::WeekOfYear, -ScalarFuncSig::Year, -ScalarFuncSig::YearWeekWithMode, -ScalarFuncSig::YearWeekWithoutMode, -ScalarFuncSig::GetFormat, -ScalarFuncSig::SysDateWithFsp, -ScalarFuncSig::SysDateWithoutFsp, -ScalarFuncSig::CurrentDate, -ScalarFuncSig::CurrentTime0Arg, -ScalarFuncSig::CurrentTime1Arg, -ScalarFuncSig::Time, -ScalarFuncSig::TimeLiteral, -ScalarFuncSig::UtcDate, -ScalarFuncSig::UtcTimestampWithArg, -ScalarFuncSig::UtcTimestampWithoutArg, -ScalarFuncSig::AddDatetimeAndDuration, -ScalarFuncSig::AddDatetimeAndString, -ScalarFuncSig::AddTimeDateTimeNull, -ScalarFuncSig::AddStringAndDuration, -ScalarFuncSig::AddStringAndString, -ScalarFuncSig::AddTimeStringNull, -ScalarFuncSig::AddDurationAndDuration, -ScalarFuncSig::AddDurationAndString, -ScalarFuncSig::AddTimeDurationNull, -ScalarFuncSig::AddDateAndDuration, -ScalarFuncSig::AddDateAndString, -ScalarFuncSig::SubDatetimeAndDuration, -ScalarFuncSig::SubDatetimeAndString, -ScalarFuncSig::SubTimeDateTimeNull, -ScalarFuncSig::SubStringAndDuration, -ScalarFuncSig::SubStringAndString, -ScalarFuncSig::SubTimeStringNull, -ScalarFuncSig::SubDurationAndDuration, -ScalarFuncSig::SubDurationAndString, -ScalarFuncSig::SubTimeDurationNull, -ScalarFuncSig::SubDateAndDuration, -ScalarFuncSig::SubDateAndString, -ScalarFuncSig::UnixTimestampCurrent, -ScalarFuncSig::UnixTimestampInt, -ScalarFuncSig::UnixTimestampDec, -ScalarFuncSig::ConvertTz, -ScalarFuncSig::MakeDate, -ScalarFuncSig::MakeTime, -ScalarFuncSig::PeriodAdd, -ScalarFuncSig::PeriodDiff, -ScalarFuncSig::Quarter, -ScalarFuncSig::SecToTime, -ScalarFuncSig::TimeToSec, -ScalarFuncSig::TimestampAdd, -ScalarFuncSig::ToDays, -ScalarFuncSig::ToSeconds, -ScalarFuncSig::UtcTimeWithArg, -ScalarFuncSig::UtcTimeWithoutArg, -ScalarFuncSig::Timestamp1Arg, -ScalarFuncSig::Timestamp2Args, -ScalarFuncSig::TimestampLiteral, -ScalarFuncSig::LastDay, -ScalarFuncSig::StrToDateDate, -ScalarFuncSig::StrToDateDatetime, -ScalarFuncSig::StrToDateDuration, -ScalarFuncSig::FromUnixTime1Arg, -ScalarFuncSig::FromUnixTime2Arg, -ScalarFuncSig::ExtractDatetime, -ScalarFuncSig::ExtractDuration, -ScalarFuncSig::AddDateStringString, -ScalarFuncSig::AddDateStringInt, -ScalarFuncSig::AddDateStringDecimal, -ScalarFuncSig::AddDateIntString, -ScalarFuncSig::AddDateIntInt, -ScalarFuncSig::AddDateDatetimeString, -ScalarFuncSig::AddDateDatetimeInt, -ScalarFuncSig::SubDateStringString, -ScalarFuncSig::SubDateStringInt, -ScalarFuncSig::SubDateStringDecimal, -ScalarFuncSig::SubDateIntString, -ScalarFuncSig::SubDateIntInt, -ScalarFuncSig::SubDateDatetimeString, -ScalarFuncSig::SubDateDatetimeInt, -ScalarFuncSig::FromDays, -ScalarFuncSig::TimeFormat, -ScalarFuncSig::TimestampDiff, -ScalarFuncSig::BitLength, -ScalarFuncSig::Bin, -ScalarFuncSig::Ascii, -ScalarFuncSig::Char, -ScalarFuncSig::CharLength, -ScalarFuncSig::Concat, -ScalarFuncSig::ConcatWs, -ScalarFuncSig::Convert, -ScalarFuncSig::Elt, -ScalarFuncSig::ExportSet3Arg, -ScalarFuncSig::ExportSet4Arg, -ScalarFuncSig::ExportSet5Arg, -ScalarFuncSig::FieldInt, -ScalarFuncSig::FieldReal, -ScalarFuncSig::FieldString, -ScalarFuncSig::FindInSet, -ScalarFuncSig::Format, -ScalarFuncSig::FormatWithLocale, -ScalarFuncSig::FromBase64, -ScalarFuncSig::HexIntArg, -ScalarFuncSig::HexStrArg, -ScalarFuncSig::Insert, -ScalarFuncSig::InsertBinary, -ScalarFuncSig::Instr, -ScalarFuncSig::InstrBinary, -ScalarFuncSig::LTrim, -ScalarFuncSig::Left, -ScalarFuncSig::LeftBinary, -ScalarFuncSig::Length, -ScalarFuncSig::Locate2Args, -ScalarFuncSig::Locate3Args, -ScalarFuncSig::LocateBinary2Args, -ScalarFuncSig::LocateBinary3Args, -ScalarFuncSig::Lower, -ScalarFuncSig::Lpad, -ScalarFuncSig::LpadBinary, -ScalarFuncSig::MakeSet, -ScalarFuncSig::OctInt, -ScalarFuncSig::OctString, -ScalarFuncSig::Ord, -ScalarFuncSig::Quote, -ScalarFuncSig::RTrim, -ScalarFuncSig::Repeat, -ScalarFuncSig::Replace, -ScalarFuncSig::Reverse, -ScalarFuncSig::ReverseBinary, -ScalarFuncSig::Right, -ScalarFuncSig::RightBinary, -ScalarFuncSig::Rpad, -ScalarFuncSig::RpadBinary, -ScalarFuncSig::Space, -ScalarFuncSig::Strcmp, -ScalarFuncSig::Substring2Args, -ScalarFuncSig::Substring3Args, -ScalarFuncSig::SubstringBinary2Args, -ScalarFuncSig::SubstringBinary3Args, -ScalarFuncSig::SubstringIndex, -ScalarFuncSig::ToBase64, -ScalarFuncSig::Trim1Arg, -ScalarFuncSig::Trim2Args, -ScalarFuncSig::Trim3Args, -ScalarFuncSig::UnHex, -ScalarFuncSig::Upper, -]; -VALUES +impl ExprType { + pub fn values() -> &'static [Self] { + static VALUES: &'static [ExprType] = &[ + ExprType::Null, + ExprType::Int64, + ExprType::Uint64, + ExprType::Float32, + ExprType::Float64, + ExprType::String, + ExprType::Bytes, + ExprType::MysqlBit, + ExprType::MysqlDecimal, + ExprType::MysqlDuration, + ExprType::MysqlEnum, + ExprType::MysqlHex, + ExprType::MysqlSet, + ExprType::MysqlTime, + ExprType::MysqlJson, + ExprType::ValueList, + ExprType::ColumnRef, + ExprType::Count, + ExprType::Sum, + ExprType::Avg, + ExprType::Min, + ExprType::Max, + ExprType::First, + ExprType::GroupConcat, + ExprType::AggBitAnd, + ExprType::AggBitOr, + ExprType::AggBitXor, + ExprType::Std, + ExprType::Stddev, + ExprType::StddevPop, + ExprType::StddevSamp, + ExprType::VarPop, + ExprType::VarSamp, + ExprType::Variance, + ExprType::JsonArrayAgg, + ExprType::JsonObjectAgg, + ExprType::ScalarFunc, + ]; + VALUES + } } +impl ScalarFuncSig { + pub fn values() -> &'static [Self] { + static VALUES: &'static [ScalarFuncSig] = &[ + ScalarFuncSig::CastIntAsInt, + ScalarFuncSig::CastIntAsReal, + ScalarFuncSig::CastIntAsString, + ScalarFuncSig::CastIntAsDecimal, + ScalarFuncSig::CastIntAsTime, + ScalarFuncSig::CastIntAsDuration, + ScalarFuncSig::CastIntAsJson, + ScalarFuncSig::CastRealAsInt, + ScalarFuncSig::CastRealAsReal, + ScalarFuncSig::CastRealAsString, + ScalarFuncSig::CastRealAsDecimal, + ScalarFuncSig::CastRealAsTime, + ScalarFuncSig::CastRealAsDuration, + ScalarFuncSig::CastRealAsJson, + ScalarFuncSig::CastDecimalAsInt, + ScalarFuncSig::CastDecimalAsReal, + ScalarFuncSig::CastDecimalAsString, + ScalarFuncSig::CastDecimalAsDecimal, + ScalarFuncSig::CastDecimalAsTime, + ScalarFuncSig::CastDecimalAsDuration, + ScalarFuncSig::CastDecimalAsJson, + ScalarFuncSig::CastStringAsInt, + ScalarFuncSig::CastStringAsReal, + ScalarFuncSig::CastStringAsString, + ScalarFuncSig::CastStringAsDecimal, + ScalarFuncSig::CastStringAsTime, + ScalarFuncSig::CastStringAsDuration, + ScalarFuncSig::CastStringAsJson, + ScalarFuncSig::CastTimeAsInt, + ScalarFuncSig::CastTimeAsReal, + ScalarFuncSig::CastTimeAsString, + ScalarFuncSig::CastTimeAsDecimal, + ScalarFuncSig::CastTimeAsTime, + ScalarFuncSig::CastTimeAsDuration, + ScalarFuncSig::CastTimeAsJson, + ScalarFuncSig::CastDurationAsInt, + ScalarFuncSig::CastDurationAsReal, + ScalarFuncSig::CastDurationAsString, + ScalarFuncSig::CastDurationAsDecimal, + ScalarFuncSig::CastDurationAsTime, + ScalarFuncSig::CastDurationAsDuration, + ScalarFuncSig::CastDurationAsJson, + ScalarFuncSig::CastJsonAsInt, + ScalarFuncSig::CastJsonAsReal, + ScalarFuncSig::CastJsonAsString, + ScalarFuncSig::CastJsonAsDecimal, + ScalarFuncSig::CastJsonAsTime, + ScalarFuncSig::CastJsonAsDuration, + ScalarFuncSig::CastJsonAsJson, + ScalarFuncSig::CoalesceInt, + ScalarFuncSig::CoalesceReal, + ScalarFuncSig::CoalesceDecimal, + ScalarFuncSig::CoalesceString, + ScalarFuncSig::CoalesceTime, + ScalarFuncSig::CoalesceDuration, + ScalarFuncSig::CoalesceJson, + ScalarFuncSig::LtInt, + ScalarFuncSig::LtReal, + ScalarFuncSig::LtDecimal, + ScalarFuncSig::LtString, + ScalarFuncSig::LtTime, + ScalarFuncSig::LtDuration, + ScalarFuncSig::LtJson, + ScalarFuncSig::LeInt, + ScalarFuncSig::LeReal, + ScalarFuncSig::LeDecimal, + ScalarFuncSig::LeString, + ScalarFuncSig::LeTime, + ScalarFuncSig::LeDuration, + ScalarFuncSig::LeJson, + ScalarFuncSig::GtInt, + ScalarFuncSig::GtReal, + ScalarFuncSig::GtDecimal, + ScalarFuncSig::GtString, + ScalarFuncSig::GtTime, + ScalarFuncSig::GtDuration, + ScalarFuncSig::GtJson, + ScalarFuncSig::GreatestInt, + ScalarFuncSig::GreatestReal, + ScalarFuncSig::GreatestDecimal, + ScalarFuncSig::GreatestString, + ScalarFuncSig::GreatestTime, + ScalarFuncSig::LeastInt, + ScalarFuncSig::LeastReal, + ScalarFuncSig::LeastDecimal, + ScalarFuncSig::LeastString, + ScalarFuncSig::LeastTime, + ScalarFuncSig::IntervalInt, + ScalarFuncSig::IntervalReal, + ScalarFuncSig::GeInt, + ScalarFuncSig::GeReal, + ScalarFuncSig::GeDecimal, + ScalarFuncSig::GeString, + ScalarFuncSig::GeTime, + ScalarFuncSig::GeDuration, + ScalarFuncSig::GeJson, + ScalarFuncSig::EqInt, + ScalarFuncSig::EqReal, + ScalarFuncSig::EqDecimal, + ScalarFuncSig::EqString, + ScalarFuncSig::EqTime, + ScalarFuncSig::EqDuration, + ScalarFuncSig::EqJson, + ScalarFuncSig::NeInt, + ScalarFuncSig::NeReal, + ScalarFuncSig::NeDecimal, + ScalarFuncSig::NeString, + ScalarFuncSig::NeTime, + ScalarFuncSig::NeDuration, + ScalarFuncSig::NeJson, + ScalarFuncSig::NullEqInt, + ScalarFuncSig::NullEqReal, + ScalarFuncSig::NullEqDecimal, + ScalarFuncSig::NullEqString, + ScalarFuncSig::NullEqTime, + ScalarFuncSig::NullEqDuration, + ScalarFuncSig::NullEqJson, + ScalarFuncSig::PlusReal, + ScalarFuncSig::PlusDecimal, + ScalarFuncSig::PlusInt, + ScalarFuncSig::MinusReal, + ScalarFuncSig::MinusDecimal, + ScalarFuncSig::MinusInt, + ScalarFuncSig::MultiplyReal, + ScalarFuncSig::MultiplyDecimal, + ScalarFuncSig::MultiplyInt, + ScalarFuncSig::DivideReal, + ScalarFuncSig::DivideDecimal, + ScalarFuncSig::IntDivideInt, + ScalarFuncSig::IntDivideDecimal, + ScalarFuncSig::ModReal, + ScalarFuncSig::ModDecimal, + ScalarFuncSig::ModInt, + ScalarFuncSig::MultiplyIntUnsigned, + ScalarFuncSig::AbsInt, + ScalarFuncSig::AbsUInt, + ScalarFuncSig::AbsReal, + ScalarFuncSig::AbsDecimal, + ScalarFuncSig::CeilIntToDec, + ScalarFuncSig::CeilIntToInt, + ScalarFuncSig::CeilDecToInt, + ScalarFuncSig::CeilDecToDec, + ScalarFuncSig::CeilReal, + ScalarFuncSig::FloorIntToDec, + ScalarFuncSig::FloorIntToInt, + ScalarFuncSig::FloorDecToInt, + ScalarFuncSig::FloorDecToDec, + ScalarFuncSig::FloorReal, + ScalarFuncSig::RoundReal, + ScalarFuncSig::RoundInt, + ScalarFuncSig::RoundDec, + ScalarFuncSig::RoundWithFracReal, + ScalarFuncSig::RoundWithFracInt, + ScalarFuncSig::RoundWithFracDec, + ScalarFuncSig::Log1Arg, + ScalarFuncSig::Log2Args, + ScalarFuncSig::Log2, + ScalarFuncSig::Log10, + ScalarFuncSig::Rand, + ScalarFuncSig::RandWithSeed, + ScalarFuncSig::Pow, + ScalarFuncSig::Conv, + ScalarFuncSig::Crc32, + ScalarFuncSig::Sign, + ScalarFuncSig::Sqrt, + ScalarFuncSig::Acos, + ScalarFuncSig::Asin, + ScalarFuncSig::Atan1Arg, + ScalarFuncSig::Atan2Args, + ScalarFuncSig::Cos, + ScalarFuncSig::Cot, + ScalarFuncSig::Degrees, + ScalarFuncSig::Exp, + ScalarFuncSig::Pi, + ScalarFuncSig::Radians, + ScalarFuncSig::Sin, + ScalarFuncSig::Tan, + ScalarFuncSig::TruncateInt, + ScalarFuncSig::TruncateReal, + ScalarFuncSig::TruncateDecimal, + ScalarFuncSig::LogicalAnd, + ScalarFuncSig::LogicalOr, + ScalarFuncSig::LogicalXor, + ScalarFuncSig::UnaryNot, + ScalarFuncSig::UnaryMinusInt, + ScalarFuncSig::UnaryMinusReal, + ScalarFuncSig::UnaryMinusDecimal, + ScalarFuncSig::DecimalIsNull, + ScalarFuncSig::DurationIsNull, + ScalarFuncSig::RealIsNull, + ScalarFuncSig::StringIsNull, + ScalarFuncSig::TimeIsNull, + ScalarFuncSig::TimeIsNullOnNotNullCol, + ScalarFuncSig::IntIsNull, + ScalarFuncSig::JsonIsNull, + ScalarFuncSig::BitAndSig, + ScalarFuncSig::BitOrSig, + ScalarFuncSig::BitXorSig, + ScalarFuncSig::BitNegSig, + ScalarFuncSig::IntIsTrue, + ScalarFuncSig::RealIsTrue, + ScalarFuncSig::DecimalIsTrue, + ScalarFuncSig::IntIsFalse, + ScalarFuncSig::RealIsFalse, + ScalarFuncSig::DecimalIsFalse, + ScalarFuncSig::LeftShift, + ScalarFuncSig::RightShift, + ScalarFuncSig::BitCount, + ScalarFuncSig::GetParamString, + ScalarFuncSig::GetVar, + ScalarFuncSig::RowSig, + ScalarFuncSig::SetVar, + ScalarFuncSig::ValuesDecimal, + ScalarFuncSig::ValuesDuration, + ScalarFuncSig::ValuesInt, + ScalarFuncSig::ValuesJson, + ScalarFuncSig::ValuesReal, + ScalarFuncSig::ValuesString, + ScalarFuncSig::ValuesTime, + ScalarFuncSig::InInt, + ScalarFuncSig::InReal, + ScalarFuncSig::InDecimal, + ScalarFuncSig::InString, + ScalarFuncSig::InTime, + ScalarFuncSig::InDuration, + ScalarFuncSig::InJson, + ScalarFuncSig::IfNullInt, + ScalarFuncSig::IfNullReal, + ScalarFuncSig::IfNullDecimal, + ScalarFuncSig::IfNullString, + ScalarFuncSig::IfNullTime, + ScalarFuncSig::IfNullDuration, + ScalarFuncSig::IfInt, + ScalarFuncSig::IfReal, + ScalarFuncSig::IfDecimal, + ScalarFuncSig::IfString, + ScalarFuncSig::IfTime, + ScalarFuncSig::IfDuration, + ScalarFuncSig::IfNullJson, + ScalarFuncSig::IfJson, + ScalarFuncSig::CaseWhenInt, + ScalarFuncSig::CaseWhenReal, + ScalarFuncSig::CaseWhenDecimal, + ScalarFuncSig::CaseWhenString, + ScalarFuncSig::CaseWhenTime, + ScalarFuncSig::CaseWhenDuration, + ScalarFuncSig::CaseWhenJson, + ScalarFuncSig::AesDecrypt, + ScalarFuncSig::AesEncrypt, + ScalarFuncSig::Compress, + ScalarFuncSig::Md5, + ScalarFuncSig::Password, + ScalarFuncSig::RandomBytes, + ScalarFuncSig::Sha1, + ScalarFuncSig::Sha2, + ScalarFuncSig::Uncompress, + ScalarFuncSig::UncompressedLength, + ScalarFuncSig::Database, + ScalarFuncSig::FoundRows, + ScalarFuncSig::CurrentUser, + ScalarFuncSig::User, + ScalarFuncSig::ConnectionId, + ScalarFuncSig::LastInsertId, + ScalarFuncSig::LastInsertIdWithId, + ScalarFuncSig::Version, + ScalarFuncSig::TiDbVersion, + ScalarFuncSig::RowCount, + ScalarFuncSig::Sleep, + ScalarFuncSig::Lock, + ScalarFuncSig::ReleaseLock, + ScalarFuncSig::DecimalAnyValue, + ScalarFuncSig::DurationAnyValue, + ScalarFuncSig::IntAnyValue, + ScalarFuncSig::JsonAnyValue, + ScalarFuncSig::RealAnyValue, + ScalarFuncSig::StringAnyValue, + ScalarFuncSig::TimeAnyValue, + ScalarFuncSig::InetAton, + ScalarFuncSig::InetNtoa, + ScalarFuncSig::Inet6Aton, + ScalarFuncSig::Inet6Ntoa, + ScalarFuncSig::IsIPv4, + ScalarFuncSig::IsIPv4Compat, + ScalarFuncSig::IsIPv4Mapped, + ScalarFuncSig::IsIPv6, + ScalarFuncSig::Uuid, + ScalarFuncSig::LikeSig, + ScalarFuncSig::RegexpBinarySig, + ScalarFuncSig::RegexpSig, + ScalarFuncSig::JsonExtractSig, + ScalarFuncSig::JsonUnquoteSig, + ScalarFuncSig::JsonTypeSig, + ScalarFuncSig::JsonSetSig, + ScalarFuncSig::JsonInsertSig, + ScalarFuncSig::JsonReplaceSig, + ScalarFuncSig::JsonRemoveSig, + ScalarFuncSig::JsonMergeSig, + ScalarFuncSig::JsonObjectSig, + ScalarFuncSig::JsonArraySig, + ScalarFuncSig::JsonValidJsonSig, + ScalarFuncSig::JsonContainsSig, + ScalarFuncSig::JsonArrayAppendSig, + ScalarFuncSig::JsonArrayInsertSig, + ScalarFuncSig::JsonMergePatchSig, + ScalarFuncSig::JsonMergePreserveSig, + ScalarFuncSig::JsonContainsPathSig, + ScalarFuncSig::JsonPrettySig, + ScalarFuncSig::JsonQuoteSig, + ScalarFuncSig::JsonSearchSig, + ScalarFuncSig::JsonStorageSizeSig, + ScalarFuncSig::JsonDepthSig, + ScalarFuncSig::JsonKeysSig, + ScalarFuncSig::JsonLengthSig, + ScalarFuncSig::JsonKeys2ArgsSig, + ScalarFuncSig::JsonValidStringSig, + ScalarFuncSig::DateFormatSig, + ScalarFuncSig::DateLiteral, + ScalarFuncSig::DateDiff, + ScalarFuncSig::NullTimeDiff, + ScalarFuncSig::TimeStringTimeDiff, + ScalarFuncSig::DurationStringTimeDiff, + ScalarFuncSig::DurationDurationTimeDiff, + ScalarFuncSig::StringTimeTimeDiff, + ScalarFuncSig::StringDurationTimeDiff, + ScalarFuncSig::StringStringTimeDiff, + ScalarFuncSig::TimeTimeTimeDiff, + ScalarFuncSig::Date, + ScalarFuncSig::Hour, + ScalarFuncSig::Minute, + ScalarFuncSig::Second, + ScalarFuncSig::MicroSecond, + ScalarFuncSig::Month, + ScalarFuncSig::MonthName, + ScalarFuncSig::NowWithArg, + ScalarFuncSig::NowWithoutArg, + ScalarFuncSig::DayName, + ScalarFuncSig::DayOfMonth, + ScalarFuncSig::DayOfWeek, + ScalarFuncSig::DayOfYear, + ScalarFuncSig::WeekWithMode, + ScalarFuncSig::WeekWithoutMode, + ScalarFuncSig::WeekDay, + ScalarFuncSig::WeekOfYear, + ScalarFuncSig::Year, + ScalarFuncSig::YearWeekWithMode, + ScalarFuncSig::YearWeekWithoutMode, + ScalarFuncSig::GetFormat, + ScalarFuncSig::SysDateWithFsp, + ScalarFuncSig::SysDateWithoutFsp, + ScalarFuncSig::CurrentDate, + ScalarFuncSig::CurrentTime0Arg, + ScalarFuncSig::CurrentTime1Arg, + ScalarFuncSig::Time, + ScalarFuncSig::TimeLiteral, + ScalarFuncSig::UtcDate, + ScalarFuncSig::UtcTimestampWithArg, + ScalarFuncSig::UtcTimestampWithoutArg, + ScalarFuncSig::AddDatetimeAndDuration, + ScalarFuncSig::AddDatetimeAndString, + ScalarFuncSig::AddTimeDateTimeNull, + ScalarFuncSig::AddStringAndDuration, + ScalarFuncSig::AddStringAndString, + ScalarFuncSig::AddTimeStringNull, + ScalarFuncSig::AddDurationAndDuration, + ScalarFuncSig::AddDurationAndString, + ScalarFuncSig::AddTimeDurationNull, + ScalarFuncSig::AddDateAndDuration, + ScalarFuncSig::AddDateAndString, + ScalarFuncSig::SubDatetimeAndDuration, + ScalarFuncSig::SubDatetimeAndString, + ScalarFuncSig::SubTimeDateTimeNull, + ScalarFuncSig::SubStringAndDuration, + ScalarFuncSig::SubStringAndString, + ScalarFuncSig::SubTimeStringNull, + ScalarFuncSig::SubDurationAndDuration, + ScalarFuncSig::SubDurationAndString, + ScalarFuncSig::SubTimeDurationNull, + ScalarFuncSig::SubDateAndDuration, + ScalarFuncSig::SubDateAndString, + ScalarFuncSig::UnixTimestampCurrent, + ScalarFuncSig::UnixTimestampInt, + ScalarFuncSig::UnixTimestampDec, + ScalarFuncSig::ConvertTz, + ScalarFuncSig::MakeDate, + ScalarFuncSig::MakeTime, + ScalarFuncSig::PeriodAdd, + ScalarFuncSig::PeriodDiff, + ScalarFuncSig::Quarter, + ScalarFuncSig::SecToTime, + ScalarFuncSig::TimeToSec, + ScalarFuncSig::TimestampAdd, + ScalarFuncSig::ToDays, + ScalarFuncSig::ToSeconds, + ScalarFuncSig::UtcTimeWithArg, + ScalarFuncSig::UtcTimeWithoutArg, + ScalarFuncSig::Timestamp1Arg, + ScalarFuncSig::Timestamp2Args, + ScalarFuncSig::TimestampLiteral, + ScalarFuncSig::LastDay, + ScalarFuncSig::StrToDateDate, + ScalarFuncSig::StrToDateDatetime, + ScalarFuncSig::StrToDateDuration, + ScalarFuncSig::FromUnixTime1Arg, + ScalarFuncSig::FromUnixTime2Arg, + ScalarFuncSig::ExtractDatetime, + ScalarFuncSig::ExtractDuration, + ScalarFuncSig::AddDateStringString, + ScalarFuncSig::AddDateStringInt, + ScalarFuncSig::AddDateStringDecimal, + ScalarFuncSig::AddDateIntString, + ScalarFuncSig::AddDateIntInt, + ScalarFuncSig::AddDateDatetimeString, + ScalarFuncSig::AddDateDatetimeInt, + ScalarFuncSig::SubDateStringString, + ScalarFuncSig::SubDateStringInt, + ScalarFuncSig::SubDateStringDecimal, + ScalarFuncSig::SubDateIntString, + ScalarFuncSig::SubDateIntInt, + ScalarFuncSig::SubDateDatetimeString, + ScalarFuncSig::SubDateDatetimeInt, + ScalarFuncSig::FromDays, + ScalarFuncSig::TimeFormat, + ScalarFuncSig::TimestampDiff, + ScalarFuncSig::BitLength, + ScalarFuncSig::Bin, + ScalarFuncSig::Ascii, + ScalarFuncSig::Char, + ScalarFuncSig::CharLength, + ScalarFuncSig::Concat, + ScalarFuncSig::ConcatWs, + ScalarFuncSig::Convert, + ScalarFuncSig::Elt, + ScalarFuncSig::ExportSet3Arg, + ScalarFuncSig::ExportSet4Arg, + ScalarFuncSig::ExportSet5Arg, + ScalarFuncSig::FieldInt, + ScalarFuncSig::FieldReal, + ScalarFuncSig::FieldString, + ScalarFuncSig::FindInSet, + ScalarFuncSig::Format, + ScalarFuncSig::FormatWithLocale, + ScalarFuncSig::FromBase64, + ScalarFuncSig::HexIntArg, + ScalarFuncSig::HexStrArg, + ScalarFuncSig::Insert, + ScalarFuncSig::InsertBinary, + ScalarFuncSig::Instr, + ScalarFuncSig::InstrBinary, + ScalarFuncSig::LTrim, + ScalarFuncSig::Left, + ScalarFuncSig::LeftBinary, + ScalarFuncSig::Length, + ScalarFuncSig::Locate2Args, + ScalarFuncSig::Locate3Args, + ScalarFuncSig::LocateBinary2Args, + ScalarFuncSig::LocateBinary3Args, + ScalarFuncSig::Lower, + ScalarFuncSig::Lpad, + ScalarFuncSig::LpadBinary, + ScalarFuncSig::MakeSet, + ScalarFuncSig::OctInt, + ScalarFuncSig::OctString, + ScalarFuncSig::Ord, + ScalarFuncSig::Quote, + ScalarFuncSig::RTrim, + ScalarFuncSig::Repeat, + ScalarFuncSig::Replace, + ScalarFuncSig::Reverse, + ScalarFuncSig::ReverseBinary, + ScalarFuncSig::Right, + ScalarFuncSig::RightBinary, + ScalarFuncSig::Rpad, + ScalarFuncSig::RpadBinary, + ScalarFuncSig::Space, + ScalarFuncSig::Strcmp, + ScalarFuncSig::Substring2Args, + ScalarFuncSig::Substring3Args, + ScalarFuncSig::SubstringBinary2Args, + ScalarFuncSig::SubstringBinary3Args, + ScalarFuncSig::SubstringIndex, + ScalarFuncSig::ToBase64, + ScalarFuncSig::Trim1Arg, + ScalarFuncSig::Trim2Args, + ScalarFuncSig::Trim3Args, + ScalarFuncSig::UnHex, + ScalarFuncSig::Upper, + ]; + VALUES + } } impl Executor { -pub fn new_() -> Executor { ::std::default::Default::default() } -pub fn has_tp(&self) -> bool { self.tp.is_some() } -pub fn clear_tp(&mut self) { self.tp = ::std::option::Option::None } -pub fn set_tp_(&mut self, v: ExecType) { self.tp = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_tp(&self) -> ExecType { unsafe { ::std::mem::transmute::(match self.tp { - Some(v) => v, - None => 0, - }) } } -pub fn has_tbl_scan(&self) -> bool { self.tbl_scan.is_some() } -pub fn clear_tbl_scan(&mut self) { self.tbl_scan = ::std::option::Option::None } -pub fn set_tbl_scan(&mut self, v: TableScan) { self.tbl_scan = ::std::option::Option::Some(v); } -pub fn get_tbl_scan(&self) -> &TableScan { match self.tbl_scan.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_tbl_scan(&mut self) -> &mut TableScan { if self.tbl_scan.is_none() { - self.tbl_scan = ::std::option::Option::Some(TableScan::default()); - } - self.tbl_scan.as_mut().unwrap() } -pub fn take_tbl_scan(&mut self) -> TableScan { self.tbl_scan.take().unwrap_or_else(TableScan::default) } -pub fn has_idx_scan(&self) -> bool { self.idx_scan.is_some() } -pub fn clear_idx_scan(&mut self) { self.idx_scan = ::std::option::Option::None } -pub fn set_idx_scan(&mut self, v: IndexScan) { self.idx_scan = ::std::option::Option::Some(v); } -pub fn get_idx_scan(&self) -> &IndexScan { match self.idx_scan.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_idx_scan(&mut self) -> &mut IndexScan { if self.idx_scan.is_none() { - self.idx_scan = ::std::option::Option::Some(IndexScan::default()); - } - self.idx_scan.as_mut().unwrap() } -pub fn take_idx_scan(&mut self) -> IndexScan { self.idx_scan.take().unwrap_or_else(IndexScan::default) } -pub fn has_selection(&self) -> bool { self.selection.is_some() } -pub fn clear_selection(&mut self) { self.selection = ::std::option::Option::None } -pub fn set_selection(&mut self, v: Selection) { self.selection = ::std::option::Option::Some(v); } -pub fn get_selection(&self) -> &Selection { match self.selection.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_selection(&mut self) -> &mut Selection { if self.selection.is_none() { - self.selection = ::std::option::Option::Some(Selection::default()); - } - self.selection.as_mut().unwrap() } -pub fn take_selection(&mut self) -> Selection { self.selection.take().unwrap_or_else(Selection::default) } -pub fn has_aggregation(&self) -> bool { self.aggregation.is_some() } -pub fn clear_aggregation(&mut self) { self.aggregation = ::std::option::Option::None } -pub fn set_aggregation(&mut self, v: Aggregation) { self.aggregation = ::std::option::Option::Some(v); } -pub fn get_aggregation(&self) -> &Aggregation { match self.aggregation.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_aggregation(&mut self) -> &mut Aggregation { if self.aggregation.is_none() { - self.aggregation = ::std::option::Option::Some(Aggregation::default()); - } - self.aggregation.as_mut().unwrap() } -pub fn take_aggregation(&mut self) -> Aggregation { self.aggregation.take().unwrap_or_else(Aggregation::default) } -pub fn has_top_n(&self) -> bool { self.top_n.is_some() } -pub fn clear_top_n(&mut self) { self.top_n = ::std::option::Option::None } -pub fn set_top_n(&mut self, v: TopN) { self.top_n = ::std::option::Option::Some(v); } -pub fn get_top_n(&self) -> &TopN { match self.top_n.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_top_n(&mut self) -> &mut TopN { if self.top_n.is_none() { - self.top_n = ::std::option::Option::Some(TopN::default()); - } - self.top_n.as_mut().unwrap() } -pub fn take_top_n(&mut self) -> TopN { self.top_n.take().unwrap_or_else(TopN::default) } -pub fn has_limit(&self) -> bool { self.limit.is_some() } -pub fn clear_limit(&mut self) { self.limit = ::std::option::Option::None } -pub fn set_limit(&mut self, v: Limit) { self.limit = ::std::option::Option::Some(v); } -pub fn get_limit(&self) -> &Limit { match self.limit.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_limit(&mut self) -> &mut Limit { if self.limit.is_none() { - self.limit = ::std::option::Option::Some(Limit::default()); - } - self.limit.as_mut().unwrap() } -pub fn take_limit(&mut self) -> Limit { self.limit.take().unwrap_or_else(Limit::default) } -pub fn has_stream_agg(&self) -> bool { self.stream_agg.is_some() } -pub fn clear_stream_agg(&mut self) { self.stream_agg = ::std::option::Option::None } -pub fn set_stream_agg(&mut self, v: Aggregation) { self.stream_agg = ::std::option::Option::Some(v); } -pub fn get_stream_agg(&self) -> &Aggregation { match self.stream_agg.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_stream_agg(&mut self) -> &mut Aggregation { if self.stream_agg.is_none() { - self.stream_agg = ::std::option::Option::Some(Aggregation::default()); - } - self.stream_agg.as_mut().unwrap() } -pub fn take_stream_agg(&mut self) -> Aggregation { self.stream_agg.take().unwrap_or_else(Aggregation::default) } -} -impl ::protobuf::Clear for Executor {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Executor {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Executor { - ::lazy_static::lazy_static! { - static ref INSTANCE: Executor = Executor::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Executor { + ::std::default::Default::default() + } + pub fn has_tp(&self) -> bool { + self.tp.is_some() + } + pub fn clear_tp(&mut self) { + self.tp = ::std::option::Option::None + } + pub fn set_tp_(&mut self, v: ExecType) { + self.tp = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_tp(&self) -> ExecType { + unsafe { + ::std::mem::transmute::(match self.tp { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_tbl_scan(&self) -> bool { + self.tbl_scan.is_some() + } + pub fn clear_tbl_scan(&mut self) { + self.tbl_scan = ::std::option::Option::None + } + pub fn set_tbl_scan(&mut self, v: TableScan) { + self.tbl_scan = ::std::option::Option::Some(v); + } + pub fn get_tbl_scan(&self) -> &TableScan { + match self.tbl_scan.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_tbl_scan(&mut self) -> &mut TableScan { + if self.tbl_scan.is_none() { + self.tbl_scan = ::std::option::Option::Some(TableScan::default()); + } + self.tbl_scan.as_mut().unwrap() + } + pub fn take_tbl_scan(&mut self) -> TableScan { + self.tbl_scan.take().unwrap_or_else(TableScan::default) + } + pub fn has_idx_scan(&self) -> bool { + self.idx_scan.is_some() + } + pub fn clear_idx_scan(&mut self) { + self.idx_scan = ::std::option::Option::None + } + pub fn set_idx_scan(&mut self, v: IndexScan) { + self.idx_scan = ::std::option::Option::Some(v); + } + pub fn get_idx_scan(&self) -> &IndexScan { + match self.idx_scan.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_idx_scan(&mut self) -> &mut IndexScan { + if self.idx_scan.is_none() { + self.idx_scan = ::std::option::Option::Some(IndexScan::default()); + } + self.idx_scan.as_mut().unwrap() + } + pub fn take_idx_scan(&mut self) -> IndexScan { + self.idx_scan.take().unwrap_or_else(IndexScan::default) + } + pub fn has_selection(&self) -> bool { + self.selection.is_some() + } + pub fn clear_selection(&mut self) { + self.selection = ::std::option::Option::None + } + pub fn set_selection(&mut self, v: Selection) { + self.selection = ::std::option::Option::Some(v); + } + pub fn get_selection(&self) -> &Selection { + match self.selection.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_selection(&mut self) -> &mut Selection { + if self.selection.is_none() { + self.selection = ::std::option::Option::Some(Selection::default()); + } + self.selection.as_mut().unwrap() + } + pub fn take_selection(&mut self) -> Selection { + self.selection.take().unwrap_or_else(Selection::default) + } + pub fn has_aggregation(&self) -> bool { + self.aggregation.is_some() + } + pub fn clear_aggregation(&mut self) { + self.aggregation = ::std::option::Option::None + } + pub fn set_aggregation(&mut self, v: Aggregation) { + self.aggregation = ::std::option::Option::Some(v); + } + pub fn get_aggregation(&self) -> &Aggregation { + match self.aggregation.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_aggregation(&mut self) -> &mut Aggregation { + if self.aggregation.is_none() { + self.aggregation = ::std::option::Option::Some(Aggregation::default()); + } + self.aggregation.as_mut().unwrap() + } + pub fn take_aggregation(&mut self) -> Aggregation { + self.aggregation.take().unwrap_or_else(Aggregation::default) + } + pub fn has_top_n(&self) -> bool { + self.top_n.is_some() + } + pub fn clear_top_n(&mut self) { + self.top_n = ::std::option::Option::None + } + pub fn set_top_n(&mut self, v: TopN) { + self.top_n = ::std::option::Option::Some(v); + } + pub fn get_top_n(&self) -> &TopN { + match self.top_n.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_top_n(&mut self) -> &mut TopN { + if self.top_n.is_none() { + self.top_n = ::std::option::Option::Some(TopN::default()); + } + self.top_n.as_mut().unwrap() + } + pub fn take_top_n(&mut self) -> TopN { + self.top_n.take().unwrap_or_else(TopN::default) + } + pub fn has_limit(&self) -> bool { + self.limit.is_some() + } + pub fn clear_limit(&mut self) { + self.limit = ::std::option::Option::None + } + pub fn set_limit(&mut self, v: Limit) { + self.limit = ::std::option::Option::Some(v); + } + pub fn get_limit(&self) -> &Limit { + match self.limit.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_limit(&mut self) -> &mut Limit { + if self.limit.is_none() { + self.limit = ::std::option::Option::Some(Limit::default()); + } + self.limit.as_mut().unwrap() + } + pub fn take_limit(&mut self) -> Limit { + self.limit.take().unwrap_or_else(Limit::default) + } + pub fn has_stream_agg(&self) -> bool { + self.stream_agg.is_some() + } + pub fn clear_stream_agg(&mut self) { + self.stream_agg = ::std::option::Option::None + } + pub fn set_stream_agg(&mut self, v: Aggregation) { + self.stream_agg = ::std::option::Option::Some(v); + } + pub fn get_stream_agg(&self) -> &Aggregation { + match self.stream_agg.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_stream_agg(&mut self) -> &mut Aggregation { + if self.stream_agg.is_none() { + self.stream_agg = ::std::option::Option::Some(Aggregation::default()); } + self.stream_agg.as_mut().unwrap() + } + pub fn take_stream_agg(&mut self) -> Aggregation { + self.stream_agg.take().unwrap_or_else(Aggregation::default) + } +} +impl ::protobuf::Clear for Executor { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Executor { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Executor { + ::lazy_static::lazy_static! { + static ref INSTANCE: Executor = Executor::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl TableScan { -pub fn new_() -> TableScan { ::std::default::Default::default() } -pub fn has_table_id(&self) -> bool { self.table_id.is_some() } -pub fn clear_table_id(&mut self) { self.table_id = ::std::option::Option::None } -pub fn set_table_id(&mut self, v: i64) { self.table_id = ::std::option::Option::Some(v); } -pub fn get_table_id(&self) -> i64 { match self.table_id { - Some(v) => v, - None => 0, - } } -pub fn clear_columns(&mut self) { self.columns.clear(); } -pub fn set_columns(&mut self, v: :: std :: vec :: Vec < ColumnInfo >) { self.columns = v; } -pub fn get_columns(&self) -> &:: std :: vec :: Vec < ColumnInfo > { &self.columns } -pub fn mut_columns(&mut self) -> &mut :: std :: vec :: Vec < ColumnInfo > { &mut self.columns } -pub fn take_columns(&mut self) -> :: std :: vec :: Vec < ColumnInfo > { ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) } -pub fn has_desc(&self) -> bool { self.desc.is_some() } -pub fn clear_desc(&mut self) { self.desc = ::std::option::Option::None } -pub fn set_desc(&mut self, v: bool) { self.desc = ::std::option::Option::Some(v); } -pub fn get_desc(&self) -> bool { match self.desc { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for TableScan {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for TableScan {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static TableScan { - ::lazy_static::lazy_static! { - static ref INSTANCE: TableScan = TableScan::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> TableScan { + ::std::default::Default::default() + } + pub fn has_table_id(&self) -> bool { + self.table_id.is_some() + } + pub fn clear_table_id(&mut self) { + self.table_id = ::std::option::Option::None + } + pub fn set_table_id(&mut self, v: i64) { + self.table_id = ::std::option::Option::Some(v); + } + pub fn get_table_id(&self) -> i64 { + match self.table_id { + Some(v) => v, + None => 0, } + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + pub fn set_columns(&mut self, v: ::std::vec::Vec) { + self.columns = v; + } + pub fn get_columns(&self) -> &::std::vec::Vec { + &self.columns + } + pub fn mut_columns(&mut self) -> &mut ::std::vec::Vec { + &mut self.columns + } + pub fn take_columns(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) + } + pub fn has_desc(&self) -> bool { + self.desc.is_some() + } + pub fn clear_desc(&mut self) { + self.desc = ::std::option::Option::None + } + pub fn set_desc(&mut self, v: bool) { + self.desc = ::std::option::Option::Some(v); + } + pub fn get_desc(&self) -> bool { + match self.desc { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for TableScan { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for TableScan { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static TableScan { + ::lazy_static::lazy_static! { + static ref INSTANCE: TableScan = TableScan::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl IndexScan { -pub fn new_() -> IndexScan { ::std::default::Default::default() } -pub fn has_table_id(&self) -> bool { self.table_id.is_some() } -pub fn clear_table_id(&mut self) { self.table_id = ::std::option::Option::None } -pub fn set_table_id(&mut self, v: i64) { self.table_id = ::std::option::Option::Some(v); } -pub fn get_table_id(&self) -> i64 { match self.table_id { - Some(v) => v, - None => 0, - } } -pub fn has_index_id(&self) -> bool { self.index_id.is_some() } -pub fn clear_index_id(&mut self) { self.index_id = ::std::option::Option::None } -pub fn set_index_id(&mut self, v: i64) { self.index_id = ::std::option::Option::Some(v); } -pub fn get_index_id(&self) -> i64 { match self.index_id { - Some(v) => v, - None => 0, - } } -pub fn clear_columns(&mut self) { self.columns.clear(); } -pub fn set_columns(&mut self, v: :: std :: vec :: Vec < ColumnInfo >) { self.columns = v; } -pub fn get_columns(&self) -> &:: std :: vec :: Vec < ColumnInfo > { &self.columns } -pub fn mut_columns(&mut self) -> &mut :: std :: vec :: Vec < ColumnInfo > { &mut self.columns } -pub fn take_columns(&mut self) -> :: std :: vec :: Vec < ColumnInfo > { ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) } -pub fn has_desc(&self) -> bool { self.desc.is_some() } -pub fn clear_desc(&mut self) { self.desc = ::std::option::Option::None } -pub fn set_desc(&mut self, v: bool) { self.desc = ::std::option::Option::Some(v); } -pub fn get_desc(&self) -> bool { match self.desc { - Some(v) => v, - None => false, - } } -pub fn has_unique(&self) -> bool { self.unique.is_some() } -pub fn clear_unique(&mut self) { self.unique = ::std::option::Option::None } -pub fn set_unique(&mut self, v: bool) { self.unique = ::std::option::Option::Some(v); } -pub fn get_unique(&self) -> bool { match self.unique { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for IndexScan {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for IndexScan {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static IndexScan { - ::lazy_static::lazy_static! { - static ref INSTANCE: IndexScan = IndexScan::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> IndexScan { + ::std::default::Default::default() + } + pub fn has_table_id(&self) -> bool { + self.table_id.is_some() + } + pub fn clear_table_id(&mut self) { + self.table_id = ::std::option::Option::None + } + pub fn set_table_id(&mut self, v: i64) { + self.table_id = ::std::option::Option::Some(v); + } + pub fn get_table_id(&self) -> i64 { + match self.table_id { + Some(v) => v, + None => 0, + } + } + pub fn has_index_id(&self) -> bool { + self.index_id.is_some() + } + pub fn clear_index_id(&mut self) { + self.index_id = ::std::option::Option::None + } + pub fn set_index_id(&mut self, v: i64) { + self.index_id = ::std::option::Option::Some(v); + } + pub fn get_index_id(&self) -> i64 { + match self.index_id { + Some(v) => v, + None => 0, + } + } + pub fn clear_columns(&mut self) { + self.columns.clear(); + } + pub fn set_columns(&mut self, v: ::std::vec::Vec) { + self.columns = v; + } + pub fn get_columns(&self) -> &::std::vec::Vec { + &self.columns + } + pub fn mut_columns(&mut self) -> &mut ::std::vec::Vec { + &mut self.columns + } + pub fn take_columns(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.columns, ::std::vec::Vec::new()) + } + pub fn has_desc(&self) -> bool { + self.desc.is_some() + } + pub fn clear_desc(&mut self) { + self.desc = ::std::option::Option::None + } + pub fn set_desc(&mut self, v: bool) { + self.desc = ::std::option::Option::Some(v); + } + pub fn get_desc(&self) -> bool { + match self.desc { + Some(v) => v, + None => false, + } + } + pub fn has_unique(&self) -> bool { + self.unique.is_some() + } + pub fn clear_unique(&mut self) { + self.unique = ::std::option::Option::None + } + pub fn set_unique(&mut self, v: bool) { + self.unique = ::std::option::Option::Some(v); + } + pub fn get_unique(&self) -> bool { + match self.unique { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for IndexScan { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for IndexScan { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static IndexScan { + ::lazy_static::lazy_static! { + static ref INSTANCE: IndexScan = IndexScan::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl Selection { -pub fn new_() -> Selection { ::std::default::Default::default() } -pub fn clear_conditions(&mut self) { self.conditions.clear(); } -pub fn set_conditions(&mut self, v: :: std :: vec :: Vec < Expr >) { self.conditions = v; } -pub fn get_conditions(&self) -> &:: std :: vec :: Vec < Expr > { &self.conditions } -pub fn mut_conditions(&mut self) -> &mut :: std :: vec :: Vec < Expr > { &mut self.conditions } -pub fn take_conditions(&mut self) -> :: std :: vec :: Vec < Expr > { ::std::mem::replace(&mut self.conditions, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for Selection {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Selection {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Selection { - ::lazy_static::lazy_static! { - static ref INSTANCE: Selection = Selection::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Selection { + ::std::default::Default::default() + } + pub fn clear_conditions(&mut self) { + self.conditions.clear(); + } + pub fn set_conditions(&mut self, v: ::std::vec::Vec) { + self.conditions = v; + } + pub fn get_conditions(&self) -> &::std::vec::Vec { + &self.conditions + } + pub fn mut_conditions(&mut self) -> &mut ::std::vec::Vec { + &mut self.conditions + } + pub fn take_conditions(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.conditions, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for Selection { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Selection { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Selection { + ::lazy_static::lazy_static! { + static ref INSTANCE: Selection = Selection::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Projection { -pub fn new_() -> Projection { ::std::default::Default::default() } -pub fn clear_exprs(&mut self) { self.exprs.clear(); } -pub fn set_exprs(&mut self, v: :: std :: vec :: Vec < Expr >) { self.exprs = v; } -pub fn get_exprs(&self) -> &:: std :: vec :: Vec < Expr > { &self.exprs } -pub fn mut_exprs(&mut self) -> &mut :: std :: vec :: Vec < Expr > { &mut self.exprs } -pub fn take_exprs(&mut self) -> :: std :: vec :: Vec < Expr > { ::std::mem::replace(&mut self.exprs, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for Projection {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Projection {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Projection { - ::lazy_static::lazy_static! { - static ref INSTANCE: Projection = Projection::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Projection { + ::std::default::Default::default() + } + pub fn clear_exprs(&mut self) { + self.exprs.clear(); + } + pub fn set_exprs(&mut self, v: ::std::vec::Vec) { + self.exprs = v; + } + pub fn get_exprs(&self) -> &::std::vec::Vec { + &self.exprs + } + pub fn mut_exprs(&mut self) -> &mut ::std::vec::Vec { + &mut self.exprs + } + pub fn take_exprs(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.exprs, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for Projection { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Projection { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Projection { + ::lazy_static::lazy_static! { + static ref INSTANCE: Projection = Projection::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Aggregation { -pub fn new_() -> Aggregation { ::std::default::Default::default() } -pub fn clear_group_by(&mut self) { self.group_by.clear(); } -pub fn set_group_by(&mut self, v: :: std :: vec :: Vec < Expr >) { self.group_by = v; } -pub fn get_group_by(&self) -> &:: std :: vec :: Vec < Expr > { &self.group_by } -pub fn mut_group_by(&mut self) -> &mut :: std :: vec :: Vec < Expr > { &mut self.group_by } -pub fn take_group_by(&mut self) -> :: std :: vec :: Vec < Expr > { ::std::mem::replace(&mut self.group_by, ::std::vec::Vec::new()) } -pub fn clear_agg_func(&mut self) { self.agg_func.clear(); } -pub fn set_agg_func(&mut self, v: :: std :: vec :: Vec < Expr >) { self.agg_func = v; } -pub fn get_agg_func(&self) -> &:: std :: vec :: Vec < Expr > { &self.agg_func } -pub fn mut_agg_func(&mut self) -> &mut :: std :: vec :: Vec < Expr > { &mut self.agg_func } -pub fn take_agg_func(&mut self) -> :: std :: vec :: Vec < Expr > { ::std::mem::replace(&mut self.agg_func, ::std::vec::Vec::new()) } -pub fn has_streamed(&self) -> bool { self.streamed.is_some() } -pub fn clear_streamed(&mut self) { self.streamed = ::std::option::Option::None } -pub fn set_streamed(&mut self, v: bool) { self.streamed = ::std::option::Option::Some(v); } -pub fn get_streamed(&self) -> bool { match self.streamed { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for Aggregation {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Aggregation {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Aggregation { - ::lazy_static::lazy_static! { - static ref INSTANCE: Aggregation = Aggregation::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Aggregation { + ::std::default::Default::default() + } + pub fn clear_group_by(&mut self) { + self.group_by.clear(); + } + pub fn set_group_by(&mut self, v: ::std::vec::Vec) { + self.group_by = v; + } + pub fn get_group_by(&self) -> &::std::vec::Vec { + &self.group_by + } + pub fn mut_group_by(&mut self) -> &mut ::std::vec::Vec { + &mut self.group_by + } + pub fn take_group_by(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.group_by, ::std::vec::Vec::new()) + } + pub fn clear_agg_func(&mut self) { + self.agg_func.clear(); + } + pub fn set_agg_func(&mut self, v: ::std::vec::Vec) { + self.agg_func = v; + } + pub fn get_agg_func(&self) -> &::std::vec::Vec { + &self.agg_func + } + pub fn mut_agg_func(&mut self) -> &mut ::std::vec::Vec { + &mut self.agg_func + } + pub fn take_agg_func(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.agg_func, ::std::vec::Vec::new()) + } + pub fn has_streamed(&self) -> bool { + self.streamed.is_some() + } + pub fn clear_streamed(&mut self) { + self.streamed = ::std::option::Option::None + } + pub fn set_streamed(&mut self, v: bool) { + self.streamed = ::std::option::Option::Some(v); + } + pub fn get_streamed(&self) -> bool { + match self.streamed { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for Aggregation { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Aggregation { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Aggregation { + ::lazy_static::lazy_static! { + static ref INSTANCE: Aggregation = Aggregation::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl TopN { -pub fn new_() -> TopN { ::std::default::Default::default() } -pub fn clear_order_by(&mut self) { self.order_by.clear(); } -pub fn set_order_by(&mut self, v: :: std :: vec :: Vec < ByItem >) { self.order_by = v; } -pub fn get_order_by(&self) -> &:: std :: vec :: Vec < ByItem > { &self.order_by } -pub fn mut_order_by(&mut self) -> &mut :: std :: vec :: Vec < ByItem > { &mut self.order_by } -pub fn take_order_by(&mut self) -> :: std :: vec :: Vec < ByItem > { ::std::mem::replace(&mut self.order_by, ::std::vec::Vec::new()) } -pub fn has_limit(&self) -> bool { self.limit.is_some() } -pub fn clear_limit(&mut self) { self.limit = ::std::option::Option::None } -pub fn set_limit(&mut self, v: u64) { self.limit = ::std::option::Option::Some(v); } -pub fn get_limit(&self) -> u64 { match self.limit { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for TopN {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for TopN {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static TopN { - ::lazy_static::lazy_static! { - static ref INSTANCE: TopN = TopN::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> TopN { + ::std::default::Default::default() + } + pub fn clear_order_by(&mut self) { + self.order_by.clear(); + } + pub fn set_order_by(&mut self, v: ::std::vec::Vec) { + self.order_by = v; + } + pub fn get_order_by(&self) -> &::std::vec::Vec { + &self.order_by + } + pub fn mut_order_by(&mut self) -> &mut ::std::vec::Vec { + &mut self.order_by + } + pub fn take_order_by(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.order_by, ::std::vec::Vec::new()) + } + pub fn has_limit(&self) -> bool { + self.limit.is_some() + } + pub fn clear_limit(&mut self) { + self.limit = ::std::option::Option::None + } + pub fn set_limit(&mut self, v: u64) { + self.limit = ::std::option::Option::Some(v); + } + pub fn get_limit(&self) -> u64 { + match self.limit { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for TopN { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for TopN { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static TopN { + ::lazy_static::lazy_static! { + static ref INSTANCE: TopN = TopN::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl Limit { -pub fn new_() -> Limit { ::std::default::Default::default() } -pub fn has_limit(&self) -> bool { self.limit.is_some() } -pub fn clear_limit(&mut self) { self.limit = ::std::option::Option::None } -pub fn set_limit(&mut self, v: u64) { self.limit = ::std::option::Option::Some(v); } -pub fn get_limit(&self) -> u64 { match self.limit { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for Limit {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Limit {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Limit { - ::lazy_static::lazy_static! { - static ref INSTANCE: Limit = Limit::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Limit { + ::std::default::Default::default() + } + pub fn has_limit(&self) -> bool { + self.limit.is_some() + } + pub fn clear_limit(&mut self) { + self.limit = ::std::option::Option::None + } + pub fn set_limit(&mut self, v: u64) { + self.limit = ::std::option::Option::Some(v); + } + pub fn get_limit(&self) -> u64 { + match self.limit { + Some(v) => v, + None => 0, } + } +} +impl ::protobuf::Clear for Limit { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Limit { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Limit { + ::lazy_static::lazy_static! { + static ref INSTANCE: Limit = Limit::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl ExecutorExecutionSummary { -pub fn new_() -> ExecutorExecutionSummary { ::std::default::Default::default() } -pub fn has_time_processed_ns(&self) -> bool { self.time_processed_ns.is_some() } -pub fn clear_time_processed_ns(&mut self) { self.time_processed_ns = ::std::option::Option::None } -pub fn set_time_processed_ns(&mut self, v: u64) { self.time_processed_ns = ::std::option::Option::Some(v); } -pub fn get_time_processed_ns(&self) -> u64 { match self.time_processed_ns { - Some(v) => v, - None => 0, - } } -pub fn has_num_produced_rows(&self) -> bool { self.num_produced_rows.is_some() } -pub fn clear_num_produced_rows(&mut self) { self.num_produced_rows = ::std::option::Option::None } -pub fn set_num_produced_rows(&mut self, v: u64) { self.num_produced_rows = ::std::option::Option::Some(v); } -pub fn get_num_produced_rows(&self) -> u64 { match self.num_produced_rows { - Some(v) => v, - None => 0, - } } -pub fn has_num_iterations(&self) -> bool { self.num_iterations.is_some() } -pub fn clear_num_iterations(&mut self) { self.num_iterations = ::std::option::Option::None } -pub fn set_num_iterations(&mut self, v: u64) { self.num_iterations = ::std::option::Option::Some(v); } -pub fn get_num_iterations(&self) -> u64 { match self.num_iterations { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for ExecutorExecutionSummary {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for ExecutorExecutionSummary {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static ExecutorExecutionSummary { - ::lazy_static::lazy_static! { - static ref INSTANCE: ExecutorExecutionSummary = ExecutorExecutionSummary::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> ExecutorExecutionSummary { + ::std::default::Default::default() + } + pub fn has_time_processed_ns(&self) -> bool { + self.time_processed_ns.is_some() + } + pub fn clear_time_processed_ns(&mut self) { + self.time_processed_ns = ::std::option::Option::None + } + pub fn set_time_processed_ns(&mut self, v: u64) { + self.time_processed_ns = ::std::option::Option::Some(v); + } + pub fn get_time_processed_ns(&self) -> u64 { + match self.time_processed_ns { + Some(v) => v, + None => 0, } + } + pub fn has_num_produced_rows(&self) -> bool { + self.num_produced_rows.is_some() + } + pub fn clear_num_produced_rows(&mut self) { + self.num_produced_rows = ::std::option::Option::None + } + pub fn set_num_produced_rows(&mut self, v: u64) { + self.num_produced_rows = ::std::option::Option::Some(v); + } + pub fn get_num_produced_rows(&self) -> u64 { + match self.num_produced_rows { + Some(v) => v, + None => 0, + } + } + pub fn has_num_iterations(&self) -> bool { + self.num_iterations.is_some() + } + pub fn clear_num_iterations(&mut self) { + self.num_iterations = ::std::option::Option::None + } + pub fn set_num_iterations(&mut self, v: u64) { + self.num_iterations = ::std::option::Option::Some(v); + } + pub fn get_num_iterations(&self) -> u64 { + match self.num_iterations { + Some(v) => v, + None => 0, + } + } } -impl ExecType { -pub fn values() -> &'static [Self] { -static VALUES: &'static [ExecType] = &[ -ExecType::TypeTableScan, -ExecType::TypeIndexScan, -ExecType::TypeSelection, -ExecType::TypeAggregation, -ExecType::TypeTopN, -ExecType::TypeLimit, -ExecType::TypeStreamAgg, -]; -VALUES +impl ::protobuf::Clear for ExecutorExecutionSummary { + fn clear(&mut self) { + ::prost::Message::clear(self); + } } +impl ::protobuf::Message for ExecutorExecutionSummary { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static ExecutorExecutionSummary { + ::lazy_static::lazy_static! { + static ref INSTANCE: ExecutorExecutionSummary = ExecutorExecutionSummary::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } +} +impl ExecType { + pub fn values() -> &'static [Self] { + static VALUES: &'static [ExecType] = &[ + ExecType::TypeTableScan, + ExecType::TypeIndexScan, + ExecType::TypeSelection, + ExecType::TypeAggregation, + ExecType::TypeTopN, + ExecType::TypeLimit, + ExecType::TypeStreamAgg, + ]; + VALUES + } } impl Row { -pub fn new_() -> Row { ::std::default::Default::default() } -pub fn has_handle(&self) -> bool { self.handle.is_some() } -pub fn clear_handle(&mut self) { self.handle = ::std::option::Option::None } -pub fn set_handle(&mut self, v: std :: vec :: Vec < u8 >) { self.handle = ::std::option::Option::Some(v); } -pub fn get_handle(&self) -> &[u8] { match self.handle.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_handle(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.handle.is_none() { - self.handle = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.handle.as_mut().unwrap() } -pub fn take_handle(&mut self) -> std :: vec :: Vec < u8 > { self.handle.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn has_data(&self) -> bool { self.data.is_some() } -pub fn clear_data(&mut self) { self.data = ::std::option::Option::None } -pub fn set_data(&mut self, v: std :: vec :: Vec < u8 >) { self.data = ::std::option::Option::Some(v); } -pub fn get_data(&self) -> &[u8] { match self.data.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_data(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.data.is_none() { - self.data = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.data.as_mut().unwrap() } -pub fn take_data(&mut self) -> std :: vec :: Vec < u8 > { self.data.take().unwrap_or_else(::std::vec::Vec::new) } -} -impl ::protobuf::Clear for Row {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Row {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Row { - ::lazy_static::lazy_static! { - static ref INSTANCE: Row = Row::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Row { + ::std::default::Default::default() + } + pub fn has_handle(&self) -> bool { + self.handle.is_some() + } + pub fn clear_handle(&mut self) { + self.handle = ::std::option::Option::None + } + pub fn set_handle(&mut self, v: std::vec::Vec) { + self.handle = ::std::option::Option::Some(v); + } + pub fn get_handle(&self) -> &[u8] { + match self.handle.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_handle(&mut self) -> &mut std::vec::Vec { + if self.handle.is_none() { + self.handle = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.handle.as_mut().unwrap() + } + pub fn take_handle(&mut self) -> std::vec::Vec { + self.handle.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn has_data(&self) -> bool { + self.data.is_some() + } + pub fn clear_data(&mut self) { + self.data = ::std::option::Option::None + } + pub fn set_data(&mut self, v: std::vec::Vec) { + self.data = ::std::option::Option::Some(v); + } + pub fn get_data(&self) -> &[u8] { + match self.data.as_ref() { + Some(v) => v, + None => &[], } + } + pub fn mut_data(&mut self) -> &mut std::vec::Vec { + if self.data.is_none() { + self.data = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.data.as_mut().unwrap() + } + pub fn take_data(&mut self) -> std::vec::Vec { + self.data.take().unwrap_or_else(::std::vec::Vec::new) + } +} +impl ::protobuf::Clear for Row { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Row { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Row { + ::lazy_static::lazy_static! { + static ref INSTANCE: Row = Row::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl Error { -pub fn new_() -> Error { ::std::default::Default::default() } -pub fn has_code(&self) -> bool { self.code.is_some() } -pub fn clear_code(&mut self) { self.code = ::std::option::Option::None } -pub fn set_code(&mut self, v: i32) { self.code = ::std::option::Option::Some(v); } -pub fn get_code(&self) -> i32 { match self.code { - Some(v) => v, - None => 0, - } } -pub fn has_msg(&self) -> bool { self.msg.is_some() } -pub fn clear_msg(&mut self) { self.msg = ::std::option::Option::None } -pub fn set_msg(&mut self, v: std :: string :: String) { self.msg = ::std::option::Option::Some(v); } -pub fn get_msg(&self) -> &str { match self.msg.as_ref() { - Some(v) => v, - None => "", - } } -pub fn mut_msg(&mut self) -> &mut std :: string :: String { if self.msg.is_none() { - self.msg = ::std::option::Option::Some(std :: string :: String::default()); - } - self.msg.as_mut().unwrap() } -pub fn take_msg(&mut self) -> std :: string :: String { self.msg.take().unwrap_or_else(::std::string::String::new) } -} -impl ::protobuf::Clear for Error {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Error {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Error { - ::lazy_static::lazy_static! { - static ref INSTANCE: Error = Error::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Error { + ::std::default::Default::default() + } + pub fn has_code(&self) -> bool { + self.code.is_some() + } + pub fn clear_code(&mut self) { + self.code = ::std::option::Option::None + } + pub fn set_code(&mut self, v: i32) { + self.code = ::std::option::Option::Some(v); + } + pub fn get_code(&self) -> i32 { + match self.code { + Some(v) => v, + None => 0, + } + } + pub fn has_msg(&self) -> bool { + self.msg.is_some() + } + pub fn clear_msg(&mut self) { + self.msg = ::std::option::Option::None + } + pub fn set_msg(&mut self, v: std::string::String) { + self.msg = ::std::option::Option::Some(v); + } + pub fn get_msg(&self) -> &str { + match self.msg.as_ref() { + Some(v) => v, + None => "", + } + } + pub fn mut_msg(&mut self) -> &mut std::string::String { + if self.msg.is_none() { + self.msg = ::std::option::Option::Some(std::string::String::default()); + } + self.msg.as_mut().unwrap() + } + pub fn take_msg(&mut self) -> std::string::String { + self.msg.take().unwrap_or_else(::std::string::String::new) + } +} +impl ::protobuf::Clear for Error { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Error { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Error { + ::lazy_static::lazy_static! { + static ref INSTANCE: Error = Error::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl SelectResponse { -pub fn new_() -> SelectResponse { ::std::default::Default::default() } -pub fn has_error(&self) -> bool { self.error.is_some() } -pub fn clear_error(&mut self) { self.error = ::std::option::Option::None } -pub fn set_error(&mut self, v: Error) { self.error = ::std::option::Option::Some(v); } -pub fn get_error(&self) -> &Error { match self.error.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_error(&mut self) -> &mut Error { if self.error.is_none() { - self.error = ::std::option::Option::Some(Error::default()); - } - self.error.as_mut().unwrap() } -pub fn take_error(&mut self) -> Error { self.error.take().unwrap_or_else(Error::default) } -pub fn clear_rows(&mut self) { self.rows.clear(); } -pub fn set_rows(&mut self, v: :: std :: vec :: Vec < Row >) { self.rows = v; } -pub fn get_rows(&self) -> &:: std :: vec :: Vec < Row > { &self.rows } -pub fn mut_rows(&mut self) -> &mut :: std :: vec :: Vec < Row > { &mut self.rows } -pub fn take_rows(&mut self) -> :: std :: vec :: Vec < Row > { ::std::mem::replace(&mut self.rows, ::std::vec::Vec::new()) } -pub fn clear_chunks(&mut self) { self.chunks.clear(); } -pub fn set_chunks(&mut self, v: :: std :: vec :: Vec < Chunk >) { self.chunks = v; } -pub fn get_chunks(&self) -> &:: std :: vec :: Vec < Chunk > { &self.chunks } -pub fn mut_chunks(&mut self) -> &mut :: std :: vec :: Vec < Chunk > { &mut self.chunks } -pub fn take_chunks(&mut self) -> :: std :: vec :: Vec < Chunk > { ::std::mem::replace(&mut self.chunks, ::std::vec::Vec::new()) } -pub fn clear_warnings(&mut self) { self.warnings.clear(); } -pub fn set_warnings(&mut self, v: :: std :: vec :: Vec < Error >) { self.warnings = v; } -pub fn get_warnings(&self) -> &:: std :: vec :: Vec < Error > { &self.warnings } -pub fn mut_warnings(&mut self) -> &mut :: std :: vec :: Vec < Error > { &mut self.warnings } -pub fn take_warnings(&mut self) -> :: std :: vec :: Vec < Error > { ::std::mem::replace(&mut self.warnings, ::std::vec::Vec::new()) } -pub fn clear_output_counts(&mut self) { self.output_counts.clear(); } -pub fn set_output_counts(&mut self, v: :: std :: vec :: Vec < i64 >) { self.output_counts = v; } -pub fn get_output_counts(&self) -> &:: std :: vec :: Vec < i64 > { &self.output_counts } -pub fn mut_output_counts(&mut self) -> &mut :: std :: vec :: Vec < i64 > { &mut self.output_counts } -pub fn take_output_counts(&mut self) -> :: std :: vec :: Vec < i64 > { ::std::mem::replace(&mut self.output_counts, ::std::vec::Vec::new()) } -pub fn has_warning_count(&self) -> bool { self.warning_count.is_some() } -pub fn clear_warning_count(&mut self) { self.warning_count = ::std::option::Option::None } -pub fn set_warning_count(&mut self, v: i64) { self.warning_count = ::std::option::Option::Some(v); } -pub fn get_warning_count(&self) -> i64 { match self.warning_count { - Some(v) => v, - None => 0, - } } -pub fn has_row_batch_data(&self) -> bool { self.row_batch_data.is_some() } -pub fn clear_row_batch_data(&mut self) { self.row_batch_data = ::std::option::Option::None } -pub fn set_row_batch_data(&mut self, v: std :: vec :: Vec < u8 >) { self.row_batch_data = ::std::option::Option::Some(v); } -pub fn get_row_batch_data(&self) -> &[u8] { match self.row_batch_data.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_row_batch_data(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.row_batch_data.is_none() { - self.row_batch_data = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.row_batch_data.as_mut().unwrap() } -pub fn take_row_batch_data(&mut self) -> std :: vec :: Vec < u8 > { self.row_batch_data.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn clear_execution_summaries(&mut self) { self.execution_summaries.clear(); } -pub fn set_execution_summaries(&mut self, v: :: std :: vec :: Vec < ExecutorExecutionSummary >) { self.execution_summaries = v; } -pub fn get_execution_summaries(&self) -> &:: std :: vec :: Vec < ExecutorExecutionSummary > { &self.execution_summaries } -pub fn mut_execution_summaries(&mut self) -> &mut :: std :: vec :: Vec < ExecutorExecutionSummary > { &mut self.execution_summaries } -pub fn take_execution_summaries(&mut self) -> :: std :: vec :: Vec < ExecutorExecutionSummary > { ::std::mem::replace(&mut self.execution_summaries, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for SelectResponse {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for SelectResponse {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static SelectResponse { - ::lazy_static::lazy_static! { - static ref INSTANCE: SelectResponse = SelectResponse::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> SelectResponse { + ::std::default::Default::default() + } + pub fn has_error(&self) -> bool { + self.error.is_some() + } + pub fn clear_error(&mut self) { + self.error = ::std::option::Option::None + } + pub fn set_error(&mut self, v: Error) { + self.error = ::std::option::Option::Some(v); + } + pub fn get_error(&self) -> &Error { + match self.error.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_error(&mut self) -> &mut Error { + if self.error.is_none() { + self.error = ::std::option::Option::Some(Error::default()); + } + self.error.as_mut().unwrap() + } + pub fn take_error(&mut self) -> Error { + self.error.take().unwrap_or_else(Error::default) + } + pub fn clear_rows(&mut self) { + self.rows.clear(); + } + pub fn set_rows(&mut self, v: ::std::vec::Vec) { + self.rows = v; + } + pub fn get_rows(&self) -> &::std::vec::Vec { + &self.rows + } + pub fn mut_rows(&mut self) -> &mut ::std::vec::Vec { + &mut self.rows + } + pub fn take_rows(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.rows, ::std::vec::Vec::new()) + } + pub fn clear_chunks(&mut self) { + self.chunks.clear(); + } + pub fn set_chunks(&mut self, v: ::std::vec::Vec) { + self.chunks = v; + } + pub fn get_chunks(&self) -> &::std::vec::Vec { + &self.chunks + } + pub fn mut_chunks(&mut self) -> &mut ::std::vec::Vec { + &mut self.chunks + } + pub fn take_chunks(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.chunks, ::std::vec::Vec::new()) + } + pub fn clear_warnings(&mut self) { + self.warnings.clear(); + } + pub fn set_warnings(&mut self, v: ::std::vec::Vec) { + self.warnings = v; + } + pub fn get_warnings(&self) -> &::std::vec::Vec { + &self.warnings + } + pub fn mut_warnings(&mut self) -> &mut ::std::vec::Vec { + &mut self.warnings + } + pub fn take_warnings(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.warnings, ::std::vec::Vec::new()) + } + pub fn clear_output_counts(&mut self) { + self.output_counts.clear(); + } + pub fn set_output_counts(&mut self, v: ::std::vec::Vec) { + self.output_counts = v; + } + pub fn get_output_counts(&self) -> &::std::vec::Vec { + &self.output_counts + } + pub fn mut_output_counts(&mut self) -> &mut ::std::vec::Vec { + &mut self.output_counts + } + pub fn take_output_counts(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.output_counts, ::std::vec::Vec::new()) + } + pub fn has_warning_count(&self) -> bool { + self.warning_count.is_some() + } + pub fn clear_warning_count(&mut self) { + self.warning_count = ::std::option::Option::None + } + pub fn set_warning_count(&mut self, v: i64) { + self.warning_count = ::std::option::Option::Some(v); + } + pub fn get_warning_count(&self) -> i64 { + match self.warning_count { + Some(v) => v, + None => 0, + } + } + pub fn has_row_batch_data(&self) -> bool { + self.row_batch_data.is_some() + } + pub fn clear_row_batch_data(&mut self) { + self.row_batch_data = ::std::option::Option::None + } + pub fn set_row_batch_data(&mut self, v: std::vec::Vec) { + self.row_batch_data = ::std::option::Option::Some(v); + } + pub fn get_row_batch_data(&self) -> &[u8] { + match self.row_batch_data.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_row_batch_data(&mut self) -> &mut std::vec::Vec { + if self.row_batch_data.is_none() { + self.row_batch_data = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.row_batch_data.as_mut().unwrap() + } + pub fn take_row_batch_data(&mut self) -> std::vec::Vec { + self.row_batch_data + .take() + .unwrap_or_else(::std::vec::Vec::new) + } + pub fn clear_execution_summaries(&mut self) { + self.execution_summaries.clear(); + } + pub fn set_execution_summaries(&mut self, v: ::std::vec::Vec) { + self.execution_summaries = v; + } + pub fn get_execution_summaries(&self) -> &::std::vec::Vec { + &self.execution_summaries + } + pub fn mut_execution_summaries(&mut self) -> &mut ::std::vec::Vec { + &mut self.execution_summaries + } + pub fn take_execution_summaries(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.execution_summaries, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for SelectResponse { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for SelectResponse { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static SelectResponse { + ::lazy_static::lazy_static! { + static ref INSTANCE: SelectResponse = SelectResponse::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl Chunk { -pub fn new_() -> Chunk { ::std::default::Default::default() } -pub fn has_rows_data(&self) -> bool { self.rows_data.is_some() } -pub fn clear_rows_data(&mut self) { self.rows_data = ::std::option::Option::None } -pub fn set_rows_data(&mut self, v: std :: vec :: Vec < u8 >) { self.rows_data = ::std::option::Option::Some(v); } -pub fn get_rows_data(&self) -> &[u8] { match self.rows_data.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_rows_data(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.rows_data.is_none() { - self.rows_data = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.rows_data.as_mut().unwrap() } -pub fn take_rows_data(&mut self) -> std :: vec :: Vec < u8 > { self.rows_data.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn clear_rows_meta(&mut self) { self.rows_meta.clear(); } -pub fn set_rows_meta(&mut self, v: :: std :: vec :: Vec < RowMeta >) { self.rows_meta = v; } -pub fn get_rows_meta(&self) -> &:: std :: vec :: Vec < RowMeta > { &self.rows_meta } -pub fn mut_rows_meta(&mut self) -> &mut :: std :: vec :: Vec < RowMeta > { &mut self.rows_meta } -pub fn take_rows_meta(&mut self) -> :: std :: vec :: Vec < RowMeta > { ::std::mem::replace(&mut self.rows_meta, ::std::vec::Vec::new()) } -} -impl ::protobuf::Clear for Chunk {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for Chunk {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static Chunk { - ::lazy_static::lazy_static! { - static ref INSTANCE: Chunk = Chunk::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> Chunk { + ::std::default::Default::default() + } + pub fn has_rows_data(&self) -> bool { + self.rows_data.is_some() + } + pub fn clear_rows_data(&mut self) { + self.rows_data = ::std::option::Option::None + } + pub fn set_rows_data(&mut self, v: std::vec::Vec) { + self.rows_data = ::std::option::Option::Some(v); + } + pub fn get_rows_data(&self) -> &[u8] { + match self.rows_data.as_ref() { + Some(v) => v, + None => &[], } + } + pub fn mut_rows_data(&mut self) -> &mut std::vec::Vec { + if self.rows_data.is_none() { + self.rows_data = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.rows_data.as_mut().unwrap() + } + pub fn take_rows_data(&mut self) -> std::vec::Vec { + self.rows_data.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn clear_rows_meta(&mut self) { + self.rows_meta.clear(); + } + pub fn set_rows_meta(&mut self, v: ::std::vec::Vec) { + self.rows_meta = v; + } + pub fn get_rows_meta(&self) -> &::std::vec::Vec { + &self.rows_meta + } + pub fn mut_rows_meta(&mut self) -> &mut ::std::vec::Vec { + &mut self.rows_meta + } + pub fn take_rows_meta(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.rows_meta, ::std::vec::Vec::new()) + } +} +impl ::protobuf::Clear for Chunk { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for Chunk { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static Chunk { + ::lazy_static::lazy_static! { + static ref INSTANCE: Chunk = Chunk::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl RowMeta { -pub fn new_() -> RowMeta { ::std::default::Default::default() } -pub fn has_handle(&self) -> bool { self.handle.is_some() } -pub fn clear_handle(&mut self) { self.handle = ::std::option::Option::None } -pub fn set_handle(&mut self, v: i64) { self.handle = ::std::option::Option::Some(v); } -pub fn get_handle(&self) -> i64 { match self.handle { - Some(v) => v, - None => 0, - } } -pub fn has_length(&self) -> bool { self.length.is_some() } -pub fn clear_length(&mut self) { self.length = ::std::option::Option::None } -pub fn set_length(&mut self, v: i64) { self.length = ::std::option::Option::Some(v); } -pub fn get_length(&self) -> i64 { match self.length { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for RowMeta {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for RowMeta {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static RowMeta { - ::lazy_static::lazy_static! { - static ref INSTANCE: RowMeta = RowMeta::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> RowMeta { + ::std::default::Default::default() + } + pub fn has_handle(&self) -> bool { + self.handle.is_some() + } + pub fn clear_handle(&mut self) { + self.handle = ::std::option::Option::None + } + pub fn set_handle(&mut self, v: i64) { + self.handle = ::std::option::Option::Some(v); + } + pub fn get_handle(&self) -> i64 { + match self.handle { + Some(v) => v, + None => 0, + } + } + pub fn has_length(&self) -> bool { + self.length.is_some() + } + pub fn clear_length(&mut self) { + self.length = ::std::option::Option::None + } + pub fn set_length(&mut self, v: i64) { + self.length = ::std::option::Option::Some(v); + } + pub fn get_length(&self) -> i64 { + match self.length { + Some(v) => v, + None => 0, + } + } +} +impl ::protobuf::Clear for RowMeta { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for RowMeta { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static RowMeta { + ::lazy_static::lazy_static! { + static ref INSTANCE: RowMeta = RowMeta::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); } + Ok(()) + } } impl DagRequest { -pub fn new_() -> DagRequest { ::std::default::Default::default() } -pub fn has_start_ts(&self) -> bool { self.start_ts.is_some() } -pub fn clear_start_ts(&mut self) { self.start_ts = ::std::option::Option::None } -pub fn set_start_ts(&mut self, v: u64) { self.start_ts = ::std::option::Option::Some(v); } -pub fn get_start_ts(&self) -> u64 { match self.start_ts { - Some(v) => v, - None => 0, - } } -pub fn clear_executors(&mut self) { self.executors.clear(); } -pub fn set_executors(&mut self, v: :: std :: vec :: Vec < Executor >) { self.executors = v; } -pub fn get_executors(&self) -> &:: std :: vec :: Vec < Executor > { &self.executors } -pub fn mut_executors(&mut self) -> &mut :: std :: vec :: Vec < Executor > { &mut self.executors } -pub fn take_executors(&mut self) -> :: std :: vec :: Vec < Executor > { ::std::mem::replace(&mut self.executors, ::std::vec::Vec::new()) } -pub fn has_time_zone_offset(&self) -> bool { self.time_zone_offset.is_some() } -pub fn clear_time_zone_offset(&mut self) { self.time_zone_offset = ::std::option::Option::None } -pub fn set_time_zone_offset(&mut self, v: i64) { self.time_zone_offset = ::std::option::Option::Some(v); } -pub fn get_time_zone_offset(&self) -> i64 { match self.time_zone_offset { - Some(v) => v, - None => 0, - } } -pub fn has_flags(&self) -> bool { self.flags.is_some() } -pub fn clear_flags(&mut self) { self.flags = ::std::option::Option::None } -pub fn set_flags(&mut self, v: u64) { self.flags = ::std::option::Option::Some(v); } -pub fn get_flags(&self) -> u64 { match self.flags { - Some(v) => v, - None => 0, - } } -pub fn clear_output_offsets(&mut self) { self.output_offsets.clear(); } -pub fn set_output_offsets(&mut self, v: :: std :: vec :: Vec < u32 >) { self.output_offsets = v; } -pub fn get_output_offsets(&self) -> &:: std :: vec :: Vec < u32 > { &self.output_offsets } -pub fn mut_output_offsets(&mut self) -> &mut :: std :: vec :: Vec < u32 > { &mut self.output_offsets } -pub fn take_output_offsets(&mut self) -> :: std :: vec :: Vec < u32 > { ::std::mem::replace(&mut self.output_offsets, ::std::vec::Vec::new()) } -pub fn has_collect_range_counts(&self) -> bool { self.collect_range_counts.is_some() } -pub fn clear_collect_range_counts(&mut self) { self.collect_range_counts = ::std::option::Option::None } -pub fn set_collect_range_counts(&mut self, v: bool) { self.collect_range_counts = ::std::option::Option::Some(v); } -pub fn get_collect_range_counts(&self) -> bool { match self.collect_range_counts { - Some(v) => v, - None => false, - } } -pub fn has_max_warning_count(&self) -> bool { self.max_warning_count.is_some() } -pub fn clear_max_warning_count(&mut self) { self.max_warning_count = ::std::option::Option::None } -pub fn set_max_warning_count(&mut self, v: u64) { self.max_warning_count = ::std::option::Option::Some(v); } -pub fn get_max_warning_count(&self) -> u64 { match self.max_warning_count { - Some(v) => v, - None => 0, - } } -pub fn has_encode_type(&self) -> bool { self.encode_type.is_some() } -pub fn clear_encode_type(&mut self) { self.encode_type = ::std::option::Option::None } -pub fn set_encode_type_(&mut self, v: EncodeType) { self.encode_type = ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); } -pub fn get_encode_type(&self) -> EncodeType { unsafe { ::std::mem::transmute::(match self.encode_type { - Some(v) => v, - None => 0, - }) } } -pub fn has_sql_mode(&self) -> bool { self.sql_mode.is_some() } -pub fn clear_sql_mode(&mut self) { self.sql_mode = ::std::option::Option::None } -pub fn set_sql_mode(&mut self, v: u64) { self.sql_mode = ::std::option::Option::Some(v); } -pub fn get_sql_mode(&self) -> u64 { match self.sql_mode { - Some(v) => v, - None => 0, - } } -pub fn has_time_zone_name(&self) -> bool { self.time_zone_name.is_some() } -pub fn clear_time_zone_name(&mut self) { self.time_zone_name = ::std::option::Option::None } -pub fn set_time_zone_name(&mut self, v: std :: string :: String) { self.time_zone_name = ::std::option::Option::Some(v); } -pub fn get_time_zone_name(&self) -> &str { match self.time_zone_name.as_ref() { - Some(v) => v, - None => "", - } } -pub fn mut_time_zone_name(&mut self) -> &mut std :: string :: String { if self.time_zone_name.is_none() { - self.time_zone_name = ::std::option::Option::Some(std :: string :: String::default()); - } - self.time_zone_name.as_mut().unwrap() } -pub fn take_time_zone_name(&mut self) -> std :: string :: String { self.time_zone_name.take().unwrap_or_else(::std::string::String::new) } -pub fn has_collect_execution_summaries(&self) -> bool { self.collect_execution_summaries.is_some() } -pub fn clear_collect_execution_summaries(&mut self) { self.collect_execution_summaries = ::std::option::Option::None } -pub fn set_collect_execution_summaries(&mut self, v: bool) { self.collect_execution_summaries = ::std::option::Option::Some(v); } -pub fn get_collect_execution_summaries(&self) -> bool { match self.collect_execution_summaries { - Some(v) => v, - None => false, - } } -} -impl ::protobuf::Clear for DagRequest {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for DagRequest {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static DagRequest { - ::lazy_static::lazy_static! { - static ref INSTANCE: DagRequest = DagRequest::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> DagRequest { + ::std::default::Default::default() + } + pub fn has_start_ts(&self) -> bool { + self.start_ts.is_some() + } + pub fn clear_start_ts(&mut self) { + self.start_ts = ::std::option::Option::None + } + pub fn set_start_ts(&mut self, v: u64) { + self.start_ts = ::std::option::Option::Some(v); + } + pub fn get_start_ts(&self) -> u64 { + match self.start_ts { + Some(v) => v, + None => 0, + } + } + pub fn clear_executors(&mut self) { + self.executors.clear(); + } + pub fn set_executors(&mut self, v: ::std::vec::Vec) { + self.executors = v; + } + pub fn get_executors(&self) -> &::std::vec::Vec { + &self.executors + } + pub fn mut_executors(&mut self) -> &mut ::std::vec::Vec { + &mut self.executors + } + pub fn take_executors(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.executors, ::std::vec::Vec::new()) + } + pub fn has_time_zone_offset(&self) -> bool { + self.time_zone_offset.is_some() + } + pub fn clear_time_zone_offset(&mut self) { + self.time_zone_offset = ::std::option::Option::None + } + pub fn set_time_zone_offset(&mut self, v: i64) { + self.time_zone_offset = ::std::option::Option::Some(v); + } + pub fn get_time_zone_offset(&self) -> i64 { + match self.time_zone_offset { + Some(v) => v, + None => 0, + } + } + pub fn has_flags(&self) -> bool { + self.flags.is_some() + } + pub fn clear_flags(&mut self) { + self.flags = ::std::option::Option::None + } + pub fn set_flags(&mut self, v: u64) { + self.flags = ::std::option::Option::Some(v); + } + pub fn get_flags(&self) -> u64 { + match self.flags { + Some(v) => v, + None => 0, + } + } + pub fn clear_output_offsets(&mut self) { + self.output_offsets.clear(); + } + pub fn set_output_offsets(&mut self, v: ::std::vec::Vec) { + self.output_offsets = v; + } + pub fn get_output_offsets(&self) -> &::std::vec::Vec { + &self.output_offsets + } + pub fn mut_output_offsets(&mut self) -> &mut ::std::vec::Vec { + &mut self.output_offsets + } + pub fn take_output_offsets(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.output_offsets, ::std::vec::Vec::new()) + } + pub fn has_collect_range_counts(&self) -> bool { + self.collect_range_counts.is_some() + } + pub fn clear_collect_range_counts(&mut self) { + self.collect_range_counts = ::std::option::Option::None + } + pub fn set_collect_range_counts(&mut self, v: bool) { + self.collect_range_counts = ::std::option::Option::Some(v); + } + pub fn get_collect_range_counts(&self) -> bool { + match self.collect_range_counts { + Some(v) => v, + None => false, + } + } + pub fn has_max_warning_count(&self) -> bool { + self.max_warning_count.is_some() + } + pub fn clear_max_warning_count(&mut self) { + self.max_warning_count = ::std::option::Option::None + } + pub fn set_max_warning_count(&mut self, v: u64) { + self.max_warning_count = ::std::option::Option::Some(v); + } + pub fn get_max_warning_count(&self) -> u64 { + match self.max_warning_count { + Some(v) => v, + None => 0, + } + } + pub fn has_encode_type(&self) -> bool { + self.encode_type.is_some() + } + pub fn clear_encode_type(&mut self) { + self.encode_type = ::std::option::Option::None + } + pub fn set_encode_type_(&mut self, v: EncodeType) { + self.encode_type = + ::std::option::Option::Some(unsafe { ::std::mem::transmute::(v) }); + } + pub fn get_encode_type(&self) -> EncodeType { + unsafe { + ::std::mem::transmute::(match self.encode_type { + Some(v) => v, + None => 0, + }) + } + } + pub fn has_sql_mode(&self) -> bool { + self.sql_mode.is_some() + } + pub fn clear_sql_mode(&mut self) { + self.sql_mode = ::std::option::Option::None + } + pub fn set_sql_mode(&mut self, v: u64) { + self.sql_mode = ::std::option::Option::Some(v); + } + pub fn get_sql_mode(&self) -> u64 { + match self.sql_mode { + Some(v) => v, + None => 0, } + } + pub fn has_time_zone_name(&self) -> bool { + self.time_zone_name.is_some() + } + pub fn clear_time_zone_name(&mut self) { + self.time_zone_name = ::std::option::Option::None + } + pub fn set_time_zone_name(&mut self, v: std::string::String) { + self.time_zone_name = ::std::option::Option::Some(v); + } + pub fn get_time_zone_name(&self) -> &str { + match self.time_zone_name.as_ref() { + Some(v) => v, + None => "", + } + } + pub fn mut_time_zone_name(&mut self) -> &mut std::string::String { + if self.time_zone_name.is_none() { + self.time_zone_name = ::std::option::Option::Some(std::string::String::default()); + } + self.time_zone_name.as_mut().unwrap() + } + pub fn take_time_zone_name(&mut self) -> std::string::String { + self.time_zone_name + .take() + .unwrap_or_else(::std::string::String::new) + } + pub fn has_collect_execution_summaries(&self) -> bool { + self.collect_execution_summaries.is_some() + } + pub fn clear_collect_execution_summaries(&mut self) { + self.collect_execution_summaries = ::std::option::Option::None + } + pub fn set_collect_execution_summaries(&mut self, v: bool) { + self.collect_execution_summaries = ::std::option::Option::Some(v); + } + pub fn get_collect_execution_summaries(&self) -> bool { + match self.collect_execution_summaries { + Some(v) => v, + None => false, + } + } +} +impl ::protobuf::Clear for DagRequest { + fn clear(&mut self) { + ::prost::Message::clear(self); + } +} +impl ::protobuf::Message for DagRequest { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static DagRequest { + ::lazy_static::lazy_static! { + static ref INSTANCE: DagRequest = DagRequest::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } } impl StreamResponse { -pub fn new_() -> StreamResponse { ::std::default::Default::default() } -pub fn has_error(&self) -> bool { self.error.is_some() } -pub fn clear_error(&mut self) { self.error = ::std::option::Option::None } -pub fn set_error(&mut self, v: Error) { self.error = ::std::option::Option::Some(v); } -pub fn get_error(&self) -> &Error { match self.error.as_ref() { - Some(v) => v, - None => ::default_instance(), - } } -pub fn mut_error(&mut self) -> &mut Error { if self.error.is_none() { - self.error = ::std::option::Option::Some(Error::default()); - } - self.error.as_mut().unwrap() } -pub fn take_error(&mut self) -> Error { self.error.take().unwrap_or_else(Error::default) } -pub fn has_data(&self) -> bool { self.data.is_some() } -pub fn clear_data(&mut self) { self.data = ::std::option::Option::None } -pub fn set_data(&mut self, v: std :: vec :: Vec < u8 >) { self.data = ::std::option::Option::Some(v); } -pub fn get_data(&self) -> &[u8] { match self.data.as_ref() { - Some(v) => v, - None => &[], - } } -pub fn mut_data(&mut self) -> &mut std :: vec :: Vec < u8 > { if self.data.is_none() { - self.data = ::std::option::Option::Some(::std::vec::Vec::default()); - } - self.data.as_mut().unwrap() } -pub fn take_data(&mut self) -> std :: vec :: Vec < u8 > { self.data.take().unwrap_or_else(::std::vec::Vec::new) } -pub fn clear_warnings(&mut self) { self.warnings.clear(); } -pub fn set_warnings(&mut self, v: :: std :: vec :: Vec < Error >) { self.warnings = v; } -pub fn get_warnings(&self) -> &:: std :: vec :: Vec < Error > { &self.warnings } -pub fn mut_warnings(&mut self) -> &mut :: std :: vec :: Vec < Error > { &mut self.warnings } -pub fn take_warnings(&mut self) -> :: std :: vec :: Vec < Error > { ::std::mem::replace(&mut self.warnings, ::std::vec::Vec::new()) } -pub fn clear_output_counts(&mut self) { self.output_counts.clear(); } -pub fn set_output_counts(&mut self, v: :: std :: vec :: Vec < i64 >) { self.output_counts = v; } -pub fn get_output_counts(&self) -> &:: std :: vec :: Vec < i64 > { &self.output_counts } -pub fn mut_output_counts(&mut self) -> &mut :: std :: vec :: Vec < i64 > { &mut self.output_counts } -pub fn take_output_counts(&mut self) -> :: std :: vec :: Vec < i64 > { ::std::mem::replace(&mut self.output_counts, ::std::vec::Vec::new()) } -pub fn has_warning_count(&self) -> bool { self.warning_count.is_some() } -pub fn clear_warning_count(&mut self) { self.warning_count = ::std::option::Option::None } -pub fn set_warning_count(&mut self, v: i64) { self.warning_count = ::std::option::Option::Some(v); } -pub fn get_warning_count(&self) -> i64 { match self.warning_count { - Some(v) => v, - None => 0, - } } -} -impl ::protobuf::Clear for StreamResponse {fn clear(&mut self) { ::prost::Message::clear(self); } -} -impl ::protobuf::Message for StreamResponse {fn compute_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn get_cached_size(&self) -> u32 { ::prost::Message::encoded_len(self) as u32 } -fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } -fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { Self::descriptor_static() } -fn new() -> Self { Self::new_() } -fn write_to_with_cached_sizes(&self, _os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn default_instance() -> &'static StreamResponse { - ::lazy_static::lazy_static! { - static ref INSTANCE: StreamResponse = StreamResponse::new_(); - } - &*INSTANCE - } -fn is_initialized(&self) -> bool { true } -fn merge_from(&mut self, _is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { unimplemented!(); } -fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { unimplemented!(); } -fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { unimplemented!(); } -fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { - let mut buf = Vec::new(); - if let Err(_) = ::prost::Message::encode(self, &mut buf) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(buf) - } -fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { - if let Err(_) = ::prost::Message::merge(self, bytes) { - return Err(::protobuf::ProtobufError::WireError(::protobuf::error::WireError::Other)); - } - Ok(()) + pub fn new_() -> StreamResponse { + ::std::default::Default::default() + } + pub fn has_error(&self) -> bool { + self.error.is_some() + } + pub fn clear_error(&mut self) { + self.error = ::std::option::Option::None + } + pub fn set_error(&mut self, v: Error) { + self.error = ::std::option::Option::Some(v); + } + pub fn get_error(&self) -> &Error { + match self.error.as_ref() { + Some(v) => v, + None => ::default_instance(), + } + } + pub fn mut_error(&mut self) -> &mut Error { + if self.error.is_none() { + self.error = ::std::option::Option::Some(Error::default()); } + self.error.as_mut().unwrap() + } + pub fn take_error(&mut self) -> Error { + self.error.take().unwrap_or_else(Error::default) + } + pub fn has_data(&self) -> bool { + self.data.is_some() + } + pub fn clear_data(&mut self) { + self.data = ::std::option::Option::None + } + pub fn set_data(&mut self, v: std::vec::Vec) { + self.data = ::std::option::Option::Some(v); + } + pub fn get_data(&self) -> &[u8] { + match self.data.as_ref() { + Some(v) => v, + None => &[], + } + } + pub fn mut_data(&mut self) -> &mut std::vec::Vec { + if self.data.is_none() { + self.data = ::std::option::Option::Some(::std::vec::Vec::default()); + } + self.data.as_mut().unwrap() + } + pub fn take_data(&mut self) -> std::vec::Vec { + self.data.take().unwrap_or_else(::std::vec::Vec::new) + } + pub fn clear_warnings(&mut self) { + self.warnings.clear(); + } + pub fn set_warnings(&mut self, v: ::std::vec::Vec) { + self.warnings = v; + } + pub fn get_warnings(&self) -> &::std::vec::Vec { + &self.warnings + } + pub fn mut_warnings(&mut self) -> &mut ::std::vec::Vec { + &mut self.warnings + } + pub fn take_warnings(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.warnings, ::std::vec::Vec::new()) + } + pub fn clear_output_counts(&mut self) { + self.output_counts.clear(); + } + pub fn set_output_counts(&mut self, v: ::std::vec::Vec) { + self.output_counts = v; + } + pub fn get_output_counts(&self) -> &::std::vec::Vec { + &self.output_counts + } + pub fn mut_output_counts(&mut self) -> &mut ::std::vec::Vec { + &mut self.output_counts + } + pub fn take_output_counts(&mut self) -> ::std::vec::Vec { + ::std::mem::replace(&mut self.output_counts, ::std::vec::Vec::new()) + } + pub fn has_warning_count(&self) -> bool { + self.warning_count.is_some() + } + pub fn clear_warning_count(&mut self) { + self.warning_count = ::std::option::Option::None + } + pub fn set_warning_count(&mut self, v: i64) { + self.warning_count = ::std::option::Option::Some(v); + } + pub fn get_warning_count(&self) -> i64 { + match self.warning_count { + Some(v) => v, + None => 0, + } + } } -impl EncodeType { -pub fn values() -> &'static [Self] { -static VALUES: &'static [EncodeType] = &[ -EncodeType::TypeDefault, -EncodeType::TypeArrow, -]; -VALUES +impl ::protobuf::Clear for StreamResponse { + fn clear(&mut self) { + ::prost::Message::clear(self); + } } +impl ::protobuf::Message for StreamResponse { + fn compute_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn get_cached_size(&self) -> u32 { + ::prost::Message::encoded_len(self) as u32 + } + fn as_any(&self) -> &::std::any::Any { + self as &::std::any::Any + } + fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { + Self::descriptor_static() + } + fn new() -> Self { + Self::new_() + } + fn write_to_with_cached_sizes( + &self, + _os: &mut ::protobuf::CodedOutputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn default_instance() -> &'static StreamResponse { + ::lazy_static::lazy_static! { + static ref INSTANCE: StreamResponse = StreamResponse::new_(); + } + &*INSTANCE + } + fn is_initialized(&self) -> bool { + true + } + fn merge_from( + &mut self, + _is: &mut ::protobuf::CodedInputStream, + ) -> ::protobuf::ProtobufResult<()> { + unimplemented!(); + } + fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { + unimplemented!(); + } + fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { + unimplemented!(); + } + fn write_to_bytes(&self) -> ::protobuf::ProtobufResult> { + let mut buf = Vec::new(); + if let Err(_) = ::prost::Message::encode(self, &mut buf) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(buf) + } + fn merge_from_bytes(&mut self, bytes: &[u8]) -> ::protobuf::ProtobufResult<()> { + if let Err(_) = ::prost::Message::merge(self, bytes) { + return Err(::protobuf::ProtobufError::WireError( + ::protobuf::error::WireError::Other, + )); + } + Ok(()) + } +} +impl EncodeType { + pub fn values() -> &'static [Self] { + static VALUES: &'static [EncodeType] = &[EncodeType::TypeDefault, EncodeType::TypeArrow]; + VALUES + } } diff --git a/src/protobuf/analyze.rs b/src/protobuf/analyze.rs index 81671a9f1..f70841c8c 100644 --- a/src/protobuf/analyze.rs +++ b/src/protobuf/analyze.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -3423,7 +3423,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x20\x03(\x0b2\x12.tipb.CMSketchTopNR\x04topN\x12)\n\rdefault_value\x18\ \x03\x20\x01(\x04R\x0cdefaultValueB\x04\xc8\xde\x1f\0*,\n\x0bAnalyzeType\ \x12\r\n\tTypeIndex\x10\0\x12\x0e\n\nTypeColumn\x10\x01B%\n\x15com.pingc\ - ap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xc8\xe2\x1e\x01\xd0\xe2\x1e\x01\ + ap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xd0\xe2\x1e\x01\xc8\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/checksum.rs b/src/protobuf/checksum.rs index 77c7efa02..8c371866c 100644 --- a/src/protobuf/checksum.rs +++ b/src/protobuf/checksum.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -619,7 +619,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x08totalKvsB\x04\xc8\xde\x1f\0\x12%\n\x0btotal_bytes\x18\x03\x20\x01(\ \x04R\ntotalBytesB\x04\xc8\xde\x1f\0*&\n\x0eChecksumScanOn\x12\t\n\x05Ta\ ble\x10\0\x12\t\n\x05Index\x10\x01*\"\n\x11ChecksumAlgorithm\x12\r\n\tCr\ - c64_Xor\x10\0B%\n\x15com.pingcap.tidb.tipbP\x01\xc8\xe2\x1e\x01\xd0\xe2\ + c64_Xor\x10\0B%\n\x15com.pingcap.tidb.tipbP\x01\xd0\xe2\x1e\x01\xc8\xe2\ \x1e\x01\xe0\xe2\x1e\x01\ "; diff --git a/src/protobuf/executor.rs b/src/protobuf/executor.rs index 48aa073da..f319aaf47 100644 --- a/src/protobuf/executor.rs +++ b/src/protobuf/executor.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -2514,7 +2514,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ n\x10\0\x12\x11\n\rTypeIndexScan\x10\x01\x12\x11\n\rTypeSelection\x10\ \x02\x12\x13\n\x0fTypeAggregation\x10\x03\x12\x0c\n\x08TypeTopN\x10\x04\ \x12\r\n\tTypeLimit\x10\x05\x12\x11\n\rTypeStreamAgg\x10\x06B%\n\x15com.\ - pingcap.tidb.tipbP\x01\xd0\xe2\x1e\x01\xc8\xe2\x1e\x01\xe0\xe2\x1e\x01\ + pingcap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xc8\xe2\x1e\x01\xd0\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/expression.rs b/src/protobuf/expression.rs index 5e95fb7e8..4599598f7 100644 --- a/src/protobuf/expression.rs +++ b/src/protobuf/expression.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -1327,6 +1327,7 @@ pub enum ScalarFuncSig { RealIsNull = 3113, StringIsNull = 3114, TimeIsNull = 3115, + TimeIsNullOnNotNullCol = 3142, IntIsNull = 3116, JsonIsNull = 3117, BitAndSig = 3118, @@ -1821,6 +1822,7 @@ impl ::protobuf::ProtobufEnum for ScalarFuncSig { 3113 => ::std::option::Option::Some(ScalarFuncSig::RealIsNull), 3114 => ::std::option::Option::Some(ScalarFuncSig::StringIsNull), 3115 => ::std::option::Option::Some(ScalarFuncSig::TimeIsNull), + 3142 => ::std::option::Option::Some(ScalarFuncSig::TimeIsNullOnNotNullCol), 3116 => ::std::option::Option::Some(ScalarFuncSig::IntIsNull), 3117 => ::std::option::Option::Some(ScalarFuncSig::JsonIsNull), 3118 => ::std::option::Option::Some(ScalarFuncSig::BitAndSig), @@ -2312,6 +2314,7 @@ impl ::protobuf::ProtobufEnum for ScalarFuncSig { ScalarFuncSig::RealIsNull, ScalarFuncSig::StringIsNull, ScalarFuncSig::TimeIsNull, + ScalarFuncSig::TimeIsNullOnNotNullCol, ScalarFuncSig::IntIsNull, ScalarFuncSig::JsonIsNull, ScalarFuncSig::BitAndSig, @@ -2668,7 +2671,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ devSamp\x10\xc6\x17\x12\x0b\n\x06VarPop\x10\xc7\x17\x12\x0c\n\x07VarSamp\ \x10\xc8\x17\x12\r\n\x08Variance\x10\xc9\x17\x12\x11\n\x0cJsonArrayAgg\ \x10\xca\x17\x12\x12\n\rJsonObjectAgg\x10\xcb\x17\x12\x0f\n\nScalarFunc\ - \x10\x90N*\x94E\n\rScalarFuncSig\x12\x10\n\x0cCastIntAsInt\x10\0\x12\x11\ + \x10\x90N*\xb1E\n\rScalarFuncSig\x12\x10\n\x0cCastIntAsInt\x10\0\x12\x11\ \n\rCastIntAsReal\x10\x01\x12\x13\n\x0fCastIntAsString\x10\x02\x12\x14\n\ \x10CastIntAsDecimal\x10\x03\x12\x11\n\rCastIntAsTime\x10\x04\x12\x15\n\ \x11CastIntAsDuration\x10\x05\x12\x11\n\rCastIntAsJson\x10\x06\x12\x11\n\ @@ -2759,123 +2762,124 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \xa4\x18\x12\x13\n\x0eUnaryMinusReal\x10\xa5\x18\x12\x16\n\x11UnaryMinus\ Decimal\x10\xa6\x18\x12\x12\n\rDecimalIsNull\x10\xa7\x18\x12\x13\n\x0eDu\ rationIsNull\x10\xa8\x18\x12\x0f\n\nRealIsNull\x10\xa9\x18\x12\x11\n\x0c\ - StringIsNull\x10\xaa\x18\x12\x0f\n\nTimeIsNull\x10\xab\x18\x12\x0e\n\tIn\ - tIsNull\x10\xac\x18\x12\x0f\n\nJsonIsNull\x10\xad\x18\x12\x0e\n\tBitAndS\ - ig\x10\xae\x18\x12\r\n\x08BitOrSig\x10\xaf\x18\x12\x0e\n\tBitXorSig\x10\ - \xb0\x18\x12\x0e\n\tBitNegSig\x10\xb1\x18\x12\x0e\n\tIntIsTrue\x10\xb2\ - \x18\x12\x0f\n\nRealIsTrue\x10\xb3\x18\x12\x12\n\rDecimalIsTrue\x10\xb4\ - \x18\x12\x0f\n\nIntIsFalse\x10\xb5\x18\x12\x10\n\x0bRealIsFalse\x10\xb6\ - \x18\x12\x13\n\x0eDecimalIsFalse\x10\xb7\x18\x12\x0e\n\tLeftShift\x10\ - \xb9\x18\x12\x0f\n\nRightShift\x10\xba\x18\x12\r\n\x08BitCount\x10\xb8\ - \x18\x12\x13\n\x0eGetParamString\x10\xbb\x18\x12\x0b\n\x06GetVar\x10\xbc\ - \x18\x12\x0b\n\x06RowSig\x10\xbd\x18\x12\x0b\n\x06SetVar\x10\xbe\x18\x12\ - \x12\n\rValuesDecimal\x10\xbf\x18\x12\x13\n\x0eValuesDuration\x10\xc0\ - \x18\x12\x0e\n\tValuesInt\x10\xc1\x18\x12\x0f\n\nValuesJSON\x10\xc2\x18\ - \x12\x0f\n\nValuesReal\x10\xc3\x18\x12\x11\n\x0cValuesString\x10\xc4\x18\ - \x12\x0f\n\nValuesTime\x10\xc5\x18\x12\n\n\x05InInt\x10\xa1\x1f\x12\x0b\ - \n\x06InReal\x10\xa2\x1f\x12\x0e\n\tInDecimal\x10\xa3\x1f\x12\r\n\x08InS\ - tring\x10\xa4\x1f\x12\x0b\n\x06InTime\x10\xa5\x1f\x12\x0f\n\nInDuration\ - \x10\xa6\x1f\x12\x0b\n\x06InJson\x10\xa7\x1f\x12\x0e\n\tIfNullInt\x10\ - \x85\x20\x12\x0f\n\nIfNullReal\x10\x86\x20\x12\x12\n\rIfNullDecimal\x10\ - \x87\x20\x12\x11\n\x0cIfNullString\x10\x88\x20\x12\x0f\n\nIfNullTime\x10\ - \x89\x20\x12\x13\n\x0eIfNullDuration\x10\x8a\x20\x12\n\n\x05IfInt\x10\ - \x8b\x20\x12\x0b\n\x06IfReal\x10\x8c\x20\x12\x0e\n\tIfDecimal\x10\x8d\ - \x20\x12\r\n\x08IfString\x10\x8e\x20\x12\x0b\n\x06IfTime\x10\x8f\x20\x12\ - \x0f\n\nIfDuration\x10\x90\x20\x12\x0f\n\nIfNullJson\x10\x91\x20\x12\x0b\ - \n\x06IfJson\x10\x92\x20\x12\x10\n\x0bCaseWhenInt\x10\xf0\x20\x12\x11\n\ - \x0cCaseWhenReal\x10\xf1\x20\x12\x14\n\x0fCaseWhenDecimal\x10\xf2\x20\ - \x12\x13\n\x0eCaseWhenString\x10\xf3\x20\x12\x11\n\x0cCaseWhenTime\x10\ - \xf4\x20\x12\x15\n\x10CaseWhenDuration\x10\xf5\x20\x12\x11\n\x0cCaseWhen\ - Json\x10\xf6\x20\x12\x0f\n\nAesDecrypt\x10\x95#\x12\x0f\n\nAesEncrypt\ - \x10\x96#\x12\r\n\x08Compress\x10\x97#\x12\x08\n\x03MD5\x10\x98#\x12\r\n\ - \x08Password\x10\x99#\x12\x10\n\x0bRandomBytes\x10\x9a#\x12\t\n\x04SHA1\ - \x10\x9b#\x12\t\n\x04SHA2\x10\x9c#\x12\x0f\n\nUncompress\x10\x9d#\x12\ - \x17\n\x12UncompressedLength\x10\x9e#\x12\r\n\x08Database\x10\xa9#\x12\ - \x0e\n\tFoundRows\x10\xaa#\x12\x10\n\x0bCurrentUser\x10\xab#\x12\t\n\x04\ - User\x10\xac#\x12\x11\n\x0cConnectionID\x10\xad#\x12\x11\n\x0cLastInsert\ - ID\x10\xae#\x12\x17\n\x12LastInsertIDWithID\x10\xaf#\x12\x0c\n\x07Versio\ - n\x10\xb0#\x12\x10\n\x0bTiDBVersion\x10\xb1#\x12\r\n\x08RowCount\x10\xb2\ - #\x12\n\n\x05Sleep\x10\xc7#\x12\t\n\x04Lock\x10\xc8#\x12\x10\n\x0bReleas\ - eLock\x10\xc9#\x12\x14\n\x0fDecimalAnyValue\x10\xca#\x12\x15\n\x10Durati\ - onAnyValue\x10\xcb#\x12\x10\n\x0bIntAnyValue\x10\xcc#\x12\x11\n\x0cJSONA\ - nyValue\x10\xcd#\x12\x11\n\x0cRealAnyValue\x10\xce#\x12\x13\n\x0eStringA\ - nyValue\x10\xcf#\x12\x11\n\x0cTimeAnyValue\x10\xd0#\x12\r\n\x08InetAton\ - \x10\xd1#\x12\r\n\x08InetNtoa\x10\xd2#\x12\x0e\n\tInet6Aton\x10\xd3#\x12\ - \x0e\n\tInet6Ntoa\x10\xd4#\x12\x0b\n\x06IsIPv4\x10\xd5#\x12\x11\n\x0cIsI\ - Pv4Compat\x10\xd6#\x12\x11\n\x0cIsIPv4Mapped\x10\xd7#\x12\x0b\n\x06IsIPv\ - 6\x10\xd8#\x12\t\n\x04UUID\x10\xd9#\x12\x0c\n\x07LikeSig\x10\xd6!\x12\ - \x14\n\x0fRegexpBinarySig\x10\xd7!\x12\x0e\n\tRegexpSig\x10\xd8!\x12\x13\ - \n\x0eJsonExtractSig\x10\x89'\x12\x13\n\x0eJsonUnquoteSig\x10\x8a'\x12\ - \x10\n\x0bJsonTypeSig\x10\x8b'\x12\x0f\n\nJsonSetSig\x10\x8c'\x12\x12\n\ - \rJsonInsertSig\x10\x8d'\x12\x13\n\x0eJsonReplaceSig\x10\x8e'\x12\x12\n\ - \rJsonRemoveSig\x10\x8f'\x12\x11\n\x0cJsonMergeSig\x10\x90'\x12\x12\n\rJ\ - sonObjectSig\x10\x91'\x12\x11\n\x0cJsonArraySig\x10\x92'\x12\x15\n\x10Js\ - onValidJsonSig\x10\x93'\x12\x14\n\x0fJsonContainsSig\x10\x94'\x12\x17\n\ - \x12JsonArrayAppendSig\x10\x95'\x12\x17\n\x12JsonArrayInsertSig\x10\x96'\ - \x12\x16\n\x11JsonMergePatchSig\x10\x97'\x12\x19\n\x14JsonMergePreserveS\ - ig\x10\x98'\x12\x18\n\x13JsonContainsPathSig\x10\x99'\x12\x12\n\rJsonPre\ - ttySig\x10\x9a'\x12\x11\n\x0cJsonQuoteSig\x10\x9b'\x12\x12\n\rJsonSearch\ - Sig\x10\x9c'\x12\x17\n\x12JsonStorageSizeSig\x10\x9d'\x12\x11\n\x0cJsonD\ - epthSig\x10\x9e'\x12\x10\n\x0bJsonKeysSig\x10\x9f'\x12\x12\n\rJsonLength\ - Sig\x10\xa0'\x12\x15\n\x10JsonKeys2ArgsSig\x10\xa1'\x12\x17\n\x12JsonVal\ - idStringSig\x10\xa2'\x12\x12\n\rDateFormatSig\x10\xf1.\x12\x10\n\x0bDate\ - Literal\x10\xf2.\x12\r\n\x08DateDiff\x10\xf3.\x12\x11\n\x0cNullTimeDiff\ - \x10\xf4.\x12\x17\n\x12TimeStringTimeDiff\x10\xf5.\x12\x1b\n\x16Duration\ - StringTimeDiff\x10\xf6.\x12\x1d\n\x18DurationDurationTimeDiff\x10\xf7.\ - \x12\x17\n\x12StringTimeTimeDiff\x10\xf8.\x12\x1b\n\x16StringDurationTim\ - eDiff\x10\xf9.\x12\x19\n\x14StringStringTimeDiff\x10\xfa.\x12\x15\n\x10T\ - imeTimeTimeDiff\x10\xfb.\x12\t\n\x04Date\x10\xfc.\x12\t\n\x04Hour\x10\ - \xfd.\x12\x0b\n\x06Minute\x10\xfe.\x12\x0b\n\x06Second\x10\xff.\x12\x10\ - \n\x0bMicroSecond\x10\x80/\x12\n\n\x05Month\x10\x81/\x12\x0e\n\tMonthNam\ - e\x10\x82/\x12\x0f\n\nNowWithArg\x10\x83/\x12\x12\n\rNowWithoutArg\x10\ - \x84/\x12\x0c\n\x07DayName\x10\x85/\x12\x0f\n\nDayOfMonth\x10\x86/\x12\ - \x0e\n\tDayOfWeek\x10\x87/\x12\x0e\n\tDayOfYear\x10\x88/\x12\x11\n\x0cWe\ - ekWithMode\x10\x89/\x12\x14\n\x0fWeekWithoutMode\x10\x8a/\x12\x0c\n\x07W\ - eekDay\x10\x8b/\x12\x0f\n\nWeekOfYear\x10\x8c/\x12\t\n\x04Year\x10\x8d/\ - \x12\x15\n\x10YearWeekWithMode\x10\x8e/\x12\x18\n\x13YearWeekWithoutMode\ - \x10\x8f/\x12\x0e\n\tGetFormat\x10\x90/\x12\x13\n\x0eSysDateWithFsp\x10\ - \x91/\x12\x16\n\x11SysDateWithoutFsp\x10\x92/\x12\x10\n\x0bCurrentDate\ - \x10\x93/\x12\x14\n\x0fCurrentTime0Arg\x10\x94/\x12\x14\n\x0fCurrentTime\ - 1Arg\x10\x95/\x12\t\n\x04Time\x10\x96/\x12\x10\n\x0bTimeLiteral\x10\x97/\ - \x12\x0c\n\x07UTCDate\x10\x98/\x12\x18\n\x13UTCTimestampWithArg\x10\x99/\ - \x12\x1b\n\x16UTCTimestampWithoutArg\x10\x9a/\x12\x1b\n\x16AddDatetimeAn\ - dDuration\x10\x9b/\x12\x19\n\x14AddDatetimeAndString\x10\x9c/\x12\x18\n\ - \x13AddTimeDateTimeNull\x10\x9d/\x12\x19\n\x14AddStringAndDuration\x10\ - \x9e/\x12\x17\n\x12AddStringAndString\x10\x9f/\x12\x16\n\x11AddTimeStrin\ - gNull\x10\xa0/\x12\x1b\n\x16AddDurationAndDuration\x10\xa1/\x12\x19\n\ - \x14AddDurationAndString\x10\xa2/\x12\x18\n\x13AddTimeDurationNull\x10\ - \xa3/\x12\x17\n\x12AddDateAndDuration\x10\xa4/\x12\x15\n\x10AddDateAndSt\ - ring\x10\xa5/\x12\x1b\n\x16SubDatetimeAndDuration\x10\xa6/\x12\x19\n\x14\ - SubDatetimeAndString\x10\xa7/\x12\x18\n\x13SubTimeDateTimeNull\x10\xa8/\ - \x12\x19\n\x14SubStringAndDuration\x10\xa9/\x12\x17\n\x12SubStringAndStr\ - ing\x10\xaa/\x12\x16\n\x11SubTimeStringNull\x10\xab/\x12\x1b\n\x16SubDur\ - ationAndDuration\x10\xac/\x12\x19\n\x14SubDurationAndString\x10\xad/\x12\ - \x18\n\x13SubTimeDurationNull\x10\xae/\x12\x17\n\x12SubDateAndDuration\ - \x10\xaf/\x12\x15\n\x10SubDateAndString\x10\xb0/\x12\x19\n\x14UnixTimest\ - ampCurrent\x10\xb1/\x12\x15\n\x10UnixTimestampInt\x10\xb2/\x12\x15\n\x10\ - UnixTimestampDec\x10\xb3/\x12\x0e\n\tConvertTz\x10\xb4/\x12\r\n\x08MakeD\ - ate\x10\xb5/\x12\r\n\x08MakeTime\x10\xb6/\x12\x0e\n\tPeriodAdd\x10\xb7/\ - \x12\x0f\n\nPeriodDiff\x10\xb8/\x12\x0c\n\x07Quarter\x10\xb9/\x12\x0e\n\ - \tSecToTime\x10\xba/\x12\x0e\n\tTimeToSec\x10\xbb/\x12\x11\n\x0cTimestam\ - pAdd\x10\xbc/\x12\x0b\n\x06ToDays\x10\xbd/\x12\x0e\n\tToSeconds\x10\xbe/\ - \x12\x13\n\x0eUTCTimeWithArg\x10\xbf/\x12\x16\n\x11UTCTimeWithoutArg\x10\ - \xc0/\x12\x12\n\rTimestamp1Arg\x10\xc1/\x12\x13\n\x0eTimestamp2Args\x10\ - \xc2/\x12\x15\n\x10TimestampLiteral\x10\xc3/\x12\x0c\n\x07LastDay\x10\ - \xc4/\x12\x12\n\rStrToDateDate\x10\xc5/\x12\x16\n\x11StrToDateDatetime\ - \x10\xc6/\x12\x16\n\x11StrToDateDuration\x10\xc7/\x12\x15\n\x10FromUnixT\ - ime1Arg\x10\xc8/\x12\x15\n\x10FromUnixTime2Arg\x10\xc9/\x12\x14\n\x0fExt\ - ractDatetime\x10\xca/\x12\x14\n\x0fExtractDuration\x10\xcb/\x12\x18\n\ - \x13AddDateStringString\x10\xcc/\x12\x15\n\x10AddDateStringInt\x10\xcd/\ - \x12\x19\n\x14AddDateStringDecimal\x10\xce/\x12\x15\n\x10AddDateIntStrin\ - g\x10\xcf/\x12\x12\n\rAddDateIntInt\x10\xd0/\x12\x1a\n\x15AddDateDatetim\ - eString\x10\xd1/\x12\x17\n\x12AddDateDatetimeInt\x10\xd2/\x12\x18\n\x13S\ - ubDateStringString\x10\xd3/\x12\x15\n\x10SubDateStringInt\x10\xd4/\x12\ - \x19\n\x14SubDateStringDecimal\x10\xd5/\x12\x15\n\x10SubDateIntString\ - \x10\xd6/\x12\x12\n\rSubDateIntInt\x10\xd7/\x12\x1a\n\x15SubDateDatetime\ - String\x10\xd8/\x12\x17\n\x12SubDateDatetimeInt\x10\xd9/\x12\r\n\x08From\ - Days\x10\xda/\x12\x0f\n\nTimeFormat\x10\xdb/\x12\x12\n\rTimestampDiff\ - \x10\xdc/\x12\x0e\n\tBitLength\x10\xd96\x12\x08\n\x03Bin\x10\xda6\x12\n\ - \n\x05ASCII\x10\xdb6\x12\t\n\x04Char\x10\xdc6\x12\x0f\n\nCharLength\x10\ + StringIsNull\x10\xaa\x18\x12\x0f\n\nTimeIsNull\x10\xab\x18\x12\x1b\n\x16\ + TimeIsNullOnNotNullCol\x10\xc6\x18\x12\x0e\n\tIntIsNull\x10\xac\x18\x12\ + \x0f\n\nJsonIsNull\x10\xad\x18\x12\x0e\n\tBitAndSig\x10\xae\x18\x12\r\n\ + \x08BitOrSig\x10\xaf\x18\x12\x0e\n\tBitXorSig\x10\xb0\x18\x12\x0e\n\tBit\ + NegSig\x10\xb1\x18\x12\x0e\n\tIntIsTrue\x10\xb2\x18\x12\x0f\n\nRealIsTru\ + e\x10\xb3\x18\x12\x12\n\rDecimalIsTrue\x10\xb4\x18\x12\x0f\n\nIntIsFalse\ + \x10\xb5\x18\x12\x10\n\x0bRealIsFalse\x10\xb6\x18\x12\x13\n\x0eDecimalIs\ + False\x10\xb7\x18\x12\x0e\n\tLeftShift\x10\xb9\x18\x12\x0f\n\nRightShift\ + \x10\xba\x18\x12\r\n\x08BitCount\x10\xb8\x18\x12\x13\n\x0eGetParamString\ + \x10\xbb\x18\x12\x0b\n\x06GetVar\x10\xbc\x18\x12\x0b\n\x06RowSig\x10\xbd\ + \x18\x12\x0b\n\x06SetVar\x10\xbe\x18\x12\x12\n\rValuesDecimal\x10\xbf\ + \x18\x12\x13\n\x0eValuesDuration\x10\xc0\x18\x12\x0e\n\tValuesInt\x10\ + \xc1\x18\x12\x0f\n\nValuesJSON\x10\xc2\x18\x12\x0f\n\nValuesReal\x10\xc3\ + \x18\x12\x11\n\x0cValuesString\x10\xc4\x18\x12\x0f\n\nValuesTime\x10\xc5\ + \x18\x12\n\n\x05InInt\x10\xa1\x1f\x12\x0b\n\x06InReal\x10\xa2\x1f\x12\ + \x0e\n\tInDecimal\x10\xa3\x1f\x12\r\n\x08InString\x10\xa4\x1f\x12\x0b\n\ + \x06InTime\x10\xa5\x1f\x12\x0f\n\nInDuration\x10\xa6\x1f\x12\x0b\n\x06In\ + Json\x10\xa7\x1f\x12\x0e\n\tIfNullInt\x10\x85\x20\x12\x0f\n\nIfNullReal\ + \x10\x86\x20\x12\x12\n\rIfNullDecimal\x10\x87\x20\x12\x11\n\x0cIfNullStr\ + ing\x10\x88\x20\x12\x0f\n\nIfNullTime\x10\x89\x20\x12\x13\n\x0eIfNullDur\ + ation\x10\x8a\x20\x12\n\n\x05IfInt\x10\x8b\x20\x12\x0b\n\x06IfReal\x10\ + \x8c\x20\x12\x0e\n\tIfDecimal\x10\x8d\x20\x12\r\n\x08IfString\x10\x8e\ + \x20\x12\x0b\n\x06IfTime\x10\x8f\x20\x12\x0f\n\nIfDuration\x10\x90\x20\ + \x12\x0f\n\nIfNullJson\x10\x91\x20\x12\x0b\n\x06IfJson\x10\x92\x20\x12\ + \x10\n\x0bCaseWhenInt\x10\xf0\x20\x12\x11\n\x0cCaseWhenReal\x10\xf1\x20\ + \x12\x14\n\x0fCaseWhenDecimal\x10\xf2\x20\x12\x13\n\x0eCaseWhenString\ + \x10\xf3\x20\x12\x11\n\x0cCaseWhenTime\x10\xf4\x20\x12\x15\n\x10CaseWhen\ + Duration\x10\xf5\x20\x12\x11\n\x0cCaseWhenJson\x10\xf6\x20\x12\x0f\n\nAe\ + sDecrypt\x10\x95#\x12\x0f\n\nAesEncrypt\x10\x96#\x12\r\n\x08Compress\x10\ + \x97#\x12\x08\n\x03MD5\x10\x98#\x12\r\n\x08Password\x10\x99#\x12\x10\n\ + \x0bRandomBytes\x10\x9a#\x12\t\n\x04SHA1\x10\x9b#\x12\t\n\x04SHA2\x10\ + \x9c#\x12\x0f\n\nUncompress\x10\x9d#\x12\x17\n\x12UncompressedLength\x10\ + \x9e#\x12\r\n\x08Database\x10\xa9#\x12\x0e\n\tFoundRows\x10\xaa#\x12\x10\ + \n\x0bCurrentUser\x10\xab#\x12\t\n\x04User\x10\xac#\x12\x11\n\x0cConnect\ + ionID\x10\xad#\x12\x11\n\x0cLastInsertID\x10\xae#\x12\x17\n\x12LastInser\ + tIDWithID\x10\xaf#\x12\x0c\n\x07Version\x10\xb0#\x12\x10\n\x0bTiDBVersio\ + n\x10\xb1#\x12\r\n\x08RowCount\x10\xb2#\x12\n\n\x05Sleep\x10\xc7#\x12\t\ + \n\x04Lock\x10\xc8#\x12\x10\n\x0bReleaseLock\x10\xc9#\x12\x14\n\x0fDecim\ + alAnyValue\x10\xca#\x12\x15\n\x10DurationAnyValue\x10\xcb#\x12\x10\n\x0b\ + IntAnyValue\x10\xcc#\x12\x11\n\x0cJSONAnyValue\x10\xcd#\x12\x11\n\x0cRea\ + lAnyValue\x10\xce#\x12\x13\n\x0eStringAnyValue\x10\xcf#\x12\x11\n\x0cTim\ + eAnyValue\x10\xd0#\x12\r\n\x08InetAton\x10\xd1#\x12\r\n\x08InetNtoa\x10\ + \xd2#\x12\x0e\n\tInet6Aton\x10\xd3#\x12\x0e\n\tInet6Ntoa\x10\xd4#\x12\ + \x0b\n\x06IsIPv4\x10\xd5#\x12\x11\n\x0cIsIPv4Compat\x10\xd6#\x12\x11\n\ + \x0cIsIPv4Mapped\x10\xd7#\x12\x0b\n\x06IsIPv6\x10\xd8#\x12\t\n\x04UUID\ + \x10\xd9#\x12\x0c\n\x07LikeSig\x10\xd6!\x12\x14\n\x0fRegexpBinarySig\x10\ + \xd7!\x12\x0e\n\tRegexpSig\x10\xd8!\x12\x13\n\x0eJsonExtractSig\x10\x89'\ + \x12\x13\n\x0eJsonUnquoteSig\x10\x8a'\x12\x10\n\x0bJsonTypeSig\x10\x8b'\ + \x12\x0f\n\nJsonSetSig\x10\x8c'\x12\x12\n\rJsonInsertSig\x10\x8d'\x12\ + \x13\n\x0eJsonReplaceSig\x10\x8e'\x12\x12\n\rJsonRemoveSig\x10\x8f'\x12\ + \x11\n\x0cJsonMergeSig\x10\x90'\x12\x12\n\rJsonObjectSig\x10\x91'\x12\ + \x11\n\x0cJsonArraySig\x10\x92'\x12\x15\n\x10JsonValidJsonSig\x10\x93'\ + \x12\x14\n\x0fJsonContainsSig\x10\x94'\x12\x17\n\x12JsonArrayAppendSig\ + \x10\x95'\x12\x17\n\x12JsonArrayInsertSig\x10\x96'\x12\x16\n\x11JsonMerg\ + ePatchSig\x10\x97'\x12\x19\n\x14JsonMergePreserveSig\x10\x98'\x12\x18\n\ + \x13JsonContainsPathSig\x10\x99'\x12\x12\n\rJsonPrettySig\x10\x9a'\x12\ + \x11\n\x0cJsonQuoteSig\x10\x9b'\x12\x12\n\rJsonSearchSig\x10\x9c'\x12\ + \x17\n\x12JsonStorageSizeSig\x10\x9d'\x12\x11\n\x0cJsonDepthSig\x10\x9e'\ + \x12\x10\n\x0bJsonKeysSig\x10\x9f'\x12\x12\n\rJsonLengthSig\x10\xa0'\x12\ + \x15\n\x10JsonKeys2ArgsSig\x10\xa1'\x12\x17\n\x12JsonValidStringSig\x10\ + \xa2'\x12\x12\n\rDateFormatSig\x10\xf1.\x12\x10\n\x0bDateLiteral\x10\xf2\ + .\x12\r\n\x08DateDiff\x10\xf3.\x12\x11\n\x0cNullTimeDiff\x10\xf4.\x12\ + \x17\n\x12TimeStringTimeDiff\x10\xf5.\x12\x1b\n\x16DurationStringTimeDif\ + f\x10\xf6.\x12\x1d\n\x18DurationDurationTimeDiff\x10\xf7.\x12\x17\n\x12S\ + tringTimeTimeDiff\x10\xf8.\x12\x1b\n\x16StringDurationTimeDiff\x10\xf9.\ + \x12\x19\n\x14StringStringTimeDiff\x10\xfa.\x12\x15\n\x10TimeTimeTimeDif\ + f\x10\xfb.\x12\t\n\x04Date\x10\xfc.\x12\t\n\x04Hour\x10\xfd.\x12\x0b\n\ + \x06Minute\x10\xfe.\x12\x0b\n\x06Second\x10\xff.\x12\x10\n\x0bMicroSecon\ + d\x10\x80/\x12\n\n\x05Month\x10\x81/\x12\x0e\n\tMonthName\x10\x82/\x12\ + \x0f\n\nNowWithArg\x10\x83/\x12\x12\n\rNowWithoutArg\x10\x84/\x12\x0c\n\ + \x07DayName\x10\x85/\x12\x0f\n\nDayOfMonth\x10\x86/\x12\x0e\n\tDayOfWeek\ + \x10\x87/\x12\x0e\n\tDayOfYear\x10\x88/\x12\x11\n\x0cWeekWithMode\x10\ + \x89/\x12\x14\n\x0fWeekWithoutMode\x10\x8a/\x12\x0c\n\x07WeekDay\x10\x8b\ + /\x12\x0f\n\nWeekOfYear\x10\x8c/\x12\t\n\x04Year\x10\x8d/\x12\x15\n\x10Y\ + earWeekWithMode\x10\x8e/\x12\x18\n\x13YearWeekWithoutMode\x10\x8f/\x12\ + \x0e\n\tGetFormat\x10\x90/\x12\x13\n\x0eSysDateWithFsp\x10\x91/\x12\x16\ + \n\x11SysDateWithoutFsp\x10\x92/\x12\x10\n\x0bCurrentDate\x10\x93/\x12\ + \x14\n\x0fCurrentTime0Arg\x10\x94/\x12\x14\n\x0fCurrentTime1Arg\x10\x95/\ + \x12\t\n\x04Time\x10\x96/\x12\x10\n\x0bTimeLiteral\x10\x97/\x12\x0c\n\ + \x07UTCDate\x10\x98/\x12\x18\n\x13UTCTimestampWithArg\x10\x99/\x12\x1b\n\ + \x16UTCTimestampWithoutArg\x10\x9a/\x12\x1b\n\x16AddDatetimeAndDuration\ + \x10\x9b/\x12\x19\n\x14AddDatetimeAndString\x10\x9c/\x12\x18\n\x13AddTim\ + eDateTimeNull\x10\x9d/\x12\x19\n\x14AddStringAndDuration\x10\x9e/\x12\ + \x17\n\x12AddStringAndString\x10\x9f/\x12\x16\n\x11AddTimeStringNull\x10\ + \xa0/\x12\x1b\n\x16AddDurationAndDuration\x10\xa1/\x12\x19\n\x14AddDurat\ + ionAndString\x10\xa2/\x12\x18\n\x13AddTimeDurationNull\x10\xa3/\x12\x17\ + \n\x12AddDateAndDuration\x10\xa4/\x12\x15\n\x10AddDateAndString\x10\xa5/\ + \x12\x1b\n\x16SubDatetimeAndDuration\x10\xa6/\x12\x19\n\x14SubDatetimeAn\ + dString\x10\xa7/\x12\x18\n\x13SubTimeDateTimeNull\x10\xa8/\x12\x19\n\x14\ + SubStringAndDuration\x10\xa9/\x12\x17\n\x12SubStringAndString\x10\xaa/\ + \x12\x16\n\x11SubTimeStringNull\x10\xab/\x12\x1b\n\x16SubDurationAndDura\ + tion\x10\xac/\x12\x19\n\x14SubDurationAndString\x10\xad/\x12\x18\n\x13Su\ + bTimeDurationNull\x10\xae/\x12\x17\n\x12SubDateAndDuration\x10\xaf/\x12\ + \x15\n\x10SubDateAndString\x10\xb0/\x12\x19\n\x14UnixTimestampCurrent\ + \x10\xb1/\x12\x15\n\x10UnixTimestampInt\x10\xb2/\x12\x15\n\x10UnixTimest\ + ampDec\x10\xb3/\x12\x0e\n\tConvertTz\x10\xb4/\x12\r\n\x08MakeDate\x10\ + \xb5/\x12\r\n\x08MakeTime\x10\xb6/\x12\x0e\n\tPeriodAdd\x10\xb7/\x12\x0f\ + \n\nPeriodDiff\x10\xb8/\x12\x0c\n\x07Quarter\x10\xb9/\x12\x0e\n\tSecToTi\ + me\x10\xba/\x12\x0e\n\tTimeToSec\x10\xbb/\x12\x11\n\x0cTimestampAdd\x10\ + \xbc/\x12\x0b\n\x06ToDays\x10\xbd/\x12\x0e\n\tToSeconds\x10\xbe/\x12\x13\ + \n\x0eUTCTimeWithArg\x10\xbf/\x12\x16\n\x11UTCTimeWithoutArg\x10\xc0/\ + \x12\x12\n\rTimestamp1Arg\x10\xc1/\x12\x13\n\x0eTimestamp2Args\x10\xc2/\ + \x12\x15\n\x10TimestampLiteral\x10\xc3/\x12\x0c\n\x07LastDay\x10\xc4/\ + \x12\x12\n\rStrToDateDate\x10\xc5/\x12\x16\n\x11StrToDateDatetime\x10\ + \xc6/\x12\x16\n\x11StrToDateDuration\x10\xc7/\x12\x15\n\x10FromUnixTime1\ + Arg\x10\xc8/\x12\x15\n\x10FromUnixTime2Arg\x10\xc9/\x12\x14\n\x0fExtract\ + Datetime\x10\xca/\x12\x14\n\x0fExtractDuration\x10\xcb/\x12\x18\n\x13Add\ + DateStringString\x10\xcc/\x12\x15\n\x10AddDateStringInt\x10\xcd/\x12\x19\ + \n\x14AddDateStringDecimal\x10\xce/\x12\x15\n\x10AddDateIntString\x10\ + \xcf/\x12\x12\n\rAddDateIntInt\x10\xd0/\x12\x1a\n\x15AddDateDatetimeStri\ + ng\x10\xd1/\x12\x17\n\x12AddDateDatetimeInt\x10\xd2/\x12\x18\n\x13SubDat\ + eStringString\x10\xd3/\x12\x15\n\x10SubDateStringInt\x10\xd4/\x12\x19\n\ + \x14SubDateStringDecimal\x10\xd5/\x12\x15\n\x10SubDateIntString\x10\xd6/\ + \x12\x12\n\rSubDateIntInt\x10\xd7/\x12\x1a\n\x15SubDateDatetimeString\ + \x10\xd8/\x12\x17\n\x12SubDateDatetimeInt\x10\xd9/\x12\r\n\x08FromDays\ + \x10\xda/\x12\x0f\n\nTimeFormat\x10\xdb/\x12\x12\n\rTimestampDiff\x10\ + \xdc/\x12\x0e\n\tBitLength\x10\xd96\x12\x08\n\x03Bin\x10\xda6\x12\n\n\ + \x05ASCII\x10\xdb6\x12\t\n\x04Char\x10\xdc6\x12\x0f\n\nCharLength\x10\ \xdd6\x12\x0b\n\x06Concat\x10\xde6\x12\r\n\x08ConcatWS\x10\xdf6\x12\x0c\ \n\x07Convert\x10\xe06\x12\x08\n\x03Elt\x10\xe16\x12\x12\n\rExportSet3Ar\ g\x10\xe26\x12\x12\n\rExportSet4Arg\x10\xe36\x12\x12\n\rExportSet5Arg\ @@ -2902,7 +2906,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x12\r\n\x08ToBase64\x10\x927\x12\r\n\x08Trim1Arg\x10\x937\x12\x0e\n\tTr\ im2Args\x10\x947\x12\x0e\n\tTrim3Args\x10\x957\x12\n\n\x05UnHex\x10\x967\ \x12\n\n\x05Upper\x10\x977B%\n\x15com.pingcap.tidb.tipbP\x01\xc8\xe2\x1e\ - \x01\xd0\xe2\x1e\x01\xe0\xe2\x1e\x01\ + \x01\xe0\xe2\x1e\x01\xd0\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/schema.rs b/src/protobuf/schema.rs index 67ff686b0..8a50b7cf0 100644 --- a/src/protobuf/schema.rs +++ b/src/protobuf/schema.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 diff --git a/src/protobuf/select.rs b/src/protobuf/select.rs index b9107bfd2..6a4e509de 100644 --- a/src/protobuf/select.rs +++ b/src/protobuf/select.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.5.0. Do not edit +// This file is generated by rust-protobuf 2.6.1. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -2428,8 +2428,8 @@ static file_descriptor_proto_data: &'static [u8] = b"\ ub.com/pingcap/tipb/sharedbytes.SharedBytes\x12O\n\x13execution_summarie\ s\x18\x08\x20\x03(\x0b2\x1e.tipb.ExecutorExecutionSummaryR\x12executionS\ ummaries\"\x8f\x01\n\x05Chunk\x12T\n\trows_data\x18\x03\x20\x01(\x0cR\ - \x08rowsDataB7\xda\xde\x1f/github.com/pingcap/tipb/sharedbytes.SharedByt\ - es\xc8\xde\x1f\0\x120\n\trows_meta\x18\x04\x20\x03(\x0b2\r.tipb.RowMetaR\ + \x08rowsDataB7\xc8\xde\x1f\0\xda\xde\x1f/github.com/pingcap/tipb/sharedb\ + ytes.SharedBytes\x120\n\trows_meta\x18\x04\x20\x03(\x0b2\r.tipb.RowMetaR\ \x08rowsMetaB\x04\xc8\xde\x1f\0\"E\n\x07RowMeta\x12\x1c\n\x06handle\x18\ \x01\x20\x01(\x03R\x06handleB\x04\xc8\xde\x1f\0\x12\x1c\n\x06length\x18\ \x02\x20\x01(\x03R\x06lengthB\x04\xc8\xde\x1f\0\"\xec\x03\n\nDAGRequest\ @@ -2451,8 +2451,8 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x0b2\x0b.tipb.ErrorR\x08warnings\x12#\n\routput_counts\x18\x05\x20\x03(\ \x03R\x0coutputCounts\x12#\n\rwarning_count\x18\x06\x20\x01(\x03R\x0cwar\ ningCount*,\n\nEncodeType\x12\x0f\n\x0bTypeDefault\x10\0\x12\r\n\tTypeAr\ - row\x10\x01B%\n\x15com.pingcap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xc8\xe2\ - \x1e\x01\xd0\xe2\x1e\x01\ + row\x10\x01B%\n\x15com.pingcap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xd0\xe2\ + \x1e\x01\xc8\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { From f02cba94529a4da17f96b8a3af02a58740f32496 Mon Sep 17 00:00:00 2001 From: qw4990 Date: Wed, 12 Jun 2019 13:04:26 +0800 Subject: [PATCH 2/3] regen --- Cargo.toml | 2 +- src/protobuf/analyze.rs | 4 ++-- src/protobuf/checksum.rs | 6 +++--- src/protobuf/executor.rs | 2 +- src/protobuf/expression.rs | 6 +++--- src/protobuf/schema.rs | 2 +- src/protobuf/select.rs | 6 +++--- 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a19b526ef..c09678bc3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ gen = [] name = "tipb" [dependencies] -protobuf = "2.1" +protobuf = "2.5.0" prost = { version = "0.5", optional = true } prost-derive = { version = "0.5", optional = true } bytes = { version = "0.4", optional = true } diff --git a/src/protobuf/analyze.rs b/src/protobuf/analyze.rs index f70841c8c..b9ff3c978 100644 --- a/src/protobuf/analyze.rs +++ b/src/protobuf/analyze.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -3423,7 +3423,7 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x20\x03(\x0b2\x12.tipb.CMSketchTopNR\x04topN\x12)\n\rdefault_value\x18\ \x03\x20\x01(\x04R\x0cdefaultValueB\x04\xc8\xde\x1f\0*,\n\x0bAnalyzeType\ \x12\r\n\tTypeIndex\x10\0\x12\x0e\n\nTypeColumn\x10\x01B%\n\x15com.pingc\ - ap.tidb.tipbP\x01\xe0\xe2\x1e\x01\xd0\xe2\x1e\x01\xc8\xe2\x1e\x01\ + ap.tidb.tipbP\x01\xd0\xe2\x1e\x01\xe0\xe2\x1e\x01\xc8\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/checksum.rs b/src/protobuf/checksum.rs index 8c371866c..e690f35ba 100644 --- a/src/protobuf/checksum.rs +++ b/src/protobuf/checksum.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -619,8 +619,8 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x08totalKvsB\x04\xc8\xde\x1f\0\x12%\n\x0btotal_bytes\x18\x03\x20\x01(\ \x04R\ntotalBytesB\x04\xc8\xde\x1f\0*&\n\x0eChecksumScanOn\x12\t\n\x05Ta\ ble\x10\0\x12\t\n\x05Index\x10\x01*\"\n\x11ChecksumAlgorithm\x12\r\n\tCr\ - c64_Xor\x10\0B%\n\x15com.pingcap.tidb.tipbP\x01\xd0\xe2\x1e\x01\xc8\xe2\ - \x1e\x01\xe0\xe2\x1e\x01\ + c64_Xor\x10\0B%\n\x15com.pingcap.tidb.tipbP\x01\xc8\xe2\x1e\x01\xe0\xe2\ + \x1e\x01\xd0\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/executor.rs b/src/protobuf/executor.rs index f319aaf47..3e944f0ee 100644 --- a/src/protobuf/executor.rs +++ b/src/protobuf/executor.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 diff --git a/src/protobuf/expression.rs b/src/protobuf/expression.rs index 4599598f7..f5cacaa14 100644 --- a/src/protobuf/expression.rs +++ b/src/protobuf/expression.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -2905,8 +2905,8 @@ static file_descriptor_proto_data: &'static [u8] = b"\ \x14SubstringBinary3Args\x10\x907\x12\x13\n\x0eSubstringIndex\x10\x917\ \x12\r\n\x08ToBase64\x10\x927\x12\r\n\x08Trim1Arg\x10\x937\x12\x0e\n\tTr\ im2Args\x10\x947\x12\x0e\n\tTrim3Args\x10\x957\x12\n\n\x05UnHex\x10\x967\ - \x12\n\n\x05Upper\x10\x977B%\n\x15com.pingcap.tidb.tipbP\x01\xc8\xe2\x1e\ - \x01\xe0\xe2\x1e\x01\xd0\xe2\x1e\x01\ + \x12\n\n\x05Upper\x10\x977B%\n\x15com.pingcap.tidb.tipbP\x01\xe0\xe2\x1e\ + \x01\xd0\xe2\x1e\x01\xc8\xe2\x1e\x01\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { diff --git a/src/protobuf/schema.rs b/src/protobuf/schema.rs index 8a50b7cf0..67ff686b0 100644 --- a/src/protobuf/schema.rs +++ b/src/protobuf/schema.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 diff --git a/src/protobuf/select.rs b/src/protobuf/select.rs index 6a4e509de..20890a6cf 100644 --- a/src/protobuf/select.rs +++ b/src/protobuf/select.rs @@ -1,4 +1,4 @@ -// This file is generated by rust-protobuf 2.6.1. Do not edit +// This file is generated by rust-protobuf 2.5.0. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 @@ -2428,8 +2428,8 @@ static file_descriptor_proto_data: &'static [u8] = b"\ ub.com/pingcap/tipb/sharedbytes.SharedBytes\x12O\n\x13execution_summarie\ s\x18\x08\x20\x03(\x0b2\x1e.tipb.ExecutorExecutionSummaryR\x12executionS\ ummaries\"\x8f\x01\n\x05Chunk\x12T\n\trows_data\x18\x03\x20\x01(\x0cR\ - \x08rowsDataB7\xc8\xde\x1f\0\xda\xde\x1f/github.com/pingcap/tipb/sharedb\ - ytes.SharedBytes\x120\n\trows_meta\x18\x04\x20\x03(\x0b2\r.tipb.RowMetaR\ + \x08rowsDataB7\xda\xde\x1f/github.com/pingcap/tipb/sharedbytes.SharedByt\ + es\xc8\xde\x1f\0\x120\n\trows_meta\x18\x04\x20\x03(\x0b2\r.tipb.RowMetaR\ \x08rowsMetaB\x04\xc8\xde\x1f\0\"E\n\x07RowMeta\x12\x1c\n\x06handle\x18\ \x01\x20\x01(\x03R\x06handleB\x04\xc8\xde\x1f\0\x12\x1c\n\x06length\x18\ \x02\x20\x01(\x03R\x06lengthB\x04\xc8\xde\x1f\0\"\xec\x03\n\nDAGRequest\ From c4641a9de7654f317e7c473d9cc2240406784e59 Mon Sep 17 00:00:00 2001 From: qw4990 Date: Wed, 12 Jun 2019 13:05:16 +0800 Subject: [PATCH 3/3] update cargo --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index c09678bc3..a19b526ef 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,7 +13,7 @@ gen = [] name = "tipb" [dependencies] -protobuf = "2.5.0" +protobuf = "2.1" prost = { version = "0.5", optional = true } prost-derive = { version = "0.5", optional = true } bytes = { version = "0.4", optional = true }