admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-02-02 01:06:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix test_hybrid_db and test_rpc error (#2552)

Browse Source 
* Fix test_hybrid_db and test_rpc error

Signed-off-by: fishpenguin <kun.yu@zilliz.com>

* CI retry

Signed-off-by: fishpenguin <kun.yu@zilliz.com>

* CI retry

Signed-off-by: fishpenguin <kun.yu@zilliz.com>
This commit is contained in:
yukun 2020-06-14 23:18:44 +08:00 committed by GitHub
parent 48a599f5bd
commit 2ee3b60e76
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 330 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -5,6 +5,7 @@ Please mark all change in change log and use the issue from GitHub
# Milvus 0.11.0 (TBD)
## Bug
- \#2551 Fix test_hybrid_db and test_rpc error
## Feature
- \#2319 Redo metadata to support MVCC

23
core/unittest/db/test_hybrid_db.cpp
View File

@ -32,7 +32,7 @@ namespace {
static const char* COLLECTION_NAME = "test_hybrid";
static constexpr int64_t COLLECTION_DIM = 128;
static constexpr int64_t SECONDS_EACH_HOUR = 3600;
static constexpr int64_t FIELD_NUM = 4;
static constexpr int64_t FIELD_NUM = 3;
static constexpr int64_t NQ = 10;
static constexpr int64_t TOPK = 10;
@ -49,9 +49,18 @@ BuildCollectionSchema(milvus::engine::meta::CollectionSchema& collection_schema,
fields[i].collection_id_ = COLLECTION_NAME;
fields[i].field_name_ = "field_" + std::to_string(i);
}
fields[0].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT32;
fields[1].field_type_ = (int)milvus::engine::meta::hybrid::DataType::INT64;
fields[2].field_type_ = (int)milvus::engine::meta::hybrid::DataType::FLOAT;
for (uint64_t i = 0; i < FIELD_NUM; ++i) {
attr_type.insert(
std::make_pair(fields[i].field_name_, (milvus::engine::meta::hybrid::DataType)fields[i].field_type_));
}
milvus::engine::meta::hybrid::FieldSchema schema;
schema.field_name_ = "field_vector";
schema.collection_id_ = TABLE_NAME;
schema.field_name_ = "field_3";
schema.collection_id_ = COLLECTION_NAME;
schema.field_type_ = (int)(milvus::engine::meta::hybrid::DataType::VECTOR);
fields.emplace_back(schema);
@ -85,7 +94,7 @@ BuildEntity(uint64_t n, uint64_t batch_index, milvus::engine::Entity& entity) {
vectors.id_array_.push_back(n * batch_index + i);
}
entity.vector_data_.insert(std::make_pair("field_vector", vectors));
entity.vector_data_.insert(std::make_pair("field_3", vectors));
std::vector<int64_t> value_0;
std::vector<int64_t> value_1;
std::vector<double> value_2;
@ -227,9 +236,9 @@ TEST_F(DBTest, HYBRID_SEARCH_TEST) {
uint64_t qb = 1000;
milvus::engine::Entity entity;
BuildComplexEntity(qb, 0, entity);
BuildEntity(qb, 0, entity);
std::vector<std::string> field_names = {"field_0", "field_1", "field_2", "field_3", "field_4", "field_5"};
std::vector<std::string> field_names = {"field_0", "field_1", "field_2"};
stat = db_->InsertEntities(COLLECTION_NAME, "", field_names, entity, attr_type);
ASSERT_TRUE(stat.ok());
@ -346,3 +355,5 @@ TEST_F(DBTest2, GET_ENTITY_BY_ID_TEST) {
ASSERT_EQ(vector.vector_count_, 0);
ASSERT_TRUE(vector.float_data_.empty());
ASSERT_TRUE(vector.binary_data_.empty());
}
}

501
core/unittest/server/test_rpc.cpp
View File

@ -1202,6 +1202,133 @@ TEST_F(RpcHandlerTest, CMD_TEST) {
handler->Cmd(&context, &command, &reply);
}
void
ConstructHybridSearchParam_1(milvus::grpc::HSearchParam& search_param, const std::string& collection_name,
int64_t dimension, int64_t nq, int64_t topk) {
search_param.set_collection_name(collection_name);
std::vector<int64_t> term_value(nq, 0);
for (uint64_t i = 0; i < nq; ++i) {
term_value[i] = i + nq;
}
std::default_random_engine e;
std::uniform_real_distribution<float> u(0, 1);
std::vector<std::vector<float>> query_vector;
query_vector.resize(nq);
for (uint64_t i = 0; i < nq; ++i) {
query_vector[i].resize(dimension);
for (uint64_t j = 0; j < dimension; ++j) {
query_vector[i][j] = u(e);
}
}
nlohmann::json dsl_json, bool_json, term_json, range_json, vector_json;
term_json["term"]["field_name"] = "field_0";
term_json["term"]["values"] = term_value;
bool_json["must"].push_back(term_json);
range_json["range"]["field_name"] = "field_0";
nlohmann::json comp_json;
comp_json["gte"] = "0";
comp_json["lte"] = "100000";
range_json["range"]["values"] = comp_json;
bool_json["must"].push_back(range_json);
std::string placeholder = "placeholder_1";
vector_json["vector"] = placeholder;
bool_json["must"].push_back(vector_json);
dsl_json["bool"] = bool_json;
nlohmann::json vector_param_json, vector_extra_params;
vector_param_json[placeholder]["field_name"] = "field_1";
vector_param_json[placeholder]["topk"] = topk;
vector_extra_params["nprobe"] = 64;
vector_param_json[placeholder]["params"] = vector_extra_params;
search_param.set_dsl(dsl_json.dump());
auto vector_param = search_param.add_vector_param();
for (auto record : query_vector) {
auto row_record = vector_param->add_row_record();
CopyRowRecord(row_record, record);
}
vector_param->set_json(vector_param_json.dump());
}
void
ConstructHybridSearchParam_2(milvus::grpc::HSearchParam& search_param, const std::string& collection_name,
int64_t dimension, int64_t nq, int64_t topk) {
search_param.set_collection_name(collection_name);
std::vector<int64_t> term_value(nq, 0);
for (uint64_t i = 0; i < nq; ++i) {
term_value[i] = i + nq;
}
std::default_random_engine e;
std::uniform_real_distribution<float> u(0, 1);
std::vector<std::vector<float>> query_vector;
query_vector.resize(nq);
for (uint64_t i = 0; i < nq; ++i) {
query_vector[i].resize(dimension);
for (uint64_t j = 0; j < dimension; ++j) {
query_vector[i][j] = u(e);
}
}
nlohmann::json dsl_json, bool_json, term_json, range_json, vector_json;
std::string placeholder = "placeholder_1";
std::string dsl_string = R"({
"bool": {
"must": [
{
"must": [
{
"should": [
{
"term": {
"field_name": "field_0",
"values": [10, 11, 12 ,13, 14 ,15]
}
},
{
"range": {
"field_name": "field_0",
"values": {"gte": "0", "lte": "100000"}
}
}
]
}
]
},
{
"must": [
{
"vector" : "placeholder_1"
}
]
}
]
}
})";
dsl_json = nlohmann::json::parse(dsl_string);
nlohmann::json vector_param_json, vector_extra_params;
vector_param_json[placeholder]["field_name"] = "field_1";
vector_param_json[placeholder]["topk"] = topk;
vector_extra_params["nprobe"] = 64;
vector_param_json[placeholder]["params"] = vector_extra_params;
search_param.set_dsl(dsl_json.dump());
auto vector_param = search_param.add_vector_param();
for (auto record : query_vector) {
auto row_record = vector_param->add_row_record();
CopyRowRecord(row_record, record);
}
vector_param->set_json(vector_param_json.dump());
}
TEST_F(RpcHandlerTest, HYBRID_TEST) {
::grpc::ServerContext context;
milvus::grpc::Mapping mapping;
@ -1210,8 +1337,10 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) {
uint64_t row_num = 1000;
uint64_t dimension = 128;
std::string collection_name = "test_hybrid";
// Create Hybrid Collection
mapping.set_collection_name("test_hybrid");
mapping.set_collection_name(collection_name);
auto field_0 = mapping.add_fields();
field_0->set_name("field_0");
field_0->mutable_type()->set_data_type(::milvus::grpc::DataType::INT64);
@ -1220,17 +1349,12 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) {
field_1->mutable_type()->mutable_vector_param()->set_dimension(128);
field_1->set_name("field_1");
milvus::json json_param = {{"metric_type", 1}, {"engine_type", 1}};
auto extra_param = field_1->add_extra_params();
extra_param->set_key("params");
extra_param->set_value(json_param.dump());
handler->CreateHybridCollection(&context, &mapping, &response);
// Insert Entities
milvus::grpc::HInsertParam insert_param;
milvus::grpc::HEntityIDs entity_ids;
insert_param.set_collection_name("test_hybrid");
insert_param.set_collection_name(collection_name);
auto entity = insert_param.mutable_entity();
auto field_name_0 = entity->add_field_names();
@ -1286,15 +1410,6 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) {
term_query->mutable_int_value()->Resize(static_cast<int>(nq), 0);
memcpy(term_query->mutable_int_value()->mutable_data(), term_value.data(), nq * sizeof(int64_t));
auto range_query = boolean_query_2->add_general_query()->mutable_range_query();
range_query->set_field_name("field_0");
auto comp1 = range_query->add_operand();
comp1->set_operator_(::milvus::grpc::CompareOperator::GTE);
comp1->set_operand("0");
auto comp2 = range_query->add_operand();
comp2->set_operator_(::milvus::grpc::CompareOperator::LTE);
comp2->set_operand("100000");
auto vector_query = boolean_query_2->add_general_query()->mutable_vector_query();
vector_query->set_field_name("field_1");
vector_query->set_topk(topk);
@ -1311,195 +1426,203 @@ TEST_F(RpcHandlerTest, HYBRID_TEST) {
auto row_record = vector_query->add_records();
CopyRowRecord(row_record, record);
}
auto extra_param_1 = vector_query->add_extra_params();
extra_param_1->set_key("params");
milvus::json param = {{"nprobe", 16}};
extra_param_1->set_value(param.dump());
search_param.set_collection_name("test_hybrid");
auto search_extra_param = search_param.add_extra_params();
search_extra_param->set_key("params");
search_extra_param->set_value("");
milvus::grpc::TopKQueryResult topk_query_result;
handler->HybridSearch(&context, &search_param, &topk_query_result);
}
TEST_F(RpcHandlerTest, HYBRID_INVALID_TEST) {
fiu_init(0);
::grpc::ServerContext context;
milvus::grpc::Mapping mapping;
milvus::grpc::Status response;
uint64_t row_num = 1000;
uint64_t dimension = 128;
// Create Hybrid Collection
mapping.set_collection_name("test_hybrid");
auto field_0 = mapping.add_fields();
field_0->set_name("field_0");
field_0->mutable_type()->set_data_type(::milvus::grpc::DataType::INT64);
auto field_1 = mapping.add_fields();
field_1->mutable_type()->mutable_vector_param()->set_dimension(128);
field_1->set_name("field_1");
milvus::json json_param = {{"metric_type", 1}, {"engine_type", 1}};
auto extra_param = field_1->add_extra_params();
auto extra_param = vector_query->add_extra_params();
extra_param->set_key("params");
extra_param->set_value(json_param.dump());
fiu_enable("CreateHybridCollectionRequest.OnExecute.invalid_collection_name", 1, NULL, 0);
handler->CreateHybridCollection(&context, &mapping, &response);
fiu_disable("CreateHybridCollectionRequest.OnExecute.invalid_collection_name");
fiu_enable("CreateHybridCollectionRequest.OnExecute.invalid_db_execute", 1, NULL, 0);
handler->CreateHybridCollection(&context, &mapping, &response);
fiu_disable("CreateHybridCollectionRequest.OnExecute.invalid_db_execute");
handler->CreateHybridCollection(&context, &mapping, &response);
milvus::grpc::CollectionName grpc_collection_name;
grpc_collection_name.set_collection_name("test_hybrid");
fiu_enable("DescribeHybridCollectionRequest.OnExecute.invalid_db_execute", 1, NULL, 0);
handler->DescribeHybridCollection(&context, &grpc_collection_name, &mapping);
fiu_disable("DescribeHybridCollectionRequest.OnExecute.invalid_db_execute");
handler->DescribeHybridCollection(&context, &grpc_collection_name, &mapping);
// Insert Entities
milvus::grpc::HInsertParam insert_param;
milvus::grpc::HEntityIDs entity_ids;
insert_param.set_collection_name("test_hybrid");
auto entity = insert_param.mutable_entities();
auto field_name_0 = entity->add_field_names();
*field_name_0 = "field_0";
auto field_name_1 = entity->add_field_names();
*field_name_1 = "field_1";
entity->set_row_num(row_num);
std::vector<int64_t> field_value(row_num, 0);
for (uint64_t i = 0; i < row_num; i++) {
field_value[i] = i;
}
entity->set_attr_records(field_value.data(), row_num * sizeof(int64_t));
std::vector<std::vector<float>> vector_field;
vector_field.resize(row_num);
for (uint64_t i = 0; i < row_num; ++i) {
vector_field[i].resize(dimension);
for (uint64_t j = 0; j < dimension; ++j) {
vector_field[i][j] = (float)((i + 10) / (j + 20));
}
}
auto vector_record = entity->add_result_values();
for (uint64_t i = 0; i < row_num; ++i) {
auto record = vector_record->mutable_vector_value()->add_value();
auto vector_data = record->mutable_float_data();
vector_data->Resize(static_cast<int>(vector_field[i].size()), 0.0);
memcpy(vector_data->mutable_data(), vector_field[i].data(), vector_field[i].size() * sizeof(float));
}
fiu_enable("InsertEntityRequest.OnExecute.throw_std_exception", 1, NULL, 0);
handler->InsertEntity(&context, &insert_param, &entity_ids);
fiu_disable("InsertEntityRequest.OnExecute.throw_std_exception");
handler->InsertEntity(&context, &insert_param, &entity_ids);
uint64_t nq = 10;
uint64_t topk = 10;
milvus::grpc::HSearchParam search_param;
auto general_query = search_param.mutable_general_query();
auto boolean_query_1 = general_query->mutable_boolean_query();
boolean_query_1->set_occur(milvus::grpc::Occur::MUST);
auto general_query_1 = boolean_query_1->add_general_query();
auto boolean_query_2 = general_query_1->mutable_boolean_query();
auto term_query = boolean_query_2->add_general_query()->mutable_term_query();
term_query->set_field_name("field_0");
std::vector<int64_t> term_value(nq, 0);
for (uint64_t i = 0; i < nq; ++i) {
term_value[i] = i + nq;
}
term_query->set_value_num(nq);
term_query->set_values(term_value.data(), nq * sizeof(int64_t));
auto range_query = boolean_query_2->add_general_query()->mutable_range_query();
range_query->set_field_name("field_0");
auto comp1 = range_query->add_operand();
comp1->set_operator_(::milvus::grpc::CompareOperator::GTE);
comp1->set_operand("0");
auto comp2 = range_query->add_operand();
comp2->set_operator_(::milvus::grpc::CompareOperator::LTE);
comp2->set_operand("100000");
auto vector_query = boolean_query_2->add_general_query()->mutable_vector_query();
vector_query->set_field_name("field_1");
vector_query->set_topk(topk);
vector_query->set_query_boost(2);
std::vector<std::vector<float>> query_vector;
query_vector.resize(nq);
for (uint64_t i = 0; i < nq; ++i) {
query_vector[i].resize(dimension);
for (uint64_t j = 0; j < dimension; ++j) {
query_vector[i][j] = (float)((j + 1) / (i + dimension));
}
}
for (auto record : query_vector) {
auto row_record = vector_query->add_records();
CopyRowRecord(row_record, record);
}
auto extra_param_1 = vector_query->add_extra_params();
extra_param_1->set_key("params");
milvus::json param = {{"nprobe", 16}};
extra_param_1->set_value(param.dump());
extra_param->set_value(param.dump());
search_param.set_collection_name("test_hybrid");
search_param.set_collection_name(collection_name);
auto search_extra_param = search_param.add_extra_params();
search_extra_param->set_key("params");
search_extra_param->set_value(param.dump());
milvus::json value;
search_extra_param->set_value(value.dump());
milvus::grpc::HQueryResult topk_query_result;
handler->HybridSearchPB(&context, &search_param, &topk_query_result);
// Test new HybridSearch
milvus::grpc::HSearchParam new_search_param;
new_search_param.set_collection_name("test_hybrid");
nlohmann::json dsl_json, bool_json, term_json, range_json, vector_json;
term_json["term"]["field_name"] = "field_0";
term_json["term"]["values"] = term_value;
bool_json["must"].push_back(term_json);
range_json["range"]["field_name"] = "field_0";
nlohmann::json comp_json;
comp_json["gte"] = "0";
comp_json["lte"] = "100000";
range_json["range"]["values"] = comp_json;
bool_json["must"].push_back(range_json);
std::string placeholder = "placeholder_1";
vector_json["vector"] = placeholder;
bool_json["must"].push_back(vector_json);
dsl_json["bool"] = bool_json;
nlohmann::json vector_param_json, vector_extra_params;
vector_param_json[placeholder]["field_name"] = "field_1";
vector_param_json[placeholder]["topk"] = topk;
vector_extra_params["nprobe"] = 64;
vector_param_json[placeholder]["params"] = vector_extra_params;
new_search_param.set_dsl(dsl_json.dump());
auto vector_param = new_search_param.add_vector_param();
for (auto record : query_vector) {
auto row_record = vector_param->add_row_record();
CopyRowRecord(row_record, record);
}
vector_param->set_json(vector_param_json.dump());
ConstructHybridSearchParam_2(new_search_param, collection_name, dimension, nq, topk);
milvus::grpc::HQueryResult new_query_result;
handler->HybridSearch(&context, &new_search_param, &new_query_result);
}
//TEST_F(RpcHandlerTest, HYBRID_INVALID_TEST) {
// fiu_init(0);
//
// ::grpc::ServerContext context;
// milvus::grpc::Mapping mapping;
// milvus::grpc::Status response;
//
// uint64_t row_num = 1000;
// uint64_t dimension = 128;
//
// // Create Hybrid Collection
// mapping.set_collection_name("test_hybrid");
// auto field_0 = mapping.add_fields();
// field_0->set_name("field_0");
// field_0->mutable_type()->set_data_type(::milvus::grpc::DataType::INT64);
//
// auto field_1 = mapping.add_fields();
// field_1->mutable_type()->mutable_vector_param()->set_dimension(128);
// field_1->set_name("field_1");
//
// milvus::json json_param = {{"metric_type", 1}, {"engine_type", 1}};
// auto extra_param = field_1->add_extra_params();
// extra_param->set_key("params");
// extra_param->set_value(json_param.dump());
//
// fiu_enable("CreateHybridCollectionRequest.OnExecute.invalid_collection_name", 1, NULL, 0);
// handler->CreateHybridCollection(&context, &mapping, &response);
// fiu_disable("CreateHybridCollectionRequest.OnExecute.invalid_collection_name");
//
// fiu_enable("CreateHybridCollectionRequest.OnExecute.invalid_db_execute", 1, NULL, 0);
// handler->CreateHybridCollection(&context, &mapping, &response);
// fiu_disable("CreateHybridCollectionRequest.OnExecute.invalid_db_execute");
//
// handler->CreateHybridCollection(&context, &mapping, &response);
// milvus::grpc::CollectionName grpc_collection_name;
// grpc_collection_name.set_collection_name("test_hybrid");
// fiu_enable("DescribeHybridCollectionRequest.OnExecute.invalid_db_execute", 1, NULL, 0);
// handler->DescribeHybridCollection(&context, &grpc_collection_name, &mapping);
// fiu_disable("DescribeHybridCollectionRequest.OnExecute.invalid_db_execute");
// handler->DescribeHybridCollection(&context, &grpc_collection_name, &mapping);
//
// // Insert Entities
// milvus::grpc::HInsertParam insert_param;
// milvus::grpc::HEntityIDs entity_ids;
// insert_param.set_collection_name("test_hybrid");
//
// auto entity = insert_param.mutable_entities();
// auto field_name_0 = entity->add_field_names();
// *field_name_0 = "field_0";
// auto field_name_1 = entity->add_field_names();
// *field_name_1 = "field_1";
//
// entity->set_row_num(row_num);
// std::vector<int64_t> field_value(row_num, 0);
// for (uint64_t i = 0; i < row_num; i++) {
// field_value[i] = i;
// }
// entity->set_attr_records(field_value.data(), row_num * sizeof(int64_t));
//
// std::vector<std::vector<float>> vector_field;
// vector_field.resize(row_num);
// for (uint64_t i = 0; i < row_num; ++i) {
// vector_field[i].resize(dimension);
// for (uint64_t j = 0; j < dimension; ++j) {
// vector_field[i][j] = (float)((i + 10) / (j + 20));
// }
// }
// auto vector_record = entity->add_result_values();
// for (uint64_t i = 0; i < row_num; ++i) {
// auto record = vector_record->mutable_vector_value()->add_value();
// auto vector_data = record->mutable_float_data();
// vector_data->Resize(static_cast<int>(vector_field[i].size()), 0.0);
// memcpy(vector_data->mutable_data(), vector_field[i].data(), vector_field[i].size() * sizeof(float));
// }
//
// fiu_enable("InsertEntityRequest.OnExecute.throw_std_exception", 1, NULL, 0);
// handler->InsertEntity(&context, &insert_param, &entity_ids);
// fiu_disable("InsertEntityRequest.OnExecute.throw_std_exception");
// handler->InsertEntity(&context, &insert_param, &entity_ids);
//
// uint64_t nq = 10;
// uint64_t topk = 10;
// milvus::grpc::HSearchParam search_param;
// auto general_query = search_param.mutable_general_query();
// auto boolean_query_1 = general_query->mutable_boolean_query();
// boolean_query_1->set_occur(milvus::grpc::Occur::MUST);
// auto general_query_1 = boolean_query_1->add_general_query();
// auto boolean_query_2 = general_query_1->mutable_boolean_query();
// auto term_query = boolean_query_2->add_general_query()->mutable_term_query();
// term_query->set_field_name("field_0");
// std::vector<int64_t> term_value(nq, 0);
// for (uint64_t i = 0; i < nq; ++i) {
// term_value[i] = i + nq;
// }
// term_query->set_value_num(nq);
// term_query->set_values(term_value.data(), nq * sizeof(int64_t));
//
// auto range_query = boolean_query_2->add_general_query()->mutable_range_query();
// range_query->set_field_name("field_0");
// auto comp1 = range_query->add_operand();
// comp1->set_operator_(::milvus::grpc::CompareOperator::GTE);
// comp1->set_operand("0");
// auto comp2 = range_query->add_operand();
// comp2->set_operator_(::milvus::grpc::CompareOperator::LTE);
// comp2->set_operand("100000");
//
// auto vector_query = boolean_query_2->add_general_query()->mutable_vector_query();
// vector_query->set_field_name("field_1");
// vector_query->set_topk(topk);
// vector_query->set_query_boost(2);
// std::vector<std::vector<float>> query_vector;
// query_vector.resize(nq);
// for (uint64_t i = 0; i < nq; ++i) {
// query_vector[i].resize(dimension);
// for (uint64_t j = 0; j < dimension; ++j) {
// query_vector[i][j] = (float)((j + 1) / (i + dimension));
// }
// }
// for (auto record : query_vector) {
// auto row_record = vector_query->add_records();
// CopyRowRecord(row_record, record);
// }
// auto extra_param_1 = vector_query->add_extra_params();
// extra_param_1->set_key("params");
// milvus::json param = {{"nprobe", 16}};
// extra_param_1->set_value(param.dump());
//
// search_param.set_collection_name("test_hybrid");
// auto search_extra_param = search_param.add_extra_params();
// search_extra_param->set_key("params");
// search_extra_param->set_value(param.dump());
//
// milvus::grpc::HQueryResult topk_query_result;
// handler->HybridSearchPB(&context, &search_param, &topk_query_result);
//
// // Test new HybridSearch
// milvus::grpc::HSearchParam new_search_param;
// new_search_param.set_collection_name("test_hybrid");
//
// nlohmann::json dsl_json, bool_json, term_json, range_json, vector_json;
// term_json["term"]["field_name"] = "field_0";
// term_json["term"]["values"] = term_value;
// bool_json["must"].push_back(term_json);
//
// range_json["range"]["field_name"] = "field_0";
// nlohmann::json comp_json;
// comp_json["gte"] = "0";
// comp_json["lte"] = "100000";
// range_json["range"]["values"] = comp_json;
// bool_json["must"].push_back(range_json);
//
// std::string placeholder = "placeholder_1";
// vector_json["vector"] = placeholder;
// bool_json["must"].push_back(vector_json);
//
// dsl_json["bool"] = bool_json;
//
// nlohmann::json vector_param_json, vector_extra_params;
// vector_param_json[placeholder]["field_name"] = "field_1";
// vector_param_json[placeholder]["topk"] = topk;
// vector_extra_params["nprobe"] = 64;
// vector_param_json[placeholder]["params"] = vector_extra_params;
//
// new_search_param.set_dsl(dsl_json.dump());
// auto vector_param = new_search_param.add_vector_param();
// for (auto record : query_vector) {
// auto row_record = vector_param->add_row_record();
// CopyRowRecord(row_record, record);
// }
// vector_param->set_json(vector_param_json.dump());
//
// milvus::grpc::HQueryResult new_query_result;
// handler->HybridSearch(&context, &new_search_param, &new_query_result);
//}
//////////////////////////////////////////////////////////////////////
namespace {
class DummyRequest : public milvus::server::BaseRequest {