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

Rename SearchResult fields for better readability (#12327) 

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>
pull/12341/head
Cai Yudong 2021-11-29 14:57:18 +08:00 committed by GitHub
parent bdd39c0623
commit cb952d6036
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 92 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/core/src/common/Types.h
View File

@ -60,8 +60,8 @@ struct SearchResult {
SearchResult() = default;
SearchResult(int64_t num_queries, int64_t topk) : topk_(topk), num_queries_(num_queries) {
auto count = get_row_count();
result_distances_.resize(count);
internal_seg_offsets_.resize(count);
distances_.resize(count);
ids_.resize(count);
}
int64_t
@ -72,8 +72,8 @@ struct SearchResult {
public:
int64_t num_queries_;
int64_t topk_;
std::vector<float> result_distances_;
std::vector<int64_t> internal_seg_offsets_;
std::vector<float> distances_;
std::vector<int64_t> ids_;
public:
// TODO(gexi): utilize these field

8
internal/core/src/query/SearchOnGrowing.cpp
View File

@ -101,8 +101,8 @@ FloatSearch(const segcore::SegmentGrowingImpl& segment,
final_qr.merge(sub_qr);
}
current_chunk_id = max_chunk;
results.result_distances_ = std::move(final_qr.mutable_values());
results.internal_seg_offsets_ = std::move(final_qr.mutable_labels());
results.distances_ = std::move(final_qr.mutable_values());
results.ids_ = std::move(final_qr.mutable_labels());
results.topk_ = topk;
results.num_queries_ = num_queries;
@ -164,8 +164,8 @@ BinarySearch(const segcore::SegmentGrowingImpl& segment,
}
final_result.round_values();
results.result_distances_ = std::move(final_result.mutable_values());
results.internal_seg_offsets_ = std::move(final_result.mutable_labels());
results.distances_ = std::move(final_result.mutable_values());
results.ids_ = std::move(final_result.mutable_labels());
results.topk_ = topk;
results.num_queries_ = num_queries;

8
internal/core/src/query/SearchOnSealed.cpp
View File

@ -105,12 +105,12 @@ SearchOnSealed(const Schema& schema,
distances[i] = round(distances[i] * multiplier) / multiplier;
}
}
result.internal_seg_offsets_.resize(total_num);
result.result_distances_.resize(total_num);
result.ids_.resize(total_num);
result.distances_.resize(total_num);
result.num_queries_ = num_queries;
result.topk_ = topk;
std::copy_n(ids, total_num, result.internal_seg_offsets_.data());
std::copy_n(distances, total_num, result.result_distances_.data());
std::copy_n(ids, total_num, result.ids_.data());
std::copy_n(distances, total_num, result.distances_.data());
}
} // namespace milvus::query

4
internal/core/src/query/visitors/ExecPlanNodeVisitor.cpp
View File

@ -68,8 +68,8 @@ empty_search_result(int64_t num_queries, int64_t topk, int64_t round_decimal, Me
SubSearchResult result(num_queries, topk, metric_type, round_decimal);
final_result.num_queries_ = num_queries;
final_result.topk_ = topk;
final_result.internal_seg_offsets_ = std::move(result.mutable_labels());
final_result.result_distances_ = std::move(result.mutable_values());
final_result.ids_ = std::move(result.mutable_labels());
final_result.distances_ = std::move(result.mutable_values());
return final_result;
}

2
internal/core/src/segcore/ReduceStructure.h
View File

