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

Handle values out of the indexable limit of trie.

Harpreet Sangarc4ff7f91f551
diff --git a/src/numeric_range_trie.cpp b/src/numeric_range_trie.cpp
index f70de113..66676e93 100644
--- a/src/numeric_range_trie.cpp
+++ b/src/numeric_range_trie.cpp
@@ -1,5 +1,6 @@
#include <timsort.hpp>
#include <set>
+#include <complex>
#include "numeric_range_trie_test.h"
#include "array_utils.h"
@@ -406,9 +407,17 @@ NumericTrie::iterator_t NumericTrie::search_equal_to(const int64_t& value) {
return NumericTrie::iterator_t(matches);
}
-void NumericTrie::Node::insert(const int64_t& cell_id, const uint32_t& seq_id, const char& max_level) {
+inline uint64_t indexable_limit(const char& max_level) {
+ return std::pow(EXPANSE, max_level);
+}
+
+void NumericTrie::Node::insert(const int64_t& value, const uint32_t& seq_id, const char& max_level) {
+ if (value >= indexable_limit(max_level)) {
+ return;
+ }
+
char level = 0;
- return insert_helper(cell_id, seq_id, level, max_level);
+ return insert_helper(value, seq_id, level, max_level);
}
void NumericTrie::Node::insert_geopoint(const uint64_t& cell_id, const uint32_t& seq_id, const char& max_level) {
@@ -433,6 +442,10 @@ inline int get_geopoint_index(const uint64_t& cell_id, const char& level) {
}
void NumericTrie::Node::remove(const int64_t& value, const uint32_t& id, const char& max_level) {
+ if (value >= indexable_limit(max_level)) {
+ return;
+ }
+
char level = 1;
Node* root = this;
auto index = get_index(value, level, max_level);
@@ -596,6 +609,11 @@ void NumericTrie::Node::get_all_ids(uint32_t*& ids, uint32_t& ids_length) {
void NumericTrie::Node::search_less_than(const int64_t& value, const char& max_level,
uint32_t*& ids, uint32_t& ids_length) {
+ if (value >= indexable_limit(max_level)) {
+ get_all_ids(ids, ids_length);
+ return;
+ }
+
char level = 0;
std::vector<NumericTrie::Node*> matches;
search_less_than_helper(value, level, max_level, matches);
@@ -655,7 +673,8 @@ void NumericTrie::Node::search_range(const int64_t& low, const int64_t& high, co
return;
}
std::vector<NumericTrie::Node*> matches;
- search_range_helper(low, high, max_level, matches);
+ search_range_helper(low, high >= indexable_limit(max_level) ? (int64_t) indexable_limit(max_level) - 1 : high,
+ max_level, matches);
std::vector<uint32_t> consolidated_ids;
for (auto const& match: matches) {
@@ -739,6 +758,10 @@ void NumericTrie::Node::search_range_helper(const int64_t& low,const int64_t& hi
void NumericTrie::Node::search_greater_than(const int64_t& value, const char& max_level,
uint32_t*& ids, uint32_t& ids_length) {
+ if (value >= indexable_limit(max_level)) {
+ return;
+ }
+
char level = 0;
std::vector<NumericTrie::Node*> matches;
search_greater_than_helper(value, level, max_level, matches);
@@ -794,6 +817,10 @@ void NumericTrie::Node::search_greater_than_helper(const int64_t& value, char& l
void NumericTrie::Node::search_equal_to(const int64_t& value, const char& max_level,
uint32_t*& ids, uint32_t& ids_length) {
+ if (value >= indexable_limit(max_level)) {
+ return;
+ }
+
char level = 1;
Node* root = this;
auto index = get_index(value, level, max_level);
diff --git a/test/numeric_range_trie_test.cpp b/test/numeric_range_trie_test.cpp
index 2412b5a5..6fdd464c 100644
--- a/test/numeric_range_trie_test.cpp
+++ b/test/numeric_range_trie_test.cpp
@@ -42,14 +42,18 @@ TEST_F(NumericRangeTrieTest, SearchRange) {
auto trie = new NumericTrie();
std::unique_ptr<NumericTrie> trie_guard(trie);
std::vector<std::pair<int32_t, uint32_t>> pairs = {
- {-8192, 8},
- {-16384, 32},
- {-24576, 35},
+ {-0x03010101, 1},
+ {-0x01010101, 5},
{-32768, 43},
+ {-24576, 35},
+ {-16384, 32},
+ {-8192, 8},
{8192, 49},
{16384, 56},
{24576, 58},
- {32768, 91}
+ {32768, 91},
+ {0x01010101, 53},
+ {0x03010101, 12},
};
for (auto const& pair: pairs) {
@@ -66,82 +70,109 @@ TEST_F(NumericRangeTrieTest, SearchRange) {
reset(ids, ids_length);
trie->search_range(-32768, true, 32768, true, ids, ids_length);
- ASSERT_EQ(pairs.size(), ids_length);
- for (uint32_t i = 0; i < pairs.size(); i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ std::vector<uint32_t> expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-32768, true, 32768, false, ids, ids_length);
- ASSERT_EQ(pairs.size() - 1, ids_length);
- for (uint32_t i = 0; i < pairs.size() - 1; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49, 56, 58};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
- trie->search_range(-32768, true, 134217728, true, ids, ids_length);
+ trie->search_range(-32768, true, 0x01000000, true, ids, ids_length);
- ASSERT_EQ(pairs.size(), ids_length);
- for (uint32_t i = 0; i < pairs.size(); i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+ trie->search_range(-32768, true, 0x0101010101, true, ids, ids_length);
+
+ expected = {8, 12, 32, 35, 43, 49, 53, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-32768, true, 0, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < 4; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-32768, true, 0, false, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < 4; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-32768, false, 32768, true, ids, ids_length);
- ASSERT_EQ(pairs.size() - 1, ids_length);
- for (uint32_t i = 0, j = 0; i < pairs.size(); i++) {
- if (i == 3) continue; // id for -32768 would not be present
- ASSERT_EQ(pairs[i].second, ids[j++]);
+ expected = {8, 32, 35, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
- trie->search_range(-134217728, true, 32768, true, ids, ids_length);
+ trie->search_range(-0x01000000, true, 32768, true, ids, ids_length);
- ASSERT_EQ(pairs.size(), ids_length);
- for (uint32_t i = 0; i < pairs.size(); i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
- trie->search_range(-134217728, true, 134217728, true, ids, ids_length);
+ trie->search_range(-0x0101010101, true, 32768, true, ids, ids_length);
- ASSERT_EQ(pairs.size(), ids_length);
- for (uint32_t i = 0; i < pairs.size(); i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {1, 5, 8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+ trie->search_range(-0x01000000, true, 0x01000000, true, ids, ids_length);
+
+ expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-1, true, 32768, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_range(-1, false, 32768, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
@@ -155,17 +186,19 @@ TEST_F(NumericRangeTrieTest, SearchRange) {
reset(ids, ids_length);
trie->search_range(8192, true, 32768, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < ids_length; i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
- trie->search_range(8192, true, 0x2000000, true, ids, ids_length);
+ trie->search_range(8192, true, 0x01000000, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < ids_length; i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
@@ -197,9 +230,28 @@ TEST_F(NumericRangeTrieTest, SearchRange) {
reset(ids, ids_length);
trie->search_range(-32768, true, -8192, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+ trie->search_range(-0x0101010101, true, -8192, true, ids, ids_length);
+
+ expected = {1, 5, 8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+ trie->search_range(32768, true, 0x0101010101, true, ids, ids_length);
+
+ expected = {12, 53, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
@@ -209,14 +261,14 @@ TEST_F(NumericRangeTrieTest, SearchGreaterThan) {
auto trie = new NumericTrie();
std::unique_ptr<NumericTrie> trie_guard(trie);
std::vector<std::pair<int32_t, uint32_t>> pairs = {
- {-8192, 8},
- {-16384, 32},
- {-24576, 35},
{-32768, 43},
+ {-24576, 35},
+ {-16384, 32},
+ {-8192, 8},
{8192, 49},
{16384, 56},
{24576, 58},
- {32768, 91}
+ {32768, 91},
};
for (auto const& pair: pairs) {
@@ -228,59 +280,64 @@ TEST_F(NumericRangeTrieTest, SearchGreaterThan) {
trie->search_greater_than(0, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ std::vector<uint32_t> expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(-1, false, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(-1, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(-24576, true, ids, ids_length);
- ASSERT_EQ(7, ids_length);
- for (uint32_t i = 0, j = 0; i < pairs.size(); i++) {
- if (i == 3) continue; // id for -32768 would not be present
- ASSERT_EQ(pairs[i].second, ids[j++]);
+ expected = {8, 32, 35, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(-32768, false, ids, ids_length);
- ASSERT_EQ(7, ids_length);
- for (uint32_t i = 0, j = 0; i < pairs.size(); i++) {
- if (i == 3) continue; // id for -32768 would not be present
- ASSERT_EQ(pairs[i].second, ids[j++]);
+ expected = {8, 32, 35, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(8192, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_greater_than(8192, false, ids, ids_length);
- ASSERT_EQ(3, ids_length);
- for (uint32_t i = 5, j = 0; i < pairs.size(); i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ expected = {56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
@@ -289,14 +346,38 @@ TEST_F(NumericRangeTrieTest, SearchGreaterThan) {
ASSERT_EQ(0, ids_length);
reset(ids, ids_length);
- trie->search_greater_than(-1000000, false, ids, ids_length);
+ trie->search_greater_than(-0x01000000, false, ids, ids_length);
- ASSERT_EQ(8, ids_length);
- for (uint32_t i = 0; i < pairs.size(); i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
+
+ pairs = {
+ {0x01010101, 53},
+ {0x03010101, 12},
+ };
+
+ for (auto const& pair: pairs) {
+ trie->insert(pair.first, pair.second);
+ }
+
+ trie->search_greater_than(0x01010101, true, ids, ids_length);
+
+ expected = {12, 53};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+
+ trie->search_greater_than(0x0101010101, true, ids, ids_length);
+
+ ASSERT_EQ(0, ids_length);
}
TEST_F(NumericRangeTrieTest, SearchLessThan) {
@@ -310,7 +391,7 @@ TEST_F(NumericRangeTrieTest, SearchLessThan) {
{8192, 49},
{16384, 56},
{24576, 58},
- {32768, 91}
+ {32768, 91},
};
for (auto const& pair: pairs) {
@@ -322,79 +403,129 @@ TEST_F(NumericRangeTrieTest, SearchLessThan) {
trie->search_less_than(0, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 4, j = 0; i < ids_length; i++, j++) {
- ASSERT_EQ(pairs[i].second, ids[j]);
+ std::vector<uint32_t> expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(0, false, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(-1, true, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(-16384, true, ids, ids_length);
- ASSERT_EQ(3, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(-16384, false, ids, ids_length);
- ASSERT_EQ(2, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(8192, true, ids, ids_length);
- ASSERT_EQ(5, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
trie->search_less_than(8192, false, ids, ids_length);
- ASSERT_EQ(4, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
- trie->search_less_than(-1000000, false, ids, ids_length);
+ trie->search_less_than(-0x01000000, false, ids, ids_length);
ASSERT_EQ(0, ids_length);
reset(ids, ids_length);
- trie->search_less_than(1000000, true, ids, ids_length);
+ trie->search_less_than(0x01000000, true, ids, ids_length);
- ASSERT_EQ(8, ids_length);
- for (uint32_t i = 0; i < ids_length; i++) {
- ASSERT_EQ(pairs[i].second, ids[i]);
+ expected = {8, 32, 35, 43, 49, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
}
reset(ids, ids_length);
+
+ pairs = {
+ {0x01010101, 53},
+ {0x03010101, 12},
+ };
+
+ for (auto const& pair: pairs) {
+ trie->insert(pair.first, pair.second);
+ }
+
+ trie->search_less_than(0x01010101010, true, ids, ids_length);
+
+ expected = {8, 12, 32, 35, 43, 49, 53, 56, 58, 91};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+
+ pairs = {
+ {-0x03010101, 1},
+ {-0x01010101, 5},
+ };
+
+ for (auto const& pair: pairs) {
+ trie->insert(pair.first, pair.second);
+ }
+
+ trie->search_less_than(-0x01010101, true, ids, ids_length);
+
+ expected = {1, 5};
+ ASSERT_EQ(expected.size(), ids_length);
+ for (uint32_t i = 0; i < expected.size(); i++) {
+ ASSERT_EQ(expected[i], ids[i]);
+ }
+
+ reset(ids, ids_length);
+
+ trie->search_less_than(-0x0101010101, true, ids, ids_length);
+
+ ASSERT_EQ(0, ids_length);
}
TEST_F(NumericRangeTrieTest, SearchEqualTo) {
auto trie = new NumericTrie();
std::unique_ptr<NumericTrie> trie_guard(trie);
- std::vector<std::pair<int32_t, uint32_t>> pairs = {
+ std::vector<std::pair<int64_t, uint32_t>> pairs = {
{-8192, 8},
{-16384, 32},
{-24576, 35},
@@ -404,7 +535,9 @@ TEST_F(NumericRangeTrieTest, SearchEqualTo) {
{8192, 49},
{16384, 56},
{24576, 58},
- {32768, 91}
+ {32768, 91},
+ {0x01010101, 68},
+ {0x0100000000, 68}
};
for (auto const& pair: pairs) {
@@ -434,6 +567,9 @@ TEST_F(NumericRangeTrieTest, SearchEqualTo) {
trie->search_equal_to(0x202020, ids, ids_length);
ASSERT_EQ(0, ids_length);
+
+ trie->search_equal_to(4311810305, ids, ids_length); // 0x0101010101
+ ASSERT_EQ(0, ids_length);
}
TEST_F(NumericRangeTrieTest, IterateSearchEqualTo) {
@@ -620,6 +756,7 @@ TEST_F(NumericRangeTrieTest, Remove) {
{24576, 58},
{32768, 91},
{0x202020, 35},
+ {0x01010101, 68},
};
for (auto const& pair: pairs) {
@@ -668,6 +805,15 @@ TEST_F(NumericRangeTrieTest, Remove) {
ASSERT_EQ(49, ids[0]);
reset(ids, ids_length);
+
+ trie->remove(0x0101010101, 68);
+
+ trie->search_equal_to(16843009, ids, ids_length);
+
+ ASSERT_EQ(1, ids_length);
+ ASSERT_EQ(68, ids[0]);
+
+ reset(ids, ids_length);
}
TEST_F(NumericRangeTrieTest, EmptyTrieOperations) {