diff --git a/CHANGELOG.md b/CHANGELOG.md index aa537b8e10..56c81154e5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/core/unittest/db/test_hybrid_db.cpp b/core/unittest/db/test_hybrid_db.cpp index a272bf1b90..f5cc1d603d 100644 --- a/core/unittest/db/test_hybrid_db.cpp +++ b/core/unittest/db/test_hybrid_db.cpp @@ -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 value_0; std::vector value_1; std::vector 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 field_names = {"field_0", "field_1", "field_2", "field_3", "field_4", "field_5"}; + std::vector 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()); + } +} diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp index d0c1982c28..99a67de7cf 100644 --- a/core/unittest/server/test_rpc.cpp +++ b/core/unittest/server/test_rpc.cpp @@ -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 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 u(0, 1); + std::vector> 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 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 u(0, 1); + std::vector> 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(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 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> 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(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 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> 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 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> 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(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 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> 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 {