@ -53,7 +53,7 @@ struct SearchResultPair {
offset_++;
if (offset_ < offset_rb_) {
primary_key_ = search_result_->primary_keys_.at(offset_);
distance_ = search_result_->result_distances_.at(offset_);
distance_ = search_result_->distances_.at(offset_);
} else {
primary_key_ = INVALID_ID;
distance_ = MAXFLOAT;

20
internal/core/src/segcore/SegmentInterface.cpp
View File

@ -18,22 +18,21 @@ void
SegmentInternalInterface::FillPrimaryKeys(const query::Plan* plan, SearchResult& results) const {
std::shared_lock lck(mutex_);
AssertInfo(plan, "empty plan");
auto size = results.result_distances_.size();
AssertInfo(results.internal_seg_offsets_.size() == size,
"Size of result distances is not equal to size of segment offsets");
auto size = results.distances_.size();
AssertInfo(results.ids_.size() == size, "Size of result distances is not equal to size of ids");
Assert(results.primary_keys_.size() == 0);
results.primary_keys_.resize(size);
auto element_sizeof = sizeof(int64_t);
aligned_vector<char> blob(size * element_sizeof);
if (plan->schema_.get_is_auto_id()) {
bulk_subscript(SystemFieldType::RowId, results.internal_seg_offsets_.data(), size, blob.data());
bulk_subscript(SystemFieldType::RowId, results.ids_.data(), size, blob.data());
} else {
auto key_offset_opt = get_schema().get_primary_key_offset();
AssertInfo(key_offset_opt.has_value(), "Cannot get primary key offset from schema");
auto key_offset = key_offset_opt.value();
AssertInfo(get_schema()[key_offset].get_data_type() == DataType::INT64, "Primary key field is not INT64 type");
bulk_subscript(key_offset, results.internal_seg_offsets_.data(), size, blob.data());
bulk_subscript(key_offset, results.ids_.data(), size, blob.data());
}
memcpy(results.primary_keys_.data(), blob.data(), element_sizeof * size);
@ -43,9 +42,8 @@ void
SegmentInternalInterface::FillTargetEntry(const query::Plan* plan, SearchResult& results) const {
std::shared_lock lck(mutex_);
AssertInfo(plan, "empty plan");
auto size = results.result_distances_.size();
AssertInfo(results.internal_seg_offsets_.size() == size,
"Size of result distances is not equal to size of segment offsets");
auto size = results.distances_.size();
AssertInfo(results.ids_.size() == size, "Size of result distances is not equal to size of ids");
Assert(results.row_data_.size() == 0);
std::vector<int64_t> element_sizeofs;
@ -55,14 +53,14 @@ SegmentInternalInterface::FillTargetEntry(const query::Plan* plan, SearchResult&
{
aligned_vector<char> blob(size * sizeof(int64_t));
if (plan->schema_.get_is_auto_id()) {
bulk_subscript(SystemFieldType::RowId, results.internal_seg_offsets_.data(), size, blob.data());
bulk_subscript(SystemFieldType::RowId, results.ids_.data(), size, blob.data());
} else {
auto key_offset_opt = get_schema().get_primary_key_offset();
AssertInfo(key_offset_opt.has_value(), "Cannot get primary key offset from schema");
auto key_offset = key_offset_opt.value();
AssertInfo(get_schema()[key_offset].get_data_type() == DataType::INT64,
"Primary key field is not INT64 type");
bulk_subscript(key_offset, results.internal_seg_offsets_.data(), size, blob.data());
bulk_subscript(key_offset, results.ids_.data(), size, blob.data());
}
blobs.emplace_back(std::move(blob));
element_sizeofs.push_back(sizeof(int64_t));
@ -73,7 +71,7 @@ SegmentInternalInterface::FillTargetEntry(const query::Plan* plan, SearchResult&
auto& field_meta = get_schema()[field_offset];
auto element_sizeof = field_meta.get_sizeof();
aligned_vector<char> blob(size * element_sizeof);
bulk_subscript(field_offset, results.internal_seg_offsets_.data(), size, blob.data());
bulk_subscript(field_offset, results.ids_.data(), size, blob.data());
blobs.emplace_back(std::move(blob));
element_sizeofs.push_back(element_sizeof);
}

4
internal/core/src/segcore/SegmentSealedImpl.cpp
View File

@ -351,8 +351,8 @@ SegmentSealedImpl::vector_search(int64_t vec_count,
}();
SearchResult results;
results.result_distances_ = std::move(sub_qr.mutable_values());
results.internal_seg_offsets_ = std::move(sub_qr.mutable_labels());
results.distances_ = std::move(sub_qr.mutable_values());
results.ids_ = std::move(sub_qr.mutable_labels());
results.topk_ = dataset.topk;
results.num_queries_ = dataset.num_queries;

24
internal/core/src/segcore/reduce_c.cpp
View File

@ -60,8 +60,7 @@ DeleteMarshaledHits(CMarshaledHits c_marshaled_hits) {
// const int64_t MAXLEN = 32;
// snprintf(buf + strlen(buf), MAXLEN, "{ seg No.%ld ", seg_idx);
// for (int64_t i = from; i < to; i++) {
// snprintf(buf + strlen(buf), MAXLEN, "(%ld, %ld, %f), ", i, result->primary_keys_[i],
// result->result_distances_[i]);
// snprintf(buf + strlen(buf), MAXLEN, "(%ld, %ld, %f), ", i, result->primary_keys_[i], result->distances_[i]);
// }
// snprintf(buf + strlen(buf), MAXLEN, "} ");
//}
@ -75,7 +74,7 @@ ReduceResultData(std::vector<SearchResult*>& search_results, int64_t nq, int64_t
auto search_result = search_results[i];
AssertInfo(search_result != nullptr, "search result must not equal to nullptr");
AssertInfo(search_result->primary_keys_.size() == nq * topk, "incorrect search result primary key size");
AssertInfo(search_result->result_distances_.size() == nq * topk, "incorrect search result distance size");
AssertInfo(search_result->distances_.size() == nq * topk, "incorrect search result distance size");
}
std::vector<std::vector<int64_t>> search_records(num_segments);
@ -89,7 +88,7 @@ ReduceResultData(std::vector<SearchResult*>& search_results, int64_t nq, int64_t
for (int i = 0; i < num_segments; i++) {
auto search_result = search_results[i];
auto primary_key = search_result->primary_keys_[base_offset];
auto distance = search_result->result_distances_[base_offset];
auto distance = search_result->distances_[base_offset];
result_pairs.push_back(
SearchResultPair(primary_key, distance, search_result, i, base_offset, base_offset + topk));
}
@ -130,7 +129,7 @@ ReduceResultData(std::vector<SearchResult*>& search_results, int64_t nq, int64_t
}
LOG_SEGCORE_DEBUG_ << "skip duplicated search result, count = " << skip_dup_cnt;
// after reduce, remove redundant values in primary_keys, result_distances and internal_seg_offsets
// after reduce, remove redundant values in primary_keys, distances and ids
for (int i = 0; i < num_segments; i++) {
auto search_result = search_results[i];
if (search_result->result_offsets_.size() == 0) {
@ -138,19 +137,18 @@ ReduceResultData(std::vector<SearchResult*>& search_results, int64_t nq, int64_t
}
std::vector<int64_t> primary_keys;
std::vector<float> result_distances;
std::vector<int64_t> internal_seg_offsets;
std::vector<float> distances;
std::vector<int64_t> ids;
for (int j = 0; j < search_records[i].size(); j++) {
auto& offset = search_records[i][j];
primary_keys.push_back(offset != INVALID_OFFSET ? search_result->primary_keys_[offset] : INVALID_ID);
result_distances.push_back(offset != INVALID_OFFSET ? search_result->result_distances_[offset] : MAXFLOAT);
internal_seg_offsets.push_back(offset != INVALID_OFFSET ? search_result->internal_seg_offsets_[offset]
: INVALID_SEG_OFFSET);
distances.push_back(offset != INVALID_OFFSET ? search_result->distances_[offset] : MAXFLOAT);
ids.push_back(offset != INVALID_OFFSET ? search_result->ids_[offset] : INVALID_ID);
}
search_result->primary_keys_ = primary_keys;
search_result->result_distances_ = result_distances;
search_result->internal_seg_offsets_ = internal_seg_offsets;
search_result->distances_ = distances;
search_result->ids_ = ids;
}
}
@ -213,7 +211,7 @@ ReorganizeSearchResults(CMarshaledHits* c_marshaled_hits, CSearchResult* c_searc
#pragma omp parallel for
for (int j = 0; j < size; j++) {
auto loc = search_result->result_offsets_[j];
result_distances[loc] = search_result->result_distances_[j];
result_distances[loc] = search_result->distances_[j];
row_datas[loc] = search_result->row_data_[j];
}
counts[i] = size;

2
internal/core/src/segcore/segment_c.cpp
View File

@ -70,7 +70,7 @@ Search(CSegmentInterface c_segment,
*search_result = segment->Search(plan, *phg_ptr, timestamp);
// if (plan->plan_node_->search_info_.metric_type_ != milvus::MetricType::METRIC_INNER_PRODUCT) {
if (!milvus::segcore::PositivelyRelated(plan->plan_node_->search_info_.metric_type_)) {
for (auto& dis : search_result->result_distances_) {
for (auto& dis : search_result->distances_) {
dis *= -1;
}
}

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

@ -956,8 +956,8 @@ TEST(CApiTest, Indexing_Without_Predicate) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1075,8 +1075,8 @@ TEST(CApiTest, Indexing_Expr_Without_Predicate) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1212,8 +1212,8 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1241,9 +1241,9 @@ TEST(CApiTest, Indexing_With_float_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -1364,8 +1364,8 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1393,9 +1393,9 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -1500,8 +1500,8 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1529,9 +1529,9 @@ TEST(CApiTest, Indexing_With_float_Predicate_Term) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -1645,8 +1645,8 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1674,9 +1674,9 @@ TEST(CApiTest, Indexing_Expr_With_float_Predicate_Term) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -1783,8 +1783,8 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1812,9 +1812,9 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 420000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -1934,8 +1934,8 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -1963,9 +1963,9 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset],
search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -2071,8 +2071,8 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -2105,9 +2105,8 @@ TEST(CApiTest, Indexing_With_binary_Predicate_Term) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset], search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -2221,8 +2220,8 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
}
auto search_result_on_raw_index = (SearchResult*)c_search_result_on_smallIndex;
search_result_on_raw_index->internal_seg_offsets_ = vec_ids;
search_result_on_raw_index->result_distances_ = vec_dis;
search_result_on_raw_index->ids_ = vec_ids;
search_result_on_raw_index->distances_ = vec_dis;
auto binary_set = indexing->Serialize(conf);
void* c_load_index_info = nullptr;
@ -2255,9 +2254,8 @@ TEST(CApiTest, Indexing_Expr_With_binary_Predicate_Term) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.result_distances_[offset],
search_result_on_raw_index->result_distances_[offset]);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.distances_[offset], search_result_on_raw_index->distances_[offset]);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -2458,7 +2456,7 @@ TEST(CApiTest, SealedSegment_search_float_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
}
DeleteLoadIndexInfo(c_load_index_info);
@ -2718,7 +2716,7 @@ TEST(CApiTest, SealedSegment_search_float_With_Expr_Predicate_Range) {
auto search_result_on_bigIndex = (*(SearchResult*)c_search_result_on_bigIndex);
for (int i = 0; i < num_queries; ++i) {
auto offset = i * TOPK;
ASSERT_EQ(search_result_on_bigIndex.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(search_result_on_bigIndex.ids_[offset], 42000 + i);
}
DeleteLoadIndexInfo(c_load_index_info);

4
internal/core/unittest/test_indexing.cpp
View File

@ -242,8 +242,8 @@ TEST(Indexing, BinaryBruteForce) {
SearchResult sr;
sr.num_queries_ = num_queries;
sr.topk_ = topk;
sr.internal_seg_offsets_ = std::move(sub_result.mutable_labels());
sr.result_distances_ = std::move(sub_result.mutable_values());
sr.ids_ = std::move(sub_result.mutable_labels());
sr.distances_ = std::move(sub_result.mutable_values());
auto json = SearchResultToJson(sr);
std::cout << json.dump(2);

6
internal/core/unittest/test_query.cpp
View File

@ -405,11 +405,11 @@ TEST(Query, ExecEmpty) {
auto sr = segment->Search(plan.get(), *ph_group, time);
std::cout << SearchResultToJson(sr);
for (auto i : sr.internal_seg_offsets_) {
for (auto i : sr.ids_) {
ASSERT_EQ(i, -1);
}
for (auto v : sr.result_distances_) {
for (auto v : sr.distances_) {
ASSERT_EQ(v, std::numeric_limits<float>::max());
}
}
@ -675,7 +675,7 @@ TEST(Query, FillSegment) {
int64_t val;
memcpy(&val, vec.data(), sizeof(int64_t));
auto internal_offset = result.internal_seg_offsets_[std_index];
auto internal_offset = result.ids_[std_index];
auto std_val = std_vec[internal_offset];
auto std_i32 = std_i32_vec[internal_offset];
std::vector<float> std_vfloat(dim);

8
internal/core/unittest/test_sealed.cpp
View File

@ -100,8 +100,8 @@ TEST(Sealed, without_predicate) {
std::vector<int64_t> vec_ids(ids, ids + topK * num_queries);
std::vector<float> vec_dis(dis, dis + topK * num_queries);
sr.internal_seg_offsets_ = vec_ids;
sr.result_distances_ = vec_dis;
sr.ids_ = vec_ids;
sr.distances_ = vec_dis;
auto ref_result = SearchResultToJson(sr);
LoadIndexInfo load_info;
@ -208,8 +208,8 @@ TEST(Sealed, with_predicate) {
auto post_sr = sr;
for (int i = 0; i < num_queries; ++i) {
auto offset = i * topK;
ASSERT_EQ(post_sr.internal_seg_offsets_[offset], 42000 + i);
ASSERT_EQ(post_sr.result_distances_[offset], 0.0);
ASSERT_EQ(post_sr.ids_[offset], 42000 + i);
ASSERT_EQ(post_sr.distances_[offset], 0.0);
}
}

3
internal/core/unittest/test_utils/DataGen.h
View File

@ -290,8 +290,7 @@ SearchResultToJson(const SearchResult& sr) {
std::vector<std::string> result;
for (int k = 0; k < topk; ++k) {
int index = q * topk + k;
result.emplace_back(std::to_string(sr.internal_seg_offsets_[index]) + "->" +
std::to_string(sr.result_distances_[index]));
result.emplace_back(std::to_string(sr.ids_[index]) + "->" + std::to_string(sr.distances_[index]));
}
results.emplace_back(std::move(result));
}