Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Numeric filters refactor. (#1951)

Harpreet Sangarae725e9d2909
diff --git a/include/filter.h b/include/filter.h
index 59d6fce4..76f8c047 100644
--- a/include/filter.h
+++ b/include/filter.h
@@ -6,6 +6,8 @@
#include "json.hpp"
#include "store.h"
+constexpr uint32_t COMPUTE_FILTER_ITERATOR_THRESHOLD = 25'000;
+
enum NUM_COMPARATOR {
LESS_THAN,
LESS_THAN_EQUALS,
diff --git a/include/filter_result_iterator.h b/include/filter_result_iterator.h
index 08bbb5a7..e6ff51c9 100644
--- a/include/filter_result_iterator.h
+++ b/include/filter_result_iterator.h
@@ -295,7 +295,7 @@ private:
std::unique_ptr<filter_result_iterator_timeout_info> timeout_info;
/// Initializes the state of iterator node after it's creation.
- void init();
+ void init(const bool& enable_lazy_evaluation = false);
/// Performs AND on the subtrees of operator.
void and_filter_iterators();
@@ -351,6 +351,7 @@ public:
explicit filter_result_iterator_t(const std::string& collection_name,
Index const* const index, filter_node_t const* const filter_node,
+ const bool& enable_lazy_evaluation = false,
uint64_t search_begin_us = 0, uint64_t search_stop_us = UINT64_MAX);
~filter_result_iterator_t();
diff --git a/src/filter_result_iterator.cpp b/src/filter_result_iterator.cpp
index 0f3c8cd1..c670cbbf 100644
--- a/src/filter_result_iterator.cpp
+++ b/src/filter_result_iterator.cpp
@@ -753,22 +753,26 @@ void apply_not_equals(uint32_t*&& all_ids,
result_ids_len = to_include_ids_len;
}
-void filter_result_iterator_t::init() {
+void filter_result_iterator_t::init(const bool& enable_lazy_evaluation) {
if (filter_node == nullptr) {
return;
}
if (filter_node->isOperator) {
if (filter_node->filter_operator == AND) {
- and_filter_iterators();
approx_filter_ids_length = std::min(left_it->approx_filter_ids_length, right_it->approx_filter_ids_length);
+ if (approx_filter_ids_length < COMPUTE_FILTER_ITERATOR_THRESHOLD) {
+ compute_iterators();
+ } else {
+ and_filter_iterators();
+ }
} else {
or_filter_iterators();
approx_filter_ids_length = std::max(left_it->approx_filter_ids_length, right_it->approx_filter_ids_length);
}
// Rearranging the subtree in hope to reduce computation if/when compute_iterators() is called.
- if (left_it->approx_filter_ids_length > right_it->approx_filter_ids_length) {
+ if (!is_filter_result_initialized && left_it->approx_filter_ids_length > right_it->approx_filter_ids_length) {
std::swap(left_it, right_it);
}
@@ -902,6 +906,233 @@ void filter_result_iterator_t::init() {
field f = index->search_schema.at(a_filter.field_name);
+ if (!enable_lazy_evaluation && (f.is_integer() || f.is_float() || f.is_bool())) {
+ if (f.is_integer()) {
+ if (f.range_index) {
+ auto const& trie = index->range_index.at(a_filter.field_name);
+
+ for (size_t fi = 0; fi < a_filter.values.size(); fi++) {
+ const std::string& filter_value = a_filter.values[fi];
+ auto const& value = (int64_t)std::stol(filter_value);
+
+ if (a_filter.comparators[fi] == RANGE_INCLUSIVE && fi+1 < a_filter.values.size()) {
+ const std::string& next_filter_value = a_filter.values[fi + 1];
+ auto const& range_end_value = (int64_t)std::stol(next_filter_value);
+ trie->search_range(value, true, range_end_value, true, filter_result.docs, filter_result.count);
+ fi++;
+ } else if (a_filter.comparators[fi] == EQUALS) {
+ trie->search_equal_to(value, filter_result.docs, filter_result.count);
+ } else if (a_filter.comparators[fi] == NOT_EQUALS) {
+ uint32_t* to_exclude_ids = nullptr;
+ uint32_t to_exclude_ids_len = 0;
+ trie->search_equal_to(value, to_exclude_ids, to_exclude_ids_len);
+
+ auto all_ids = index->seq_ids->uncompress();
+ filter_result.count = ArrayUtils::exclude_scalar(all_ids, index->seq_ids->num_ids(),
+ to_exclude_ids, to_exclude_ids_len, &filter_result.docs);
+
+ delete[] all_ids;
+ delete[] to_exclude_ids;
+ } else if (a_filter.comparators[fi] == GREATER_THAN || a_filter.comparators[fi] == GREATER_THAN_EQUALS) {
+ trie->search_greater_than(value, a_filter.comparators[fi] == GREATER_THAN_EQUALS,
+ filter_result.docs, filter_result.count);
+ } else if (a_filter.comparators[fi] == LESS_THAN || a_filter.comparators[fi] == LESS_THAN_EQUALS) {
+ trie->search_less_than(value, a_filter.comparators[fi] == LESS_THAN_EQUALS,
+ filter_result.docs, filter_result.count);
+ }
+ }
+ } else {
+ auto num_tree = index->numerical_index.at(a_filter.field_name);
+
+ for (size_t fi = 0; fi < a_filter.values.size(); fi++) {
+ const std::string& filter_value = a_filter.values[fi];
+ int64_t value = (int64_t)std::stol(filter_value);
+
+ size_t result_size = filter_result.count;
+ if (a_filter.comparators[fi] == RANGE_INCLUSIVE && fi+1 < a_filter.values.size()) {
+ const std::string& next_filter_value = a_filter.values[fi + 1];
+ auto const range_end_value = (int64_t)std::stol(next_filter_value);
+ num_tree->range_inclusive_search(value, range_end_value, &filter_result.docs, result_size);
+ fi++;
+ } else if (a_filter.comparators[fi] == NOT_EQUALS) {
+ numeric_not_equals_filter(num_tree, value,
+ index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, result_size);
+ } else {
+ num_tree->search(a_filter.comparators[fi], value, &filter_result.docs, result_size);
+ }
+
+ filter_result.count = result_size;
+ }
+ }
+
+ if (a_filter.apply_not_equals) {
+ apply_not_equals(index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, filter_result.count);
+ }
+
+ if (filter_result.count == 0) {
+ validity = invalid;
+ return;
+ }
+
+ seq_id = filter_result.docs[result_index];
+ is_filter_result_initialized = true;
+ approx_filter_ids_length = filter_result.count;
+ return;
+ } else if (f.is_float()) {
+ if (f.range_index) {
+ auto const& trie = index->range_index.at(a_filter.field_name);
+
+ for (size_t fi = 0; fi < a_filter.values.size(); fi++) {
+ const std::string& filter_value = a_filter.values[fi];
+ float value = (float)std::atof(filter_value.c_str());
+ int64_t float_int64 = Index::float_to_int64_t(value);
+
+ if (a_filter.comparators[fi] == RANGE_INCLUSIVE && fi+1 < a_filter.values.size()) {
+ const std::string& next_filter_value = a_filter.values[fi + 1];
+ int64_t range_end_value = Index::float_to_int64_t((float) std::atof(next_filter_value.c_str()));
+ trie->search_range(float_int64, true, range_end_value, true, filter_result.docs, filter_result.count);
+ fi++;
+ } else if (a_filter.comparators[fi] == EQUALS) {
+ trie->search_equal_to(float_int64, filter_result.docs, filter_result.count);
+ } else if (a_filter.comparators[fi] == NOT_EQUALS) {
+ uint32_t* to_exclude_ids = nullptr;
+ uint32_t to_exclude_ids_len = 0;
+ trie->search_equal_to(float_int64, to_exclude_ids, to_exclude_ids_len);
+
+ auto all_ids = index->seq_ids->uncompress();
+ filter_result.count = ArrayUtils::exclude_scalar(all_ids, index->seq_ids->num_ids(),
+ to_exclude_ids, to_exclude_ids_len, &filter_result.docs);
+
+ delete[] all_ids;
+ delete[] to_exclude_ids;
+ } else if (a_filter.comparators[fi] == GREATER_THAN || a_filter.comparators[fi] == GREATER_THAN_EQUALS) {
+ trie->search_greater_than(float_int64, a_filter.comparators[fi] == GREATER_THAN_EQUALS,
+ filter_result.docs, filter_result.count);
+ } else if (a_filter.comparators[fi] == LESS_THAN || a_filter.comparators[fi] == LESS_THAN_EQUALS) {
+ trie->search_less_than(float_int64, a_filter.comparators[fi] == LESS_THAN_EQUALS,
+ filter_result.docs, filter_result.count);
+ }
+ }
+ } else {
+ auto num_tree = index->numerical_index.at(a_filter.field_name);
+
+ for (size_t fi = 0; fi < a_filter.values.size(); fi++) {
+ const std::string& filter_value = a_filter.values[fi];
+ float value = (float)std::atof(filter_value.c_str());
+ int64_t float_int64 = Index::float_to_int64_t(value);
+
+ size_t result_size = filter_result.count;
+ if (a_filter.comparators[fi] == RANGE_INCLUSIVE && fi+1 < a_filter.values.size()) {
+ const std::string& next_filter_value = a_filter.values[fi+1];
+ int64_t range_end_value = Index::float_to_int64_t((float) std::atof(next_filter_value.c_str()));
+ num_tree->range_inclusive_search(float_int64, range_end_value, &filter_result.docs, result_size);
+ fi++;
+ } else if (a_filter.comparators[fi] == NOT_EQUALS) {
+ numeric_not_equals_filter(num_tree, float_int64,
+ index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, result_size);
+ } else {
+ num_tree->search(a_filter.comparators[fi], float_int64, &filter_result.docs, result_size);
+ }
+
+ filter_result.count = result_size;
+ }
+ }
+
+ if (a_filter.apply_not_equals) {
+ apply_not_equals(index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, filter_result.count);
+ }
+
+ if (filter_result.count == 0) {
+ validity = invalid;
+ return;
+ }
+
+ seq_id = filter_result.docs[result_index];
+ is_filter_result_initialized = true;
+ approx_filter_ids_length = filter_result.count;
+ return;
+ } else if (f.is_bool()) {
+ if (f.range_index) {
+
+ auto const& trie = index->range_index.at(a_filter.field_name);
+
+ size_t value_index = 0;
+ for (const std::string& filter_value : a_filter.values) {
+ int64_t bool_int64 = (filter_value == "1") ? 1 : 0;
+
+ if (a_filter.comparators[value_index] == EQUALS) {
+ trie->search_equal_to(bool_int64, filter_result.docs, filter_result.count);
+ } else if (a_filter.comparators[value_index] == NOT_EQUALS) {
+ uint32_t* to_exclude_ids = nullptr;
+ uint32_t to_exclude_ids_len = 0;
+ trie->search_equal_to(bool_int64, to_exclude_ids, to_exclude_ids_len);
+
+ auto all_ids = index->seq_ids->uncompress();
+ filter_result.count = ArrayUtils::exclude_scalar(all_ids, index->seq_ids->num_ids(),
+ to_exclude_ids, to_exclude_ids_len, &filter_result.docs);
+
+ delete[] all_ids;
+ delete[] to_exclude_ids;
+ }
+
+ value_index++;
+ }
+ } else {
+ auto num_tree = index->numerical_index.at(a_filter.field_name);
+
+ // For a boolean filter like `in_stock: true` that could match a large number of ids, we use bool_iterator.
+ if (a_filter.values.size() == 1 && a_filter.comparators[0] == EQUALS && !a_filter.apply_not_equals &&
+ num_tree->approx_search_count(EQUALS, (a_filter.values[0] == "1" ? 1 : 0)) > bool_filter_ids_threshold) {
+ bool_iterator = num_tree_t::iterator_t(num_tree, EQUALS, (a_filter.values[0] == "1" ? 1 : 0));
+ if (!bool_iterator.is_valid) {
+ validity = invalid;
+ return;
+ }
+
+ seq_id = bool_iterator.seq_id;
+ approx_filter_ids_length = bool_iterator.approx_filter_ids_length;
+ return;
+ }
+
+ size_t value_index = 0;
+ for (const std::string& filter_value : a_filter.values) {
+ int64_t bool_int64 = (filter_value == "1") ? 1 : 0;
+
+ size_t result_size = filter_result.count;
+ if (a_filter.comparators[value_index] == NOT_EQUALS) {
+ numeric_not_equals_filter(num_tree, bool_int64,
+ index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, result_size);
+ } else {
+ num_tree->search(a_filter.comparators[value_index], bool_int64, &filter_result.docs, result_size);
+ }
+
+ filter_result.count = result_size;
+ value_index++;
+ }
+ }
+
+ if (a_filter.apply_not_equals) {
+ apply_not_equals(index->seq_ids->uncompress(), index->seq_ids->num_ids(),
+ filter_result.docs, filter_result.count);
+ }
+
+ if (filter_result.count == 0) {
+ validity = invalid;
+ return;
+ }
+
+ seq_id = filter_result.docs[result_index];
+ is_filter_result_initialized = true;
+ approx_filter_ids_length = filter_result.count;
+ return;
+ }
+ }
+
if (f.is_integer()) {
if (f.range_index) {
auto const& trie = index->range_index.at(a_filter.field_name);
@@ -2129,6 +2360,7 @@ void filter_result_iterator_t::and_scalar(const uint32_t* A, const uint32_t& len
filter_result_iterator_t::filter_result_iterator_t(const std::string& collection_name, const Index *const index,
const filter_node_t *const filter_node,
+ const bool& enable_lazy_evaluation,
uint64_t search_begin, uint64_t search_stop) :
collection_name(collection_name),
index(index),
@@ -2145,7 +2377,7 @@ filter_result_iterator_t::filter_result_iterator_t(const std::string& collection
// Generate the iterator tree and then initialize each node.
if (filter_node->isOperator) {
- left_it = new filter_result_iterator_t(collection_name, index, filter_node->left);
+ left_it = new filter_result_iterator_t(collection_name, index, filter_node->left, enable_lazy_evaluation);
// If left subtree of && operator is invalid, we don't have to evaluate its right subtree.
if (filter_node->filter_operator == AND && left_it->validity == invalid) {
validity = invalid;
@@ -2155,10 +2387,10 @@ filter_result_iterator_t::filter_result_iterator_t(const std::string& collection
return;
}
- right_it = new filter_result_iterator_t(collection_name, index, filter_node->right);
+ right_it = new filter_result_iterator_t(collection_name, index, filter_node->right, enable_lazy_evaluation);
}
- init();
+ init(enable_lazy_evaluation);
if (!validity) {
this->approx_filter_ids_length = 0;
diff --git a/src/index.cpp b/src/index.cpp
index 778f6a47..cf49a410 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -1805,7 +1805,7 @@ Option<bool> Index::do_filtering_with_lock(filter_node_t* const filter_tree_root
const bool& should_timeout) const {
std::shared_lock lock(mutex);
- auto filter_result_iterator = filter_result_iterator_t(collection_name, this, filter_tree_root,
+ auto filter_result_iterator = filter_result_iterator_t(collection_name, this, filter_tree_root, false,
search_begin_us, should_timeout ? search_stop_us : UINT64_MAX);
auto filter_init_op = filter_result_iterator.init_status();
if (!filter_init_op.ok()) {
@@ -1865,7 +1865,7 @@ Option<bool> Index::do_reference_filtering_with_lock(filter_node_t* const filter
const std::string& field_name) const {
std::shared_lock lock(mutex);
- auto ref_filter_result_iterator = filter_result_iterator_t(ref_collection_name, this, filter_tree_root,
+ auto ref_filter_result_iterator = filter_result_iterator_t(ref_collection_name, this, filter_tree_root, false,
search_begin_us, search_stop_us);
auto filter_init_op = ref_filter_result_iterator.init_status();
if (!filter_init_op.ok()) {
@@ -2889,7 +2889,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
std::shared_lock lock(mutex);
auto filter_result_iterator = new filter_result_iterator_t(collection_name, this, filter_tree_root,
- search_begin_us, search_stop_us);
+ enable_lazy_filter, search_begin_us, search_stop_us);
std::unique_ptr<filter_result_iterator_t> filter_iterator_guard(filter_result_iterator);
auto filter_init_op = filter_result_iterator->init_status();
@@ -2904,7 +2904,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
}
#else
- if (!enable_lazy_filter || filter_result_iterator->approx_filter_ids_length < 25'000) {
+ if (!enable_lazy_filter || filter_result_iterator->approx_filter_ids_length < COMPUTE_FILTER_ITERATOR_THRESHOLD) {
filter_result_iterator->compute_iterators();
}
#endif
@@ -6367,7 +6367,7 @@ Option<bool> Index::populate_sort_mapping(int* sort_order, std::vector<size_t>&
auto& eval_exp = sort_fields_std[i].eval;
auto count = sort_fields_std[i].eval_expressions.size();
for (uint32_t j = 0; j < count; j++) {
- auto filter_result_iterator = filter_result_iterator_t("", this, eval_exp.filter_trees[j],
+ auto filter_result_iterator = filter_result_iterator_t("", this, eval_exp.filter_trees[j], false,
search_begin_us, search_stop_us);
auto filter_init_op = filter_result_iterator.init_status();
if (!filter_init_op.ok()) {
diff --git a/test/filter_test.cpp b/test/filter_test.cpp
index 88f7b6cd..eff5362b 100644
--- a/test/filter_test.cpp
+++ b/test/filter_test.cpp
@@ -63,7 +63,9 @@ TEST_F(FilterTest, FilterTreeIterator) {
const std::string doc_id_prefix = std::to_string(coll->get_collection_id()) + "_" + Collection::DOC_ID_PREFIX + "_";
filter_node_t* filter_tree_root = nullptr;
- auto iter_null_filter_tree_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto const enable_lazy_evaluation = true;
+ auto iter_null_filter_tree_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_null_filter_tree_test.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_null_filter_tree_test.validity);
@@ -72,7 +74,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_no_match_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_no_match_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_no_match_test.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_no_match_test.validity);
@@ -83,7 +86,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_no_match_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_no_match_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_no_match_multi_test.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_no_match_multi_test.validity);
@@ -94,7 +98,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_contains_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_contains_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_contains_test.init_status().ok());
for (uint32_t i = 0; i < 5; i++) {
@@ -110,7 +115,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_contains_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_contains_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_contains_multi_test.init_status().ok());
for (uint32_t i = 0; i < 5; i++) {
@@ -126,7 +132,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_exact_match_1_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_exact_match_1_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_exact_match_1_test.init_status().ok());
for (uint32_t i = 0; i < 5; i++) {
@@ -142,7 +149,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_exact_match_2_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_exact_match_2_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_exact_match_2_test.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_exact_match_2_test.validity);
@@ -152,7 +160,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_exact_match_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_exact_match_multi_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_exact_match_multi_test.init_status().ok());
std::vector<int> expected = {0, 2, 3, 4};
@@ -169,7 +178,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_test.init_status().ok());
expected = {1, 3};
@@ -198,7 +208,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
auto add_op = coll->add(doc.dump());
ASSERT_TRUE(add_op.ok());
- auto iter_or_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_or_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_or_test.init_status().ok());
expected = {2, 4, 5};
@@ -216,7 +227,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_complex_filter_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_complex_filter_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_complex_filter_test.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::valid, iter_complex_filter_test.validity);
@@ -238,7 +250,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_validate_ids_test1 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_validate_ids_test1 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_validate_ids_test1.init_status().ok());
std::vector<int> validate_ids = {0, 1, 2, 3, 4, 5, 6};
@@ -255,7 +268,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_validate_ids_test2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_validate_ids_test2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_validate_ids_test2.init_status().ok());
validate_ids = {0, 1, 2, 3, 4, 5, 6}, seq_ids = {1, 1, 5, 5, 5, 5, 5};
@@ -271,10 +285,12 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_validate_ids_test3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_validate_ids_test3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_validate_ids_test3.init_status().ok());
+ ASSERT_TRUE(iter_validate_ids_test3._get_is_filter_result_initialized());
- validate_ids = {0, 1, 2, 3, 4, 5, 6}, seq_ids = {0, 3, 3, 4, 4, 4, 4};
+ validate_ids = {0, 1, 2, 3, 4, 5, 6}, seq_ids = {0, 4, 4, 4, 4, 4, 4};
expected = {1, 0, 0, 0, 1, -1, -1};
for (uint32_t i = 0; i < validate_ids.size(); i++) {
ASSERT_EQ(expected[i], iter_validate_ids_test3.is_valid(validate_ids[i]));
@@ -288,7 +304,7 @@ TEST_F(FilterTest, FilterTreeIterator) {
ASSERT_TRUE(filter_op.ok());
auto iter_compact_plist_contains_atleast_one_test1 = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_compact_plist_contains_atleast_one_test1.init_status().ok());
std::vector<uint32_t> ids = {1, 3, 5};
@@ -300,7 +316,7 @@ TEST_F(FilterTest, FilterTreeIterator) {
free(c_list1);
auto iter_compact_plist_contains_atleast_one_test2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_compact_plist_contains_atleast_one_test2.init_status().ok());
ids = {1, 3, 4};
@@ -312,7 +328,7 @@ TEST_F(FilterTest, FilterTreeIterator) {
free(c_list2);
auto iter_plist_contains_atleast_one_test1 = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_plist_contains_atleast_one_test1.init_status().ok());
posting_list_t p_list1(2);
@@ -341,7 +357,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_reset_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_reset_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_reset_test.init_status().ok());
expected = {0, 2, 3, 4};
@@ -361,7 +378,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
}
ASSERT_EQ(filter_result_iterator_t::invalid, iter_reset_test.validity);
- auto iter_move_assignment_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_move_assignment_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
iter_reset_test.reset();
iter_move_assignment_test = std::move(iter_reset_test);
@@ -380,7 +398,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_to_array_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_to_array_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_to_array_test.init_status().ok());
uint32_t* filter_ids = nullptr;
@@ -397,7 +416,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
delete[] filter_ids;
- auto iter_and_scalar_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_and_scalar_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_and_scalar_test.init_status().ok());
uint32_t a_ids[6] = {0, 1, 3, 4, 5, 6};
@@ -429,7 +449,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_op = filter::parse_filter_query("tags: bronze", coll->get_schema(), store, doc_id_prefix,
filter_tree_root);
- auto iter_add_phrase_ids_test = new filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_add_phrase_ids_test = new filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
std::unique_ptr<filter_result_iterator_t> filter_iter_guard(iter_add_phrase_ids_test);
ASSERT_TRUE(iter_add_phrase_ids_test->init_status().ok());
@@ -450,7 +471,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_multi_value_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_multi_value_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_multi_value_test.init_status().ok());
ASSERT_FALSE(iter_string_multi_value_test._get_is_filter_result_initialized());
@@ -468,7 +490,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_equals_test.init_status().ok());
ASSERT_TRUE(iter_string_equals_test._get_is_filter_result_initialized());
@@ -487,7 +510,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_equals_test_2.init_status().ok());
ASSERT_FALSE(iter_string_equals_test_2._get_is_filter_result_initialized());
@@ -504,7 +528,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_op = filter::parse_filter_query("tags: != [gold, silver]", coll->get_schema(), store, doc_id_prefix,
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_not_equals_test_2.init_status().ok());
ASSERT_TRUE(iter_string_not_equals_test_2._get_is_filter_result_initialized());
@@ -557,7 +582,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_boolean_test = filter_result_iterator_t(bool_coll->get_name(), bool_coll->_get_index(), filter_tree_root);
+ auto iter_boolean_test = filter_result_iterator_t(bool_coll->get_name(), bool_coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_boolean_test.init_status().ok());
ASSERT_TRUE(iter_boolean_test._get_is_filter_result_initialized());
ASSERT_EQ(2, iter_boolean_test.approx_filter_ids_length);
@@ -576,7 +602,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_boolean_test_2 = filter_result_iterator_t(bool_coll->get_name(), bool_coll->_get_index(), filter_tree_root);
+ auto iter_boolean_test_2 = filter_result_iterator_t(bool_coll->get_name(), bool_coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_boolean_test_2.init_status().ok());
ASSERT_FALSE(iter_boolean_test_2._get_is_filter_result_initialized());
ASSERT_EQ(8, iter_boolean_test_2.approx_filter_ids_length);
@@ -628,7 +655,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_prefix_value_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_prefix_value_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_prefix_value_test.init_status().ok());
ASSERT_FALSE(iter_string_prefix_value_test._get_is_filter_result_initialized());
ASSERT_EQ(3, iter_string_prefix_value_test.approx_filter_ids_length); // document 0 and 2 have been deleted.
@@ -647,7 +675,8 @@ TEST_F(FilterTest, FilterTreeIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_prefix_value_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_prefix_value_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_prefix_value_test_2.init_status().ok());
ASSERT_FALSE(iter_string_prefix_value_test_2._get_is_filter_result_initialized());
ASSERT_EQ(4, iter_string_prefix_value_test_2.approx_filter_ids_length); // 7 total docs, 3 approx count for equals.
@@ -752,7 +781,9 @@ TEST_F(FilterTest, FilterTreeInitialization) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_left_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto const enable_lazy_evaluation = true;
+ auto iter_left_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_left_subtree_0_matches.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_left_subtree_0_matches.validity);
@@ -768,14 +799,15 @@ TEST_F(FilterTest, FilterTreeInitialization) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_right_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_right_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_right_subtree_0_matches.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_right_subtree_0_matches.validity);
ASSERT_EQ(0, iter_right_subtree_0_matches.approx_filter_ids_length);
- ASSERT_FALSE(iter_right_subtree_0_matches._get_is_filter_result_initialized());
- ASSERT_NE(nullptr, iter_right_subtree_0_matches._get_left_it());
- ASSERT_NE(nullptr, iter_right_subtree_0_matches._get_right_it());
+ ASSERT_TRUE(iter_right_subtree_0_matches._get_is_filter_result_initialized());
+ ASSERT_EQ(nullptr, iter_right_subtree_0_matches._get_left_it());
+ ASSERT_EQ(nullptr, iter_right_subtree_0_matches._get_right_it());
delete filter_tree_root;
filter_tree_root = nullptr;
@@ -784,7 +816,8 @@ TEST_F(FilterTest, FilterTreeInitialization) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_inner_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_inner_subtree_0_matches = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_inner_subtree_0_matches.init_status().ok());
ASSERT_EQ(filter_result_iterator_t::invalid, iter_inner_subtree_0_matches.validity);
@@ -824,7 +857,9 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto const enable_lazy_evaluation = true;
+ auto computed_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_not_equals_test.init_status().ok());
ASSERT_TRUE(computed_not_equals_test._get_is_filter_result_initialized());
@@ -842,7 +877,8 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_not_equals_test.init_status().ok());
ASSERT_FALSE(iter_string_not_equals_test._get_is_filter_result_initialized());
@@ -869,7 +905,8 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
filter_op = filter::parse_filter_query("tags: != [gold, silver]", coll->get_schema(), store, doc_id_prefix,
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_array_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_array_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_array_not_equals_test.init_status().ok());
ASSERT_FALSE(iter_string_array_not_equals_test._get_is_filter_result_initialized());
ASSERT_EQ(5, iter_string_array_not_equals_test.approx_filter_ids_length);
@@ -915,7 +952,8 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_string_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_string_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_string_not_equals_test_2.init_status().ok());
ASSERT_FALSE(iter_string_not_equals_test_2._get_is_filter_result_initialized());
@@ -964,7 +1002,7 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
ASSERT_TRUE(filter_op.ok());
auto iter_not_equals_or_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_or_test.init_status().ok());
ASSERT_FALSE(iter_not_equals_or_test._get_is_filter_result_initialized());
@@ -989,7 +1027,7 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
ASSERT_TRUE(filter_op.ok());
auto iter_not_equals_or_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_or_test_2.init_status().ok());
validate_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8};
@@ -1013,14 +1051,16 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
ASSERT_TRUE(filter_op.ok());
auto iter_not_equals_and_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_and_test.init_status().ok());
+ ASSERT_TRUE(iter_not_equals_and_test._get_is_filter_result_initialized());
- validate_ids = {5, 6, 7, 8};
- seq_ids = {6, 7, 8, 8};
- expected = {1, 1, 0, -1};
+ validate_ids = {4, 5, 6, 7};
+ seq_ids = {5, 6, 6, 6};
+ expected = {0, 1, 1, -1};
+
+ ASSERT_EQ(filter_result_iterator_t::valid, iter_not_equals_and_test.validity);
for (uint32_t i = 0; i < validate_ids.size(); i++) {
- ASSERT_EQ(filter_result_iterator_t::valid, iter_not_equals_and_test.validity);
ASSERT_EQ(expected[i], iter_not_equals_and_test.is_valid(validate_ids[i]));
if (expected[i] == 1) {
@@ -1035,16 +1075,18 @@ TEST_F(FilterTest, NotEqualsStringFilter) {
filter_op = filter::parse_filter_query("tags: != silver && tags: != gold", coll->get_schema(), store, doc_id_prefix,
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
+ ASSERT_TRUE(iter_not_equals_and_test._get_is_filter_result_initialized());
auto iter_not_equals_and_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(),
- filter_tree_root);
+ filter_tree_root, enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_and_test_2.init_status().ok());
validate_ids = {0, 1, 2, 3, 4, 5, 6, 7, 8};
- seq_ids = {1, 2, 3, 4, 5, 6, 7, 8, 8};
- expected = {0, 1, 0, 0, 0, 1, 1, 0, -1};
+ seq_ids = {1, 5, 5, 5, 5, 6, 6, 6, 6};
+ expected = {0, 1, 0, 0, 0, 1, 1, -1, -1};
+
+ ASSERT_EQ(filter_result_iterator_t::valid, iter_not_equals_and_test_2.validity);
for (uint32_t i = 0; i < validate_ids.size(); i++) {
- ASSERT_EQ(filter_result_iterator_t::valid, iter_not_equals_and_test_2.validity);
ASSERT_EQ(expected[i], iter_not_equals_and_test_2.is_valid(validate_ids[i]));
if (expected[i] == 1) {
@@ -1086,7 +1128,9 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_greater_than_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto const enable_lazy_evaluation = true;
+ auto computed_greater_than_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_greater_than_test.init_status().ok());
ASSERT_TRUE(computed_greater_than_test._get_is_filter_result_initialized());
@@ -1104,7 +1148,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_greater_than_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_greater_than_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_greater_than_test.init_status().ok());
ASSERT_FALSE(iter_greater_than_test._get_is_filter_result_initialized());
@@ -1147,7 +1192,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_not_equals_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_test.init_status().ok());
ASSERT_FALSE(iter_not_equals_test._get_is_filter_result_initialized());
@@ -1172,7 +1218,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_not_equals_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_test_2.init_status().ok());
ASSERT_FALSE(iter_not_equals_test_2._get_is_filter_result_initialized());
@@ -1202,7 +1249,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter._get_is_filter_result_initialized());
@@ -1231,7 +1279,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter_2.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter_2._get_is_filter_result_initialized());
@@ -1261,7 +1310,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter_3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter_3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter_3.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter_3._get_is_filter_result_initialized());
@@ -1295,7 +1345,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_greater_than_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto computed_greater_than_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_greater_than_test_2.init_status().ok());
ASSERT_TRUE(computed_greater_than_test_2._get_is_filter_result_initialized());
@@ -1313,7 +1364,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_greater_than_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_greater_than_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_greater_than_test_2.init_status().ok());
ASSERT_FALSE(iter_greater_than_test_2._get_is_filter_result_initialized());
@@ -1360,7 +1412,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_not_equals_test_3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_not_equals_test_3 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_test_3.init_status().ok());
ASSERT_FALSE(iter_not_equals_test_3._get_is_filter_result_initialized());
@@ -1385,7 +1438,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_not_equals_test_4 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_not_equals_test_4 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_not_equals_test_4.init_status().ok());
ASSERT_FALSE(iter_not_equals_test_4._get_is_filter_result_initialized());
@@ -1415,7 +1469,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter_4 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter_4 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter_4.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter_4._get_is_filter_result_initialized());
@@ -1444,7 +1499,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter_5 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter_5 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter_5.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter_5._get_is_filter_result_initialized());
@@ -1474,7 +1530,8 @@ TEST_F(FilterTest, NumericFilterIterator) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_multivalue_filter_6 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_multivalue_filter_6 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_multivalue_filter_6.init_status().ok());
ASSERT_FALSE(iter_multivalue_filter_6._get_is_filter_result_initialized());
@@ -1538,7 +1595,9 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_exact_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto const enable_lazy_evaluation = true;
+ auto computed_exact_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_exact_prefix_test.init_status().ok());
ASSERT_TRUE(computed_exact_prefix_test._get_is_filter_result_initialized());
@@ -1556,7 +1615,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_contains_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto computed_contains_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_contains_prefix_test.init_status().ok());
ASSERT_TRUE(computed_contains_prefix_test._get_is_filter_result_initialized());
@@ -1592,7 +1652,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_exact_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_exact_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_exact_prefix_test.init_status().ok());
ASSERT_FALSE(iter_exact_prefix_test._get_is_filter_result_initialized());
@@ -1624,7 +1685,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_contains_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_contains_prefix_test = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_contains_prefix_test.init_status().ok());
ASSERT_FALSE(iter_contains_prefix_test._get_is_filter_result_initialized());
@@ -1656,7 +1718,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_exact_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto computed_exact_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_exact_prefix_test_2.init_status().ok());
ASSERT_TRUE(computed_exact_prefix_test_2._get_is_filter_result_initialized());
@@ -1674,7 +1737,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto computed_contains_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto computed_contains_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(computed_contains_prefix_test_2.init_status().ok());
ASSERT_TRUE(computed_contains_prefix_test_2._get_is_filter_result_initialized());
@@ -1707,7 +1771,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_exact_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_exact_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_exact_prefix_test_2.init_status().ok());
ASSERT_FALSE(iter_exact_prefix_test_2._get_is_filter_result_initialized());
@@ -1739,7 +1804,8 @@ TEST_F(FilterTest, PrefixStringFilter) {
filter_tree_root);
ASSERT_TRUE(filter_op.ok());
- auto iter_contains_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root);
+ auto iter_contains_prefix_test_2 = filter_result_iterator_t(coll->get_name(), coll->_get_index(), filter_tree_root,
+ enable_lazy_evaluation);
ASSERT_TRUE(iter_contains_prefix_test_2.init_status().ok());
ASSERT_FALSE(iter_contains_prefix_test_2._get_is_filter_result_initialized());