mirror of
https://github.com/typesense/typesense.git
synced 2025-05-20 21:52:23 +08:00
Review change.
This commit is contained in:
parent
31107ded93
commit
a68f251f83
@ -18,8 +18,9 @@ struct reference_filter_result_t {
|
||||
explicit reference_filter_result_t(uint32_t count = 0, uint32_t* docs = nullptr) : count(count), docs(docs) {}
|
||||
|
||||
reference_filter_result_t(const reference_filter_result_t& obj) {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = new uint32_t[count];
|
||||
@ -27,8 +28,9 @@ struct reference_filter_result_t {
|
||||
}
|
||||
|
||||
reference_filter_result_t& operator=(const reference_filter_result_t& obj) noexcept {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = new uint32_t[count];
|
||||
@ -38,8 +40,9 @@ struct reference_filter_result_t {
|
||||
}
|
||||
|
||||
reference_filter_result_t& operator=(reference_filter_result_t&& obj) noexcept {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = obj.docs;
|
||||
@ -65,8 +68,9 @@ struct single_filter_result_t {
|
||||
seq_id(seq_id), reference_filter_results(std::move(reference_filter_results)) {}
|
||||
|
||||
single_filter_result_t(const single_filter_result_t& obj) {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return;
|
||||
}
|
||||
|
||||
seq_id = obj.seq_id;
|
||||
|
||||
@ -82,15 +86,16 @@ struct filter_result_t {
|
||||
uint32_t count = 0;
|
||||
uint32_t* docs = nullptr;
|
||||
// Collection name -> Reference filter result
|
||||
std::unique_ptr<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []> reference_filter_results;
|
||||
std::map<std::string, reference_filter_result_t>* coll_to_references = nullptr;
|
||||
|
||||
filter_result_t() = default;
|
||||
|
||||
filter_result_t(uint32_t count, uint32_t* docs) : count(count), docs(docs) {}
|
||||
|
||||
filter_result_t(const filter_result_t& obj) {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = new uint32_t[count];
|
||||
@ -100,8 +105,9 @@ struct filter_result_t {
|
||||
}
|
||||
|
||||
filter_result_t& operator=(const filter_result_t& obj) noexcept {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = new uint32_t[count];
|
||||
@ -113,20 +119,23 @@ struct filter_result_t {
|
||||
}
|
||||
|
||||
filter_result_t& operator=(filter_result_t&& obj) noexcept {
|
||||
if (&obj == this)
|
||||
if (&obj == this) {
|
||||
return *this;
|
||||
}
|
||||
|
||||
count = obj.count;
|
||||
docs = obj.docs;
|
||||
reference_filter_results = std::move(obj.reference_filter_results);
|
||||
coll_to_references = obj.coll_to_references;
|
||||
|
||||
obj.docs = nullptr;
|
||||
obj.coll_to_references = nullptr;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
~filter_result_t() {
|
||||
delete[] docs;
|
||||
delete[] coll_to_references;
|
||||
}
|
||||
|
||||
static void and_filter_results(const filter_result_t& a, const filter_result_t& b, filter_result_t& result);
|
||||
|
@ -14,20 +14,19 @@
|
||||
#include "collection_manager.h"
|
||||
|
||||
void filter_result_t::copy_references(const filter_result_t& from, filter_result_t& to) {
|
||||
if (from.reference_filter_results == nullptr) {
|
||||
if (from.coll_to_references == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto const& count = from.count;
|
||||
to.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(count);
|
||||
to.coll_to_references = new std::map<std::string, reference_filter_result_t>[count] {};
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
if (from.reference_filter_results[i] == nullptr) {
|
||||
if (from.coll_to_references[i].empty()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto& ref = to.reference_filter_results[i];
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
ref->insert(from.reference_filter_results[i]->begin(), from.reference_filter_results[i]->end());
|
||||
auto& ref = to.coll_to_references[i];
|
||||
ref.insert(from.coll_to_references[i].begin(), from.coll_to_references[i].end());
|
||||
}
|
||||
}
|
||||
|
||||
@ -43,8 +42,8 @@ void filter_result_t::and_filter_results(const filter_result_t& a, const filter_
|
||||
const uint32_t *endA = A + lenA;
|
||||
const uint32_t *endB = B + lenB;
|
||||
|
||||
if (a.reference_filter_results != nullptr || b.reference_filter_results != nullptr) {
|
||||
result.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(std::min(lenA, lenB));
|
||||
if (a.coll_to_references != nullptr || b.coll_to_references != nullptr) {
|
||||
result.coll_to_references = new std::map<std::string, reference_filter_result_t>[std::min(lenA, lenB)] {};
|
||||
}
|
||||
|
||||
while (true) {
|
||||
@ -64,17 +63,14 @@ void filter_result_t::and_filter_results(const filter_result_t& a, const filter_
|
||||
if (*A == *B) {
|
||||
*out = *A;
|
||||
|
||||
if (result.reference_filter_results != nullptr) {
|
||||
if (result.coll_to_references != nullptr) {
|
||||
// Copy the references of the document from every collection into result.
|
||||
auto& ref = result.reference_filter_results[out - result.docs];
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
if (a.reference_filter_results != nullptr && a.reference_filter_results[A - a.docs] != nullptr) {
|
||||
ref->insert(a.reference_filter_results[A - a.docs]->begin(),
|
||||
a.reference_filter_results[A - a.docs]->end());
|
||||
auto& ref = result.coll_to_references[out - result.docs];
|
||||
if (a.coll_to_references != nullptr) {
|
||||
ref.insert(a.coll_to_references[A - a.docs].begin(), a.coll_to_references[A - a.docs].end());
|
||||
}
|
||||
if (b.reference_filter_results != nullptr && b.reference_filter_results[B - b.docs] != nullptr) {
|
||||
ref->insert(b.reference_filter_results[B - b.docs]->begin(),
|
||||
b.reference_filter_results[B - b.docs]->end());
|
||||
if (b.coll_to_references != nullptr) {
|
||||
ref.insert(b.coll_to_references[B - b.docs].begin(), b.coll_to_references[B - b.docs].end());
|
||||
}
|
||||
}
|
||||
|
||||
@ -108,8 +104,8 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
size_t indexA = 0, indexB = 0, res_index = 0, lenA = a.count, lenB = b.count;
|
||||
result.docs = new uint32_t[lenA + lenB];
|
||||
|
||||
if (a.reference_filter_results != nullptr || b.reference_filter_results != nullptr) {
|
||||
result.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(lenA + lenB);
|
||||
if (a.coll_to_references != nullptr || b.coll_to_references != nullptr) {
|
||||
result.coll_to_references = new std::map<std::string, reference_filter_result_t>[lenA + lenB] {};
|
||||
}
|
||||
|
||||
while (indexA < lenA && indexB < lenB) {
|
||||
@ -120,13 +116,10 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
res_index++;
|
||||
}
|
||||
|
||||
if (a.reference_filter_results != nullptr && a.reference_filter_results[indexA] != nullptr) {
|
||||
if (a.coll_to_references != nullptr) {
|
||||
// Copy references of the last result document from every collection in a.
|
||||
auto &ref = result.reference_filter_results[res_index - 1];
|
||||
if (ref == nullptr) {
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
}
|
||||
ref->insert(a.reference_filter_results[indexA]->begin(), a.reference_filter_results[indexA]->end());
|
||||
auto &ref = result.coll_to_references[res_index - 1];
|
||||
ref.insert(a.coll_to_references[indexA].begin(), a.coll_to_references[indexA].end());
|
||||
}
|
||||
|
||||
indexA++;
|
||||
@ -136,12 +129,9 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
res_index++;
|
||||
}
|
||||
|
||||
if (b.reference_filter_results != nullptr && b.reference_filter_results[indexB] != nullptr) {
|
||||
auto &ref = result.reference_filter_results[res_index - 1];
|
||||
if (ref == nullptr) {
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
}
|
||||
ref->insert(b.reference_filter_results[indexB]->begin(), b.reference_filter_results[indexB]->end());
|
||||
if (b.coll_to_references != nullptr) {
|
||||
auto &ref = result.coll_to_references[res_index - 1];
|
||||
ref.insert(b.coll_to_references[indexB].begin(), b.coll_to_references[indexB].end());
|
||||
}
|
||||
|
||||
indexB++;
|
||||
@ -154,12 +144,9 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
res_index++;
|
||||
}
|
||||
|
||||
if (a.reference_filter_results != nullptr && a.reference_filter_results[indexA] != nullptr) {
|
||||
auto &ref = result.reference_filter_results[res_index - 1];
|
||||
if (ref == nullptr) {
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
}
|
||||
ref->insert(a.reference_filter_results[indexA]->begin(), a.reference_filter_results[indexA]->end());
|
||||
if (a.coll_to_references != nullptr) {
|
||||
auto &ref = result.coll_to_references[res_index - 1];
|
||||
ref.insert(a.coll_to_references[indexA].begin(), a.coll_to_references[indexA].end());
|
||||
}
|
||||
|
||||
indexA++;
|
||||
@ -171,12 +158,9 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
res_index++;
|
||||
}
|
||||
|
||||
if (b.reference_filter_results != nullptr && b.reference_filter_results[indexB] != nullptr) {
|
||||
auto &ref = result.reference_filter_results[res_index - 1];
|
||||
if (ref == nullptr) {
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
}
|
||||
ref->insert(b.reference_filter_results[indexB]->begin(), b.reference_filter_results[indexB]->end());
|
||||
if (b.coll_to_references != nullptr) {
|
||||
auto &ref = result.coll_to_references[res_index - 1];
|
||||
ref.insert(b.coll_to_references[indexB].begin(), b.coll_to_references[indexB].end());
|
||||
}
|
||||
|
||||
indexB++;
|
||||
@ -194,22 +178,17 @@ void filter_result_t::or_filter_results(const filter_result_t& a, const filter_r
|
||||
delete[] result.docs;
|
||||
result.docs = out;
|
||||
|
||||
if (result.reference_filter_results == nullptr) {
|
||||
if (result.coll_to_references == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto out_references = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(res_index);
|
||||
auto out_references = new std::map<std::string, reference_filter_result_t>[res_index] {};
|
||||
for (uint32_t i = 0; i < res_index; i++) {
|
||||
if (result.reference_filter_results[i] == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto& ref = out_references[i];
|
||||
ref = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
ref->insert(result.reference_filter_results[i]->begin(), result.reference_filter_results[i]->end());
|
||||
ref.insert(result.coll_to_references[i].begin(), result.coll_to_references[i].end());
|
||||
}
|
||||
|
||||
result.reference_filter_results = std::move(out_references);
|
||||
result.coll_to_references = out_references;
|
||||
}
|
||||
|
||||
void filter_result_iterator_t::and_filter_iterators() {
|
||||
@ -445,9 +424,8 @@ void filter_result_iterator_t::next() {
|
||||
|
||||
seq_id = filter_result.docs[result_index];
|
||||
reference.clear();
|
||||
if (filter_result.reference_filter_results != nullptr &&
|
||||
filter_result.reference_filter_results[result_index] != nullptr) {
|
||||
auto& ref = *filter_result.reference_filter_results[result_index];
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
auto& ref = filter_result.coll_to_references[result_index];
|
||||
reference.insert(ref.begin(), ref.end());
|
||||
}
|
||||
|
||||
@ -703,9 +681,8 @@ void filter_result_iterator_t::init() {
|
||||
}
|
||||
|
||||
seq_id = filter_result.docs[result_index];
|
||||
if (filter_result.reference_filter_results != nullptr &&
|
||||
filter_result.reference_filter_results[result_index] != nullptr) {
|
||||
auto& ref = *filter_result.reference_filter_results[result_index];
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
auto& ref = filter_result.coll_to_references[result_index];
|
||||
reference.insert(ref.begin(), ref.end());
|
||||
}
|
||||
|
||||
@ -1180,9 +1157,8 @@ void filter_result_iterator_t::skip_to(uint32_t id) {
|
||||
|
||||
seq_id = filter_result.docs[result_index];
|
||||
reference.clear();
|
||||
if (filter_result.reference_filter_results != nullptr &&
|
||||
filter_result.reference_filter_results[result_index] != nullptr) {
|
||||
auto& ref = *filter_result.reference_filter_results[result_index];
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
auto& ref = filter_result.coll_to_references[result_index];
|
||||
reference.insert(ref.begin(), ref.end());
|
||||
}
|
||||
|
||||
@ -1415,9 +1391,8 @@ void filter_result_iterator_t::reset() {
|
||||
seq_id = filter_result.docs[result_index];
|
||||
|
||||
reference.clear();
|
||||
if (filter_result.reference_filter_results != nullptr &&
|
||||
filter_result.reference_filter_results[result_index] != nullptr) {
|
||||
auto& ref = *filter_result.reference_filter_results[result_index];
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
auto& ref = filter_result.coll_to_references[result_index];
|
||||
reference.insert(ref.begin(), ref.end());
|
||||
}
|
||||
|
||||
@ -1523,7 +1498,7 @@ void filter_result_iterator_t::and_scalar(const uint32_t* A, const uint32_t& len
|
||||
return;
|
||||
}
|
||||
|
||||
if (filter_result.reference_filter_results == nullptr) {
|
||||
if (filter_result.coll_to_references == nullptr) {
|
||||
if (is_filter_result_initialized) {
|
||||
result.count = ArrayUtils::and_scalar(A, lenA, filter_result.docs, filter_result.count, &result.docs);
|
||||
return;
|
||||
@ -1571,20 +1546,15 @@ void filter_result_iterator_t::and_scalar(const uint32_t* A, const uint32_t& len
|
||||
|
||||
result.count = match_indexes.size();
|
||||
result.docs = new uint32_t[match_indexes.size()];
|
||||
result.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(match_indexes.size());
|
||||
result.coll_to_references = new std::map<std::string, reference_filter_result_t>[match_indexes.size()] {};
|
||||
|
||||
for (uint32_t i = 0; i < match_indexes.size(); i++) {
|
||||
auto const& match_index = match_indexes[i];
|
||||
result.docs[i] = filter_result.docs[match_index];
|
||||
|
||||
if (filter_result.reference_filter_results[match_index] == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto& result_reference = result.reference_filter_results[i];
|
||||
result_reference = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
result_reference->insert(filter_result.reference_filter_results[match_index]->begin(),
|
||||
filter_result.reference_filter_results[match_index]->end());
|
||||
auto& result_reference = result.coll_to_references[i];
|
||||
result_reference.insert(filter_result.coll_to_references[match_index].begin(),
|
||||
filter_result.coll_to_references[match_index].end());
|
||||
}
|
||||
}
|
||||
|
||||
@ -1672,21 +1642,21 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n, filter_result_t*& re
|
||||
|
||||
auto result_length = result->count = std::min(n, filter_result.count - result_index);
|
||||
result->docs = new uint32_t[result_length];
|
||||
if (filter_result.reference_filter_results != nullptr) {
|
||||
result->reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>>[]>(result_length);
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
result->coll_to_references = new std::map<std::string, reference_filter_result_t>[result_length] {};
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < result_length; i++, result_index++) {
|
||||
result->docs[i] = filter_result.docs[result_index];
|
||||
|
||||
if (filter_result.reference_filter_results == nullptr) {
|
||||
if (filter_result.coll_to_references == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto& result_reference = result->reference_filter_results[i];
|
||||
auto& result_reference = result->coll_to_references[i];
|
||||
// Moving references since get_n_ids is only called in wildcard search flow and filter_result_iterator is
|
||||
// not used afterwards.
|
||||
result_reference = std::move(filter_result.reference_filter_results[result_index]);
|
||||
result_reference = std::move(filter_result.coll_to_references[result_index]);
|
||||
}
|
||||
|
||||
is_valid = result_index < filter_result.count;
|
||||
@ -1718,22 +1688,22 @@ void filter_result_iterator_t::get_n_ids(const uint32_t& n,
|
||||
|
||||
result->count = match_indexes.size();
|
||||
result->docs = new uint32_t[match_indexes.size()];
|
||||
if (filter_result.reference_filter_results != nullptr) {
|
||||
result->reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>>[]>(match_indexes.size());
|
||||
if (filter_result.coll_to_references != nullptr) {
|
||||
result->coll_to_references = new std::map<std::string, reference_filter_result_t>[match_indexes.size()] {};
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < match_indexes.size(); i++) {
|
||||
auto const& match_index = match_indexes[i];
|
||||
result->docs[i] = filter_result.docs[match_index];
|
||||
|
||||
if (filter_result.reference_filter_results == nullptr) {
|
||||
if (filter_result.coll_to_references == nullptr) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto& result_reference = result->reference_filter_results[i];
|
||||
auto& result_reference = result->coll_to_references[i];
|
||||
// Moving references since get_n_ids is only called in wildcard search flow and filter_result_iterator is
|
||||
// not used afterwards.
|
||||
result_reference = std::move(filter_result.reference_filter_results[match_index]);
|
||||
result_reference = std::move(filter_result.coll_to_references[match_index]);
|
||||
}
|
||||
|
||||
is_valid = result_index < filter_result.count;
|
||||
|
@ -1732,18 +1732,17 @@ Option<bool> Index::do_reference_filtering_with_lock(filter_node_t* const filter
|
||||
|
||||
filter_result.count = result.size();
|
||||
filter_result.docs = new uint32_t[result.size()];
|
||||
filter_result.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(result.size());
|
||||
filter_result.coll_to_references = new std::map<std::string, reference_filter_result_t>[result.size()] {};
|
||||
|
||||
for (uint32_t result_index = 0; result_index < result.size(); result_index++) {
|
||||
filter_result.docs[result_index] = result[result_index].first;
|
||||
|
||||
auto& reference_result = filter_result.reference_filter_results[result_index];
|
||||
reference_result = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference_result = filter_result.coll_to_references[result_index];
|
||||
|
||||
auto const& references = result[result_index].second;
|
||||
auto r = reference_filter_result_t(references.size(), new uint32_t[references.size()]);
|
||||
std::copy(references.begin(), references.end(), r.docs);
|
||||
(*reference_result)[collection_name] = std::move(r);
|
||||
reference_result[collection_name] = std::move(r);
|
||||
}
|
||||
|
||||
return Option(true);
|
||||
@ -4707,9 +4706,8 @@ Option<bool> Index::do_infix_search(const size_t num_search_fields, const std::v
|
||||
for(size_t i = 0; i < raw_infix_ids_length; i++) {
|
||||
auto seq_id = raw_infix_ids[i];
|
||||
std::map<std::string, reference_filter_result_t> references;
|
||||
if (filtered_infix_ids.reference_filter_results != nullptr &&
|
||||
filtered_infix_ids.reference_filter_results[i] != nullptr) {
|
||||
references = std::move(*filtered_infix_ids.reference_filter_results[i]);
|
||||
if (filtered_infix_ids.coll_to_references != nullptr) {
|
||||
references = std::move(filtered_infix_ids.coll_to_references[i]);
|
||||
}
|
||||
|
||||
int64_t match_score = 0;
|
||||
@ -5093,9 +5091,8 @@ Option<bool> Index::search_wildcard(filter_node_t const* const& filter_tree_root
|
||||
for(size_t i = 0; i < batch_result->count; i++) {
|
||||
const uint32_t seq_id = batch_result->docs[i];
|
||||
std::map<basic_string<char>, reference_filter_result_t> references;
|
||||
if (batch_result->reference_filter_results != nullptr &&
|
||||
batch_result->reference_filter_results[i] != nullptr) {
|
||||
references = std::move(*batch_result->reference_filter_results[i]);
|
||||
if (batch_result->coll_to_references != nullptr) {
|
||||
references = std::move(batch_result->coll_to_references[i]);
|
||||
}
|
||||
|
||||
int64_t match_score = 0;
|
||||
|
@ -651,7 +651,7 @@ TEST_F(CollectionJoinTest, AndFilterResults_NoReference) {
|
||||
filter_result_t::and_filter_results(a, b, result);
|
||||
|
||||
ASSERT_EQ(2, result.count);
|
||||
ASSERT_EQ(nullptr, result.reference_filter_results);
|
||||
ASSERT_EQ(nullptr, result.coll_to_references);
|
||||
|
||||
std::vector<uint32_t> docs = {3, 6};
|
||||
|
||||
@ -664,31 +664,31 @@ TEST_F(CollectionJoinTest, AndFilterResults_WithReferences) {
|
||||
filter_result_t a;
|
||||
a.count = 9;
|
||||
a.docs = new uint32_t[a.count];
|
||||
a.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(a.count);
|
||||
a.coll_to_references = new std::map<std::string, reference_filter_result_t>[a.count] {};
|
||||
|
||||
for (size_t i = 0; i < a.count; i++) {
|
||||
a.docs[i] = i;
|
||||
|
||||
auto& reference = a.reference_filter_results[i] = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference = a.coll_to_references[i];
|
||||
// Having only one reference of each document for brevity.
|
||||
auto reference_docs = new uint32_t[1];
|
||||
reference_docs[0] = 10 - i;
|
||||
(*reference)["foo"] = reference_filter_result_t(1, reference_docs);
|
||||
reference["foo"] = reference_filter_result_t(1, reference_docs);
|
||||
}
|
||||
|
||||
filter_result_t b;
|
||||
b.count = 0;
|
||||
uint32_t limit = 10;
|
||||
b.docs = new uint32_t[limit];
|
||||
b.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(limit);
|
||||
b.coll_to_references = new std::map<std::string, reference_filter_result_t>[limit] {};
|
||||
for (size_t i = 2; i < limit; i++) {
|
||||
if (i % 3 == 0) {
|
||||
b.docs[b.count] = i;
|
||||
|
||||
auto& reference = b.reference_filter_results[b.count++] = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference = b.coll_to_references[b.count++];
|
||||
auto reference_docs = new uint32_t[1];
|
||||
reference_docs[0] = 2 * i;
|
||||
(*reference)["bar"] = reference_filter_result_t(1, reference_docs);
|
||||
reference["bar"] = reference_filter_result_t(1, reference_docs);
|
||||
}
|
||||
}
|
||||
|
||||
@ -697,9 +697,9 @@ TEST_F(CollectionJoinTest, AndFilterResults_WithReferences) {
|
||||
filter_result_t::and_filter_results(a, b, result);
|
||||
|
||||
ASSERT_EQ(2, result.count);
|
||||
ASSERT_EQ(2, result.reference_filter_results[0]->size());
|
||||
ASSERT_EQ(1, result.reference_filter_results[0]->count("foo"));
|
||||
ASSERT_EQ(1, result.reference_filter_results[0]->count("bar"));
|
||||
ASSERT_EQ(2, result.coll_to_references[0].size());
|
||||
ASSERT_EQ(1, result.coll_to_references[0].count("foo"));
|
||||
ASSERT_EQ(1, result.coll_to_references[0].count("bar"));
|
||||
|
||||
std::vector<uint32_t> docs = {3, 6}, foo_reference = {7, 4}, bar_reference = {6, 12};
|
||||
|
||||
@ -707,10 +707,10 @@ TEST_F(CollectionJoinTest, AndFilterResults_WithReferences) {
|
||||
ASSERT_EQ(docs[i], result.docs[i]);
|
||||
|
||||
// result should contain correct references to the foo and bar collection.
|
||||
ASSERT_EQ(1, result.reference_filter_results[i]->at("foo").count);
|
||||
ASSERT_EQ(foo_reference[i], result.reference_filter_results[i]->at("foo").docs[0]);
|
||||
ASSERT_EQ(1, result.reference_filter_results[i]->at("bar").count);
|
||||
ASSERT_EQ(bar_reference[i], result.reference_filter_results[i]->at("bar").docs[0]);
|
||||
ASSERT_EQ(1, result.coll_to_references[i].at("foo").count);
|
||||
ASSERT_EQ(foo_reference[i], result.coll_to_references[i].at("foo").docs[0]);
|
||||
ASSERT_EQ(1, result.coll_to_references[i].at("bar").count);
|
||||
ASSERT_EQ(bar_reference[i], result.coll_to_references[i].at("bar").docs[0]);
|
||||
}
|
||||
}
|
||||
|
||||
@ -729,7 +729,7 @@ TEST_F(CollectionJoinTest, OrFilterResults_NoReference) {
|
||||
filter_result_t result1;
|
||||
filter_result_t::or_filter_results(a, b, result1);
|
||||
ASSERT_EQ(3, result1.count);
|
||||
ASSERT_EQ(nullptr, result1.reference_filter_results);
|
||||
ASSERT_EQ(nullptr, result1.coll_to_references);
|
||||
|
||||
std::vector<uint32_t> expected = {3, 6, 9};
|
||||
for (size_t i = 0; i < result1.count; i++) {
|
||||
@ -746,7 +746,7 @@ TEST_F(CollectionJoinTest, OrFilterResults_NoReference) {
|
||||
filter_result_t result2;
|
||||
filter_result_t::or_filter_results(a, b, result2);
|
||||
ASSERT_EQ(10, result2.count);
|
||||
ASSERT_EQ(nullptr, result2.reference_filter_results);
|
||||
ASSERT_EQ(nullptr, result2.coll_to_references);
|
||||
|
||||
expected = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
for (size_t i = 0; i < result2.count; i++) {
|
||||
@ -766,7 +766,7 @@ TEST_F(CollectionJoinTest, OrFilterResults_NoReference) {
|
||||
// b.docs: [0..8], c.docs: [0, 4, 5]
|
||||
filter_result_t::or_filter_results(b, c, result3);
|
||||
ASSERT_EQ(9, result3.count);
|
||||
ASSERT_EQ(nullptr, result3.reference_filter_results);
|
||||
ASSERT_EQ(nullptr, result3.coll_to_references);
|
||||
|
||||
expected = {0, 1, 2, 3, 4, 5, 6, 7, 8};
|
||||
for(size_t i = 0; i < result3.count; i++) {
|
||||
@ -780,15 +780,15 @@ TEST_F(CollectionJoinTest, OrFilterResults_WithReferences) {
|
||||
|
||||
a.count = 0;
|
||||
a.docs = new uint32_t[limit];
|
||||
a.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(limit);
|
||||
a.coll_to_references = new std::map<std::string, reference_filter_result_t>[limit] {};
|
||||
for (size_t i = 2; i < limit; i++) {
|
||||
if (i % 3 == 0) {
|
||||
a.docs[a.count] = i;
|
||||
|
||||
auto& reference = a.reference_filter_results[a.count++] = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference = a.coll_to_references[a.count++];
|
||||
auto reference_docs = new uint32_t[1];
|
||||
reference_docs[0] = 2 * i;
|
||||
(*reference)["foo"] = reference_filter_result_t(1, reference_docs);
|
||||
reference["foo"] = reference_filter_result_t(1, reference_docs);
|
||||
}
|
||||
}
|
||||
|
||||
@ -797,27 +797,27 @@ TEST_F(CollectionJoinTest, OrFilterResults_WithReferences) {
|
||||
filter_result_t::or_filter_results(a, b, result1);
|
||||
|
||||
ASSERT_EQ(3, result1.count);
|
||||
ASSERT_EQ(1, result1.reference_filter_results[0]->size());
|
||||
ASSERT_EQ(1, result1.reference_filter_results[0]->count("foo"));
|
||||
ASSERT_EQ(1, result1.coll_to_references[0].size());
|
||||
ASSERT_EQ(1, result1.coll_to_references[0].count("foo"));
|
||||
|
||||
std::vector<uint32_t> expected = {3, 6, 9}, foo_reference = {6, 12, 18};
|
||||
for (size_t i = 0; i < result1.count; i++) {
|
||||
ASSERT_EQ(expected[i], result1.docs[i]);
|
||||
|
||||
ASSERT_EQ(1, result1.reference_filter_results[i]->at("foo").count);
|
||||
ASSERT_EQ(foo_reference[i], result1.reference_filter_results[i]->at("foo").docs[0]);
|
||||
ASSERT_EQ(1, result1.coll_to_references[i].at("foo").count);
|
||||
ASSERT_EQ(foo_reference[i], result1.coll_to_references[i].at("foo").docs[0]);
|
||||
}
|
||||
|
||||
b.count = 9;
|
||||
b.docs = new uint32_t[b.count];
|
||||
b.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(b.count);
|
||||
b.coll_to_references = new std::map<std::string, reference_filter_result_t>[b.count] {};
|
||||
for (size_t i = 0; i < b.count; i++) {
|
||||
b.docs[i] = i;
|
||||
|
||||
auto& reference = b.reference_filter_results[i] = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference = b.coll_to_references[i];
|
||||
auto reference_docs = new uint32_t[1];
|
||||
reference_docs[0] = 10 - i;
|
||||
(*reference)["bar"] = reference_filter_result_t(1, reference_docs);
|
||||
reference["bar"] = reference_filter_result_t(1, reference_docs);
|
||||
}
|
||||
|
||||
// a.docs: [3, 6, 9], b.docs: [0..8]
|
||||
@ -834,18 +834,18 @@ TEST_F(CollectionJoinTest, OrFilterResults_WithReferences) {
|
||||
ASSERT_EQ(expected[i], result2.docs[i]);
|
||||
|
||||
if (foo_map.count(i) != 0) {
|
||||
ASSERT_EQ(1, result2.reference_filter_results[i]->at("foo").count);
|
||||
ASSERT_EQ(foo_map[i], result2.reference_filter_results[i]->at("foo").docs[0]);
|
||||
ASSERT_EQ(1, result2.coll_to_references[i].at("foo").count);
|
||||
ASSERT_EQ(foo_map[i], result2.coll_to_references[i].at("foo").docs[0]);
|
||||
} else {
|
||||
// foo didn't have any reference to current doc.
|
||||
ASSERT_EQ(0, result2.reference_filter_results[i]->count("foo"));
|
||||
ASSERT_EQ(0, result2.coll_to_references[i].count("foo"));
|
||||
}
|
||||
|
||||
if (bar_map.count(i) != 0) {
|
||||
ASSERT_EQ(1, result2.reference_filter_results[i]->at("bar").count);
|
||||
ASSERT_EQ(bar_map[i], result2.reference_filter_results[i]->at("bar").docs[0]);
|
||||
ASSERT_EQ(1, result2.coll_to_references[i].at("bar").count);
|
||||
ASSERT_EQ(bar_map[i], result2.coll_to_references[i].at("bar").docs[0]);
|
||||
} else {
|
||||
ASSERT_EQ(0, result2.reference_filter_results[i]->count("bar"));
|
||||
ASSERT_EQ(0, result2.coll_to_references[i].count("bar"));
|
||||
}
|
||||
}
|
||||
|
||||
@ -854,15 +854,15 @@ TEST_F(CollectionJoinTest, OrFilterResults_WithReferences) {
|
||||
std::map<uint32_t, uint32_t> baz_map = {{0, 2}, {4, 0}, {5, 8}};
|
||||
c.count = baz_map.size();
|
||||
c.docs = new uint32_t[baz_map.size()];
|
||||
c.reference_filter_results = std::make_unique<std::unique_ptr<std::map<std::string, reference_filter_result_t>> []>(baz_map.size());
|
||||
c.coll_to_references = new std::map<std::string, reference_filter_result_t>[baz_map.size()] {};
|
||||
auto j = 0;
|
||||
for(auto i: baz_map) {
|
||||
c.docs[j] = i.first;
|
||||
|
||||
auto& reference = c.reference_filter_results[j++] = std::make_unique<std::map<std::string, reference_filter_result_t>>();
|
||||
auto& reference = c.coll_to_references[j++];
|
||||
auto reference_docs = new uint32_t[1];
|
||||
reference_docs[0] = i.second;
|
||||
(*reference)["baz"] = reference_filter_result_t(1, reference_docs);
|
||||
reference["baz"] = reference_filter_result_t(1, reference_docs);
|
||||
}
|
||||
|
||||
// b.docs: [0..8], c.docs: [0, 4, 5]
|
||||
@ -874,17 +874,17 @@ TEST_F(CollectionJoinTest, OrFilterResults_WithReferences) {
|
||||
ASSERT_EQ(expected[i], result3.docs[i]);
|
||||
|
||||
if (bar_map.count(i) != 0) {
|
||||
ASSERT_EQ(1, result3.reference_filter_results[i]->at("bar").count);
|
||||
ASSERT_EQ(bar_map[i], result3.reference_filter_results[i]->at("bar").docs[0]);
|
||||
ASSERT_EQ(1, result3.coll_to_references[i].at("bar").count);
|
||||
ASSERT_EQ(bar_map[i], result3.coll_to_references[i].at("bar").docs[0]);
|
||||
} else {
|
||||
ASSERT_EQ(0, result3.reference_filter_results[i]->count("bar"));
|
||||
ASSERT_EQ(0, result3.coll_to_references[i].count("bar"));
|
||||
}
|
||||
|
||||
if (baz_map.count(i) != 0) {
|
||||
ASSERT_EQ(1, result3.reference_filter_results[i]->at("baz").count);
|
||||
ASSERT_EQ(baz_map[i], result3.reference_filter_results[i]->at("baz").docs[0]);
|
||||
ASSERT_EQ(1, result3.coll_to_references[i].at("baz").count);
|
||||
ASSERT_EQ(baz_map[i], result3.coll_to_references[i].at("baz").docs[0]);
|
||||
} else {
|
||||
ASSERT_EQ(0, result3.reference_filter_results[i]->count("baz"));
|
||||
ASSERT_EQ(0, result3.coll_to_references[i].count("baz"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user