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

Distinguish the dsl and expr in proxy and query node (#5118) 

Pass a parameter `IsExpr` from proxy to query node, so query 
node can create search plan according to the variable `IsExpr`.
It makes `segcore` unnecessary to distinguish `dsl` or `expr`
using dynamic exception. When `IsExpr` is set to true, query
node will call `CreatePlanByExpr` according to the passed
information about expression. Otherwise query node will keep
still to use `CreatePlan` according to the `dsl` information. At
the same time, this pr adds some unittests to `CreatePlanByExpr`,
these unittests translate already exist case with `dsl` to case with
`expr`.

Signed-off-by: dragondriver <jiquan.long@zilliz.com>
pull/5126/head
dragondriver 2021-05-07 15:20:47 +08:00 committed by GitHub
parent eed04f6c0f
commit e5d4963ba0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 1439 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
internal/core/src/query/Plan.cpp
View File

@ -318,19 +318,19 @@ ParsePlaceholderGroup(const Plan* plan, const std::string& blob) {
std::unique_ptr<Plan>
CreatePlan(const Schema& schema, const std::string& dsl_str) {
Json dsl;
try {
dsl = json::parse(dsl_str);
} catch (std::exception& e) {
// assume protobuf text format
proto::plan::PlanNode plan_node;
auto ok = google::protobuf::TextFormat::ParseFromString(dsl_str, &plan_node);
AssertInfo(ok, "Failed to parse");
return ProtoParser(schema).CreatePlan(plan_node);
}
dsl = json::parse(dsl_str);
auto plan = Parser(schema).CreatePlanImpl(dsl);
return plan;
}
std::unique_ptr<Plan>
CreatePlanByExpr(const Schema& schema, const std::string& serialized_expr_plan) {
proto::plan::PlanNode plan_node;
auto ok = google::protobuf::TextFormat::ParseFromString(serialized_expr_plan, &plan_node);
AssertInfo(ok, "Failed to parse");
return ProtoParser(schema).CreatePlan(plan_node);
}
std::vector<ExprPtr>
Parser::ParseItemList(const Json& body) {
std::vector<ExprPtr> results;

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

@ -25,6 +25,9 @@ struct PlaceholderGroup;
std::unique_ptr<Plan>
CreatePlan(const Schema& schema, const std::string& dsl);
std::unique_ptr<Plan>
CreatePlanByExpr(const Schema& schema, const std::string& serialized_expr_plan);
std::unique_ptr<PlaceholderGroup>
ParsePlaceholderGroup(const Plan* plan, const std::string& placeholder_group_blob);

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

@ -81,7 +81,6 @@ ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) {
// TODO: add more buffs
Assert(plan_node_proto.has_vector_anns());
auto& anns_proto = plan_node_proto.vector_anns();
AssertInfo(anns_proto.is_binary() == false, "unimplemented");
auto expr_opt = [&]() -> std::optional<ExprPtr> {
if (!anns_proto.has_predicates()) {
return std::nullopt;

28
internal/core/src/segcore/plan_c.cpp
View File

@ -41,6 +41,34 @@ CreatePlan(CCollection c_col, const char* dsl, CPlan* res_plan) {
}
}
CStatus
CreatePlanByExpr(CCollection c_col, const char* serialized_expr_plan, CPlan* res_plan) {
auto col = (milvus::segcore::Collection*)c_col;
try {
auto res = milvus::query::CreatePlanByExpr(*col->get_schema(), serialized_expr_plan);
auto status = CStatus();
status.error_code = Success;
status.error_msg = "";
auto plan = (CPlan)res.release();
*res_plan = plan;
return status;
} catch (milvus::SegcoreError& e) {
auto status = CStatus();
status.error_code = e.get_error_code();
status.error_msg = strdup(e.what());
*res_plan = nullptr;
return status;
} catch (std::exception& e) {
auto status = CStatus();
status.error_code = UnexpectedError;
status.error_msg = strdup(e.what());
*res_plan = nullptr;
return status;
}
}
CStatus
ParsePlaceholderGroup(CPlan c_plan,
void* placeholder_group_blob,

3
internal/core/src/segcore/plan_c.h
View File

@ -24,6 +24,9 @@ typedef void* CPlaceholderGroup;
CStatus
CreatePlan(CCollection col, const char* dsl, CPlan* res_plan);
CStatus
CreatePlanByExpr(CCollection col, const char* serialized_expr_plan, CPlan* res_plan);
CStatus
ParsePlaceholderGroup(CPlan plan,
void* placeholder_group_blob,

1188
internal/core/unittest/test_c_api.cpp
View File

File diff suppressed because it is too large Load Diff

1
internal/msgstream/mem_msgstream_test.go
View File

@ -36,7 +36,6 @@ func mGetTsMsg(msgType MsgType, reqID UniqueID, hashValue uint32) TsMsg {
Timestamp: 11,
SourceID: reqID,
},
Query: nil,
ResultChannelID: "0",
}
searchMsg := &SearchMsg{

1
internal/msgstream/mq_msgstream_test.go
View File

@ -111,7 +111,6 @@ func getTsMsg(msgType MsgType, reqID UniqueID, hashValue uint32) TsMsg {
Timestamp: 11,
SourceID: reqID,
},
Query: nil,
ResultChannelID: "0",
}
searchMsg := &SearchMsg{

3
internal/proto/internal.proto
View File

@ -127,7 +127,8 @@ message SearchRequest {
string dsl = 6;
// serialized `PlaceholderGroup`
bytes placeholder_group = 7;
common.Blob query = 8;
common.DslType dsl_type = 8;
string serialized_expr_plan = 9;
}
message SearchResults {

220
internal/proto/internalpb/internal.pb.go
View File

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

39
internal/proxynode/plan_parser_test.go
View File

@ -97,3 +97,42 @@ func TestExternalParser(t *testing.T) {
println(ast.Node.Location().Column)
}
func TestExprPlan_Str(t *testing.T) {
fields := []*schemapb.FieldSchema{
{FieldID: 100, Name: "fakevec", DataType: schemapb.DataType_FloatVector},
{FieldID: 101, Name: "age", DataType: schemapb.DataType_Int64},
}
schema := &schemapb.CollectionSchema{
Name: "default-collection",
Description: "",
AutoID: true,
Fields: fields,
}
queryInfo := &planpb.QueryInfo{
Topk: 10,
MetricType: "L2",
SearchParams: "{\"nprobe\": 10}",
}
// without filter
planProto, err := CreateQueryPlan(schema, nil, "fakevec", queryInfo)
assert.Nil(t, err)
dbgStr := proto.MarshalTextString(planProto)
println(dbgStr)
exprStrs := []string{
"age >= 420000 && age < 420010", // range
"age == 420000 || age == 420001 || age == 420002 || age == 420003 || age == 420004", // term
}
for offset, exprStr := range exprStrs {
fmt.Printf("case %d: %s\n", offset, exprStr)
planProto, err := CreateQueryPlan(schema, &exprStr, "fakevec", queryInfo)
assert.Nil(t, err)
dbgStr := proto.MarshalTextString(planProto)
println(dbgStr)
}
}

26
internal/proxynode/task.go
View File

@ -563,8 +563,6 @@ func (st *SearchTask) PreExecute(ctx context.Context) error {
}
st.Base.MsgType = commonpb.MsgType_Search
var dsl string
dsl = st.query.Dsl
if st.query.GetDslType() == commonpb.DslType_BoolExprV1 {
schema, err := globalMetaCache.GetCollectionSchema(ctx, collectionName)
if err != nil { // err is not nil if collection not exists
@ -606,26 +604,18 @@ func (st *SearchTask) PreExecute(ctx context.Context) error {
return errors.New("invalid expression: " + st.query.Dsl)
}
dsl = proto.MarshalTextString(plan)
st.query.Dsl = dsl
st.SearchRequest.DslType = commonpb.DslType_BoolExprV1
st.SearchRequest.SerializedExprPlan = proto.MarshalTextString(plan)
}
queryBytes, err := proto.Marshal(st.query)
if err != nil {
return err
}
st.Query = &commonpb.Blob{
Value: queryBytes,
}
st.ResultChannelID = Params.SearchResultChannelNames[0]
st.DbID = 0 // todo
st.SearchRequest.ResultChannelID = Params.SearchResultChannelNames[0]
st.SearchRequest.DbID = 0 // todo
collectionID, err := globalMetaCache.GetCollectionID(ctx, collectionName)
if err != nil { // err is not nil if collection not exists
return err
}
st.CollectionID = collectionID
st.PartitionIDs = make([]UniqueID, 0)
st.SearchRequest.CollectionID = collectionID
st.SearchRequest.PartitionIDs = make([]UniqueID, 0)
partitionsMap, err := globalMetaCache.GetPartitions(ctx, collectionName)
if err != nil {
@ -655,8 +645,8 @@ func (st *SearchTask) PreExecute(ctx context.Context) error {
}
}
st.Dsl = dsl
st.PlaceholderGroup = st.query.PlaceholderGroup
st.SearchRequest.Dsl = st.query.Dsl
st.SearchRequest.PlaceholderGroup = st.query.PlaceholderGroup
return nil
}

15
internal/querynode/plan.go
View File

@ -45,6 +45,21 @@ func createPlan(col Collection, dsl string) (*Plan, error) {
return newPlan, nil
}
func createPlanByExpr(col Collection, expr string) (*Plan, error) {
cExpr := C.CString(expr)
defer C.free(unsafe.Pointer(cExpr))
var cPlan C.CPlan
status := C.CreatePlanByExpr(col.collectionPtr, cExpr, &cPlan)
err1 := HandleCStatus(&status, "Create Plan by expr failed")
if err1 != nil {
return nil, err1
}
var newPlan = &Plan{cPlan: cPlan}
return newPlan, nil
}
func (plan *Plan) getTopK() int64 {
topK := C.GetTopK(plan.cPlan)
return int64(topK)

28
internal/querynode/search_collection.go
View File

@ -276,10 +276,19 @@ func (s *searchCollection) search(searchMsg *msgstream.SearchMsg) error {
if err != nil {
return err
}
dsl := searchMsg.Dsl
plan, err := createPlan(*collection, dsl)
if err != nil {
return err
var plan *Plan
if searchMsg.GetDslType() == commonpb.DslType_BoolExprV1 {
expr := searchMsg.SerializedExprPlan
plan, err = createPlanByExpr(*collection, expr)
if err != nil {
return err
}
} else {
dsl := searchMsg.Dsl
plan, err = createPlan(*collection, dsl)
if err != nil {
return err
}
}
searchRequestBlob := searchMsg.PlaceholderGroup
searchReq, err := parseSearchRequest(plan, searchRequestBlob)
@ -315,14 +324,21 @@ func (s *searchCollection) search(searchMsg *msgstream.SearchMsg) error {
searchPartitionIDs = partitionIDsInQuery
}
sp.LogFields(oplog.String("statistical time", "stats start"), oplog.Object("nq", queryNum), oplog.Object("dsl", dsl))
if searchMsg.GetDslType() == commonpb.DslType_BoolExprV1 {
sp.LogFields(oplog.String("statistical time", "stats start"),
oplog.Object("nq", queryNum),
oplog.Object("expr", searchMsg.SerializedExprPlan))
} else {
sp.LogFields(oplog.String("statistical time", "stats start"),
oplog.Object("nq", queryNum),
oplog.Object("dsl", searchMsg.Dsl))
}
for _, partitionID := range searchPartitionIDs {
segmentIDs, err := s.replica.getSegmentIDs(partitionID)
if err != nil {
return err
}
for _, segmentID := range segmentIDs {
//log.Debug("dsl = ", dsl)
segment, err := s.replica.getSegmentByID(segmentID)
if err != nil {
return err

19
internal/querynode/search_service_test.go
View File

@ -101,19 +101,6 @@ func sendSearchRequest(ctx context.Context, DIM int) error {
return err
}
// generate searchRequest
searchReq := milvuspb.SearchRequest{
Dsl: dslString,
PlaceholderGroup: placeGroupByte,
}
searchReqBytes, err := proto.Marshal(&searchReq)
if err != nil {
return err
}
blob := commonpb.Blob{
Value: searchReqBytes,
}
// generate searchMsg
searchMsg := &msgstream.SearchMsg{
BaseMsg: msgstream.BaseMsg{
@ -126,8 +113,10 @@ func sendSearchRequest(ctx context.Context, DIM int) error {
Timestamp: Timestamp(10),
SourceID: 1,
},
ResultChannelID: "0",
Query: &blob,
ResultChannelID: "0",
Dsl: dslString,
PlaceholderGroup: placeGroupByte,
DslType: commonpb.DslType_Dsl,
},
}
msgPackSearch := msgstream.MsgPack{}

4
tests/python_test/utils.py
View File

@ -870,6 +870,8 @@ def gen_binary_index():
def gen_normal_expressions():
expressions = [
"int64 > 0",
"int64 > 0 && int64 < 2021", # range
"int64 == 0 || int64 == 1 || int64 == 2 || int64 == 3", # term
]
return expressions
@ -878,7 +880,7 @@ def get_search_param(index_type, metric_type="L2"):
search_params = {"metric_type": metric_type}
if index_type in ivf() or index_type in binary_support():
search_params.update({"nprobe": 64})
elif index_type in ["HNSW", "RHNSW_FLAT","RHNSW_SQ", "RHNSW_PQ"]:
elif index_type in ["HNSW", "RHNSW_FLAT", "RHNSW_SQ", "RHNSW_PQ"]:
search_params.update({"ef": 64})
elif index_type == "NSG":
search_params.update({"search_length": 100})