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

Merge branch 'v0.24-nested' into v0.25

Kishore Nallancd5cfc54458e
diff --cc include/collection.h
index 7017098f,171b1457..8d1cea01
--- a/include/collection.h
+++ b/include/collection.h
@@@ -416,11 -413,10 +418,12 @@@ public
const std::string& vector_query_str = "",
const bool enable_highlight_v1 = true,
const uint64_t search_time_start_us = 0,
- const text_match_type_t match_type = max_score) const;
++ const text_match_type_t match_type = max_score,
+ const size_t facet_sample_percent = 100,
+ const size_t facet_sample_threshold = 0) const;
- Option<bool> get_filter_ids(const std::string & simple_filter_query,
- std::vector<std::pair<size_t, uint32_t*>>& index_ids);
+ Option<bool> get_filter_ids(const std::string & filter_query,
+ std::vector<std::pair<size_t, uint32_t*>>& index_ids) const;
Option<nlohmann::json> get(const std::string & id) const;
diff --cc include/index.h
index 82418877,d5b39214..d99a498f
--- a/include/index.h
+++ b/include/index.h
@@@ -133,10 -139,9 +139,11 @@@ struct search_args
std::vector<std::vector<KV*>> override_result_kvs;
vector_query_t& vector_query;
+ size_t facet_sample_percent;
+ size_t facet_sample_threshold;
search_args(std::vector<query_tokens_t> field_query_tokens, std::vector<search_field_t> search_fields,
+ const text_match_type_t match_type,
filter_node_t* filter_tree_root, std::vector<facet>& facets,
std::vector<std::pair<uint32_t, uint32_t>>& included_ids, std::vector<uint32_t> excluded_ids,
std::vector<sort_by>& sort_fields_std, facet_query_t facet_query, const std::vector<uint32_t>& num_typos,
@@@ -148,10 -153,9 +155,10 @@@
size_t concurrency, size_t search_cutoff_ms,
size_t min_len_1typo, size_t min_len_2typo, size_t max_candidates, const std::vector<enable_t>& infixes,
const size_t max_extra_prefix, const size_t max_extra_suffix, const size_t facet_query_num_typos,
- const bool filter_curated_hits, const enable_t split_join_tokens, vector_query_t& vector_query) :
+ const bool filter_curated_hits, const enable_t split_join_tokens, vector_query_t& vector_query,
+ size_t facet_sample_percent, size_t facet_sample_threshold) :
field_query_tokens(field_query_tokens),
- search_fields(search_fields), filter_tree_root(filter_tree_root), facets(facets),
+ search_fields(search_fields), match_type(match_type), filter_tree_root(filter_tree_root), facets(facets),
included_ids(included_ids), excluded_ids(excluded_ids), sort_fields_std(sort_fields_std),
facet_query(facet_query), num_typos(num_typos), max_facet_values(max_facet_values), per_page(per_page),
page(page), token_order(token_order), prefixes(prefixes),
diff --cc src/collection.cpp
index 7853971f,0ea060fa..df7cfd30
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@@ -964,8 -869,7 +964,9 @@@ Option<nlohmann::json> Collection::sear
const std::string& vector_query_str,
const bool enable_highlight_v1,
const uint64_t search_time_start_us,
- const text_match_type_t match_type) const {
++ const text_match_type_t match_type,
+ const size_t facet_sample_percent,
+ const size_t facet_sample_threshold) const {
std::shared_lock lock(mutex);
@@@ -1751,17 -1665,21 +1753,24 @@@
}
result["facet_counts"] = nlohmann::json::array();
-
+
// populate facets
for(facet & a_facet: facets) {
+ // check for search cutoff elapse
+ if((std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().
+ time_since_epoch()).count() - search_begin_us) > search_stop_us) {
+ search_cutoff = true;
+ break;
+ }
+
nlohmann::json facet_result = nlohmann::json::object();
facet_result["field_name"] = a_facet.field_name;
+ facet_result["sampled"] = a_facet.sampled;
facet_result["counts"] = nlohmann::json::array();
+ std::vector<facet_value_t> facet_values;
std::vector<std::pair<uint64_t, facet_count_t>> facet_hash_counts;
+
for (const auto & kv : a_facet.result_map) {
facet_hash_counts.emplace_back(kv);
}
diff --cc src/collection_manager.cpp
index f51791aa,d6d02b10..8115b210
--- a/src/collection_manager.cpp
+++ b/src/collection_manager.cpp
@@@ -697,11 -693,10 +693,13 @@@ Option<bool> CollectionManager::do_sear
const char *EXHAUSTIVE_SEARCH = "exhaustive_search";
const char *SPLIT_JOIN_TOKENS = "split_join_tokens";
+ const char *TEXT_MATCH_TYPE = "text_match_type";
+
const char *ENABLE_HIGHLIGHT_V1 = "enable_highlight_v1";
+ const char *FACET_SAMPLE_PERCENT = "facet_sample_percent";
+ const char *FACET_SAMPLE_THRESHOLD = "facet_sample_threshold";
+
// enrich params with values from embedded params
for(auto& item: embedded_params.items()) {
if(item.key() == "expires_at") {
@@@ -778,10 -774,8 +776,11 @@@
size_t max_extra_prefix = INT16_MAX;
size_t max_extra_suffix = INT16_MAX;
bool enable_highlight_v1 = true;
+ text_match_type_t match_type;
+ size_t facet_sample_percent = 100;
+ size_t facet_sample_threshold = 0;
+
std::unordered_map<std::string, size_t*> unsigned_int_values = {
{MIN_LEN_1TYPO, &min_len_1typo},
{MIN_LEN_2TYPO, &min_len_2typo},
@@@ -998,8 -991,7 +1004,9 @@@
vector_query,
enable_highlight_v1,
start_ts,
- match_type
++ match_type,
+ facet_sample_percent,
+ facet_sample_threshold
);
uint64_t timeMillis = std::chrono::duration_cast<std::chrono::milliseconds>(
diff --cc src/index.cpp
index 5492ce0a,f3101f0d..c75ee5ff
--- a/src/index.cpp
+++ b/src/index.cpp
@@@ -2837,11 -2816,14 +2851,16 @@@ void Index::search(std::vector<query_to
thread_pool->enqueue([this, thread_id, &facet_batches, &facet_query, group_limit, group_by_fields,
batch_result_ids, batch_res_len, &facet_infos,
+ estimate_facets, facet_sample_percent,
+ &parent_search_begin, &parent_search_stop_ms, &parent_search_cutoff,
&num_processed, &m_process, &cv_process]() {
+ search_begin_us = parent_search_begin;
+ search_stop_us = parent_search_stop_ms;
+ search_cutoff = parent_search_cutoff;
+
auto fq = facet_query;
- do_facets(facet_batches[thread_id], fq, facet_infos, group_limit, group_by_fields,
+ do_facets(facet_batches[thread_id], fq, estimate_facets, facet_sample_percent,
+ facet_infos, group_limit, group_by_fields,
batch_result_ids, batch_res_len);
std::unique_lock<std::mutex> lock(m_process);
num_processed++;
diff --cc test/collection_faceting_test.cpp
index 023b81cf,497eb588..ab9ea13c
--- a/test/collection_faceting_test.cpp
+++ b/test/collection_faceting_test.cpp
@@@ -982,432 -978,6 +982,432 @@@ TEST_F(CollectionFacetingTest, FacetByN
ASSERT_EQ(1, results["facet_counts"][0]["counts"].size());
ASSERT_EQ(2, results["facet_counts"][0]["counts"][0]["count"].get<size_t>());
ASSERT_EQ("2000", results["facet_counts"][0]["counts"][0]["value"].get<std::string>());
+
+ // Nested wildcard faceting
+ std::vector<facet> wildcard_facets;
+ coll1->parse_facet("company.*", wildcard_facets);
+
+ ASSERT_EQ(1, wildcard_facets.size());
+ ASSERT_EQ("company.num_employees", wildcard_facets[0].field_name);
+
+ wildcard_facets.clear();
+ coll1->parse_facet("company*", wildcard_facets);
+
+ ASSERT_EQ(2, wildcard_facets.size());
+ ASSERT_EQ("company.num_employees", wildcard_facets[0].field_name);
+ ASSERT_EQ("companyRank", wildcard_facets[1].field_name);
+}
+
+TEST_F(CollectionFacetingTest, FacetParseTest){
+ std::vector<field> fields = {
+ field("score", field_types::INT32, true),
+ field("grade", field_types::INT32, true),
+ field("rank", field_types::INT32, true),
+ field("range", field_types::INT32, true),
+ field("scale", field_types::INT32, false),
+ };
+
+ Collection* coll1 = collectionManager.create_collection("coll1", 1, fields).get();
+
+ std::vector<std::string> range_facet_fields {
+ "score(fail:[0, 40], pass:[40, 100])",
+ "grade(A:[80, 100], B:[60, 80], C:[40, 60])"
+ };
+ std::vector<facet> range_facets;
+ for(const std::string & facet_field: range_facet_fields) {
+ coll1->parse_facet(facet_field, range_facets);
+ }
+ ASSERT_EQ(2, range_facets.size());
+
+ ASSERT_STREQ("score", range_facets[0].field_name.c_str());
+ ASSERT_TRUE(range_facets[0].is_range_query);
+ ASSERT_GT(range_facets[0].facet_range_map.size(), 0);
+
+ ASSERT_STREQ("grade", range_facets[1].field_name.c_str());
+ ASSERT_TRUE(range_facets[1].is_range_query);
+ ASSERT_GT(range_facets[1].facet_range_map.size(), 0);
+
+ std::vector<std::string> normal_facet_fields {
+ "score",
+ "grade"
+ };
+ std::vector<facet> normal_facets;
+ for(const std::string & facet_field: normal_facet_fields) {
+ coll1->parse_facet(facet_field, normal_facets);
+ }
+ ASSERT_EQ(2, normal_facets.size());
+
+ ASSERT_STREQ("score", normal_facets[0].field_name.c_str());
+ ASSERT_STREQ("grade", normal_facets[1].field_name.c_str());
+
+ std::vector<std::string> wildcard_facet_fields {
+ "ran*",
+ "sc*",
+ };
+ std::vector<facet> wildcard_facets;
+ for(const std::string & facet_field: wildcard_facet_fields) {
+ coll1->parse_facet(facet_field, wildcard_facets);
+ }
+ ASSERT_EQ(3, wildcard_facets.size());
+
+ ASSERT_EQ("rank", wildcard_facets[0].field_name);
+ ASSERT_EQ("range", wildcard_facets[1].field_name);
+ ASSERT_EQ("score", wildcard_facets[2].field_name);
+
+ wildcard_facets.clear();
+ coll1->parse_facet("*", wildcard_facets);
+
+ // Last field is not a facet.
+ ASSERT_EQ(fields.size() - 1, wildcard_facets.size());
+
+ std::vector<std::string> expected;
+ expected.resize(fields.size() - 1);
+ std::transform(fields.begin(), fields.end() - 1, expected.begin(), [] (const field& f) -> string {
+ return f.name;
+ });
+ std::sort(expected.begin(), expected.end());
+
+ std::vector<std::string> result;
+ result.resize(wildcard_facets.size());
+ std::transform(wildcard_facets.begin(), wildcard_facets.end(), result.begin(), [] (const facet& f) -> string {
+ return f.field_name;
+ });
+ std::sort(result.begin(), result.end());
+ for (size_t i = 0; i < wildcard_facets.size(); i++) {
+ ASSERT_EQ(expected[i], result[i]);
+ }
+
+ std::vector<std::string> mixed_facet_fields {
+ "score",
+ "grade(A:[80, 100], B:[60, 80], C:[40, 60])",
+ "ra*",
+ };
+ std::vector<facet> mixed_facets;
+ for(const std::string & facet_field: mixed_facet_fields) {
+ coll1->parse_facet(facet_field, mixed_facets);
+ }
+ ASSERT_EQ(4, mixed_facets.size());
+
+ ASSERT_STREQ("score", mixed_facets[0].field_name.c_str());
+
+ ASSERT_STREQ("grade", mixed_facets[1].field_name.c_str());
+ ASSERT_TRUE(mixed_facets[1].is_range_query);
+ ASSERT_GT(mixed_facets[1].facet_range_map.size(), 0);
+
+ ASSERT_STREQ("rank", mixed_facets[2].field_name.c_str());
+ ASSERT_EQ("range", mixed_facets[3].field_name);
+}
+
+TEST_F(CollectionFacetingTest, RangeFacetTest) {
+ std::vector<field> fields = {field("place", field_types::STRING, false),
+ field("state", field_types::STRING, false),
+ field("visitors", field_types::INT32, true),};
+ Collection* coll1 = collectionManager.create_collection(
+ "coll1", 1, fields, "", 0, "", {}, {}
+ ).get();
+ nlohmann::json doc1;
+ doc1["id"] = "0";
+ doc1["place"] = "Mysore Palace";
+ doc1["state"] = "Karnataka";
+ doc1["visitors"] = 235486;
+
+ nlohmann::json doc2;
+ doc2["id"] = "1";
+ doc2["place"] = "Hampi";
+ doc2["state"] = "Karnataka";
+ doc2["visitors"] = 187654;
+
+ nlohmann::json doc3;
+ doc3["id"] = "2";
+ doc3["place"] = "Mahabalipuram";
+ doc3["state"] = "TamilNadu";
+ doc3["visitors"] = 174684;
+
+ nlohmann::json doc4;
+ doc4["id"] = "3";
+ doc4["place"] = "Meenakshi Amman Temple";
+ doc4["state"] = "TamilNadu";
+ doc4["visitors"] = 246676;
+
+ nlohmann::json doc5;
+ doc5["id"] = "4";
+ doc5["place"] = "Staue of Unity";
+ doc5["state"] = "Gujarat";
+ doc5["visitors"] = 345878;
+
+
+ ASSERT_TRUE(coll1->add(doc1.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc2.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc3.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc4.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc5.dump()).ok());
+
+ auto results = coll1->search("Karnataka", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:[200000, 500000])"},
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true).get();
+ ASSERT_EQ(2, results["facet_counts"][0]["counts"].size());
+ ASSERT_EQ(1, (int) results["facet_counts"][0]["counts"][0]["count"]);
+ ASSERT_STREQ("Busy", results["facet_counts"][0]["counts"][0]["value"].get<std::string>().c_str());
+
+ auto results2 = coll1->search("Gujarat", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:[200000, 500000])"},
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true).get();
+ ASSERT_EQ(1, results2["facet_counts"][0]["counts"].size());
+ ASSERT_EQ(1, results2["facet_counts"][0]["counts"][0]["count"].get<std::size_t>());
+ ASSERT_STREQ("VeryBusy", results2["facet_counts"][0]["counts"][0]["value"].get<std::string>().c_str());
+ ASSERT_TRUE(results2["facet_counts"][0]["counts"][1]["value"] == nullptr);
+
+ collectionManager.drop_collection("coll1");
+}
+
+TEST_F(CollectionFacetingTest, RangeFacetContinuity) {
+ std::vector<field> fields = {field("place", field_types::STRING, false),
+ field("state", field_types::STRING, false),
+ field("visitors", field_types::INT32, true),};
+ Collection* coll1 = collectionManager.create_collection(
+ "coll1", 1, fields, "", 0, "", {}, {}
+ ).get();
+ nlohmann::json doc1;
+ doc1["id"] = "0";
+ doc1["place"] = "Mysore Palace";
+ doc1["state"] = "Karnataka";
+ doc1["visitors"] = 235486;
+
+ nlohmann::json doc2;
+ doc2["id"] = "1";
+ doc2["place"] = "Hampi";
+ doc2["state"] = "Karnataka";
+ doc2["visitors"] = 187654;
+
+ nlohmann::json doc3;
+ doc3["id"] = "2";
+ doc3["place"] = "Mahabalipuram";
+ doc3["state"] = "TamilNadu";
+ doc3["visitors"] = 174684;
+
+ nlohmann::json doc4;
+ doc4["id"] = "3";
+ doc4["place"] = "Meenakshi Amman Temple";
+ doc4["state"] = "TamilNadu";
+ doc4["visitors"] = 246676;
+
+ nlohmann::json doc5;
+ doc5["id"] = "4";
+ doc5["place"] = "Staue of Unity";
+ doc5["state"] = "Gujarat";
+ doc5["visitors"] = 345878;
+
+
+ ASSERT_TRUE(coll1->add(doc1.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc2.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc3.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc4.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc5.dump()).ok());
+
+ auto results = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:[200001, 500000])"},
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Ranges in range facet syntax should be continous.", results.error().c_str());
+
+ auto results2 = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:[199999, 500000])"},
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Ranges in range facet syntax should be continous.", results2.error().c_str());
+
+ collectionManager.drop_collection("coll1");
+}
+
+TEST_F(CollectionFacetingTest, RangeFacetTypo) {
+ std::vector<field> fields = {field("place", field_types::STRING, false),
+ field("state", field_types::STRING, false),
+ field("visitors", field_types::INT32, true),};
+ Collection* coll1 = collectionManager.create_collection(
+ "coll1", 1, fields, "", 0, "", {}, {}
+ ).get();
+ nlohmann::json doc1;
+ doc1["id"] = "0";
+ doc1["place"] = "Mysore Palace";
+ doc1["state"] = "Karnataka";
+ doc1["visitors"] = 235486;
+
+ nlohmann::json doc2;
+ doc2["id"] = "1";
+ doc2["place"] = "Hampi";
+ doc2["state"] = "Karnataka";
+ doc2["visitors"] = 187654;
+
+ nlohmann::json doc3;
+ doc3["id"] = "2";
+ doc3["place"] = "Mahabalipuram";
+ doc3["state"] = "TamilNadu";
+ doc3["visitors"] = 174684;
+
+ nlohmann::json doc4;
+ doc4["id"] = "3";
+ doc4["place"] = "Meenakshi Amman Temple";
+ doc4["state"] = "TamilNadu";
+ doc4["visitors"] = 246676;
+
+ nlohmann::json doc5;
+ doc5["id"] = "4";
+ doc5["place"] = "Staue of Unity";
+ doc5["state"] = "Gujarat";
+ doc5["visitors"] = 345878;
+
+
+ ASSERT_TRUE(coll1->add(doc1.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc2.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc3.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc4.dump()).ok());
+ ASSERT_TRUE(coll1->add(doc5.dump()).ok());
+
+ auto results = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:[200000, 500000)"}, //missing ']' at end
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Error splitting the range string.", results.error().c_str());
+
+ auto results2 = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000], VeryBusy:200000, 500000])"}, //missing '[' in second range
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Error splitting the range string.", results2.error().c_str());
+
+ auto results3 = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000] VeryBusy:[200000, 500000])"}, //missing ',' between ranges
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Error splitting the range string.", results3.error().c_str());
+
+ auto results4 = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0 200000], VeryBusy:[200000, 500000])"}, //missing ',' between first ranges values
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Range String range pattern not matched.", results4.error().c_str());
+
+ auto results5 = coll1->search("TamilNadu", {"state"},
+ "", {"visitors(Busy:[0, 200000 VeryBusy:200000, 500000])"}, //missing '],' and '['
+ {}, {2}, 10,
+ 1, FREQUENCY, {true},
+ 10, spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 10, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000,
+ true, false, true, "", true);
+ ASSERT_STREQ("Range String range pattern not matched.", results5.error().c_str());
+
+ collectionManager.drop_collection("coll1");
+}
+
+TEST_F(CollectionFacetingTest, SampleFacetCounts) {
+ nlohmann::json schema = R"({
+ "name": "coll1",
+ "fields": [
+ {"name": "color", "type": "string", "facet": true}
+ ]
+ })"_json;
+
+ Collection* coll1 = collectionManager.create_collection(schema).get();
+
+ std::mt19937 gen(137723); // use constant seed to make sure that counts don't jump around
+ std::uniform_int_distribution<> distr(1, 100); // 1 to 100 inclusive
+
+ size_t count_blue = 0, count_red = 0;
+
+ for(size_t i = 0; i < 1000; i++) {
+ nlohmann::json doc;
+ if(distr(gen) % 2 == 0) {
+ doc["color"] = "blue";
+ count_blue++;
+ } else {
+ doc["color"] = "red";
+ count_red++;
+ }
+
+ ASSERT_TRUE(coll1->add(doc.dump()).ok());
+ }
+
+ auto res = coll1->search("*", {}, "", {"color"}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, fallback,
- 4, {off}, 3, 3, 2, 2, false, "", true, 0, 10, 0).get();
++ 4, {off}, 3, 3, 2, 2, false, "", true, 0, max_score, 10, 0).get();
+
+ ASSERT_EQ(1000, res["found"].get<size_t>());
+ ASSERT_EQ(1, res["facet_counts"].size());
+ ASSERT_EQ(2, res["facet_counts"][0]["counts"].size());
+
+ // verify approximate counts
+ ASSERT_GE(res["facet_counts"][0]["counts"][0]["count"].get<size_t>(), 250);
+ ASSERT_GE(res["facet_counts"][0]["counts"][1]["count"].get<size_t>(), 250);
+ ASSERT_TRUE(res["facet_counts"][0]["sampled"].get<bool>());
+
+ // when sample threshold is high, don't estimate
+ res = coll1->search("*", {}, "", {"color"}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, fallback,
- 4, {off}, 3, 3, 2, 2, false, "", true, 0, 10, 10000).get();
++ 4, {off}, 3, 3, 2, 2, false, "", true, 0, max_score, 10, 10000).get();
+
+ ASSERT_EQ(1000, res["found"].get<size_t>());
+ ASSERT_EQ(1, res["facet_counts"].size());
+ ASSERT_EQ(2, res["facet_counts"][0]["counts"].size());
+
+ for(size_t i = 0; i < res["facet_counts"][0]["counts"].size(); i++) {
+ if(res["facet_counts"][0]["counts"][i]["value"].get<std::string>() == "red") {
+ ASSERT_EQ(count_red, res["facet_counts"][0]["counts"][i]["count"].get<size_t>());
+ } else {
+ ASSERT_EQ(count_blue, res["facet_counts"][0]["counts"][i]["count"].get<size_t>());
+ }
+ }
+
+ ASSERT_FALSE(res["facet_counts"][0]["sampled"].get<bool>());
+
+ // test for sample percent > 100
+
+ auto res_op = coll1->search("*", {}, "", {"color"}, {}, {0}, 3, 1, FREQUENCY, {true}, 5,
+ spp::sparse_hash_set<std::string>(),
+ spp::sparse_hash_set<std::string>(), 10, "", 30, 4, "", 20, {}, {}, {}, 0,
+ "<mark>", "</mark>", {}, 1000, true, false, true, "", false, 6000 * 1000, 4, 7, fallback,
- 4, {off}, 3, 3, 2, 2, false, "", true, 0, 200, 0);
++ 4, {off}, 3, 3, 2, 2, false, "", true, 0, max_score, 200, 0);
+
+ ASSERT_FALSE(res_op.ok());
+ ASSERT_EQ("Value of `facet_sample_percent` must be less than 100.", res_op.error());
}
TEST_F(CollectionFacetingTest, FacetOnArrayFieldWithSpecialChars) {