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

cleanup & refactor

krunal87092620afce
diff --git a/include/collection.h b/include/collection.h
index c79ee618..95c4b235 100644
--- a/include/collection.h
+++ b/include/collection.h
@@ -477,8 +477,7 @@ public:
const size_t remote_embedding_timeout_ms = 30000,
const size_t remote_embedding_num_try = 2,
const std::string& stopwords_set="",
- const std::vector<std::string>& facet_return_parent = {},
- const facet_sort_by& facet_sort_params = {}) const;
+ const std::vector<std::string>& facet_return_parent = {}) const;
Option<bool> get_filter_ids(const std::string & filter_query, filter_result_t& filter_result) const;
@@ -506,8 +505,6 @@ public:
Option<bool> parse_facet(const std::string& facet_field, std::vector<facet>& facets) const;
- Option<bool> validate_facet_sort_by_field(const facet_sort_by& facet_sort_params) const;
-
// Override operations
Option<uint32_t> add_override(const override_t & override, bool write_to_store = true);
diff --git a/include/collection_manager.h b/include/collection_manager.h
index 370b565f..99de5a8c 100644
--- a/include/collection_manager.h
+++ b/include/collection_manager.h
@@ -184,8 +184,6 @@ public:
static bool parse_sort_by_str(std::string sort_by_str, std::vector<sort_by>& sort_fields);
- static bool parse_facet_sort_by_str(std::string facet_sort_by_str, facet_sort_by& facet_sort_params);
-
// symlinks
Option<std::string> resolve_symlink(const std::string & symlink_name) const;
diff --git a/include/field.h b/include/field.h
index f7ad535b..46a6c237 100644
--- a/include/field.h
+++ b/include/field.h
@@ -539,19 +539,6 @@ struct sort_by {
}
};
-struct facet_sort_by {
- std::string param;
- std::string order;
-
- facet_sort_by() {
- param.clear();
- order.clear();
- }
-
- facet_sort_by(const std::string& _param, const std::string& _order)
- :param(_param), order(_order) {}
-};
-
class GeoPoint {
constexpr static const double EARTH_RADIUS = 3958.75;
constexpr static const double METER_CONVERT = 1609.00;
@@ -617,6 +604,10 @@ struct facet {
bool is_intersected = false;
+ bool is_sort_by_alpha = false;
+
+ std::string sort_order="";
+
bool get_range(std::string key, std::pair<std::string, std::string>& range_pair)
{
if(facet_range_map.empty())
@@ -636,10 +627,13 @@ struct facet {
}
explicit facet(const std::string& field_name,
- std::map<std::string, std::string> facet_range = {}, bool is_range_q = false)
- :field_name(field_name){
- facet_range_map = facet_range;
- is_range_query = is_range_q;
+ std::map<std::string, std::string> facet_range = {}, bool is_range_q = false, bool sort_by_alpha=false,
+ const std::string& order="")
+ :field_name(field_name) {
+ facet_range_map = facet_range;
+ is_range_query = is_range_q;
+ is_sort_by_alpha = sort_by_alpha;
+ sort_order = order;
}
};
@@ -660,7 +654,6 @@ struct facet_value_t {
std::string value;
std::string highlighted;
uint32_t count;
- float sort_field_val = 0.0f;
};
struct facet_hash_values_t {
diff --git a/include/index.h b/include/index.h
index f1c7712e..9f5bf4a8 100644
--- a/include/index.h
+++ b/include/index.h
@@ -377,7 +377,7 @@ private:
size_t group_limit, const std::vector<std::string>& group_by_fields,
const uint32_t* result_ids, size_t results_size,
int max_facet_count, bool is_wildcard_query, bool no_filters_provided,
- facet_index_type_t facet_index_type, const facet_sort_by& facet_sort_params={}) const;
+ facet_index_type_t facet_index_type) const;
bool static_filter_query_eval(const override_t* override, std::vector<std::string>& tokens,
filter_node_t*& filter_tree_root) const;
@@ -632,7 +632,7 @@ public:
// Public operations
Option<bool> run_search(search_args* search_params, const std::string& collection_name,
- facet_index_type_t facet_index_type, const facet_sort_by& facet_sort_params={});
+ facet_index_type_t facet_index_type);
Option<bool> search(std::vector<query_tokens_t>& field_query_tokens, const std::vector<search_field_t>& the_fields,
const text_match_type_t match_type,
@@ -657,8 +657,7 @@ public:
const size_t max_extra_suffix, const size_t facet_query_num_typos,
const bool filter_curated_hits, enable_t split_join_tokens,
const vector_query_t& vector_query, size_t facet_sample_percent, size_t facet_sample_threshold,
- const std::string& collection_name, facet_index_type_t facet_index_type = DETECT,
- const facet_sort_by& facet_sort_params={}) const;
+ const std::string& collection_name, facet_index_type_t facet_index_type = DETECT) const;
void remove_field(uint32_t seq_id, const nlohmann::json& document, const std::string& field_name);
diff --git a/src/collection.cpp b/src/collection.cpp
index 85543b3e..da8c9f51 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -1124,8 +1124,8 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
const size_t remote_embedding_timeout_ms,
const size_t remote_embedding_num_try,
const std::string& stopwords_set,
- const std::vector<std::string>& facet_return_parent,
- const facet_sort_by& facet_sort_param) const {
+ const std::vector<std::string>& facet_return_parent) const
+ {
std::shared_lock lock(mutex);
@@ -1422,14 +1422,6 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
}
}
- //validate facet_sort_by fields
- if(!facet_sort_param.param.empty()) {
- const auto &res = validate_facet_sort_by_field(facet_sort_param);
- if (!res.ok()) {
- return Option<nlohmann::json>(res.code(), res.error());
- }
- }
-
if(per_page > PER_PAGE_MAX) {
std::string message = "Only upto " + std::to_string(PER_PAGE_MAX) + " hits can be fetched per page.";
return Option<nlohmann::json>(422, message);
@@ -1631,7 +1623,7 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
std::unique_ptr<search_args> search_params_guard(search_params);
- auto search_op = index->run_search(search_params, name, facet_index_type, facet_sort_param);
+ auto search_op = index->run_search(search_params, name, facet_index_type);
// filter_tree_root might be updated in Index::static_filter_query_eval.
filter_tree_root_guard.release();
@@ -2076,10 +2068,6 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
bool should_return_parent = std::find(facet_return_parent.begin(), facet_return_parent.end(),
the_field.name) != facet_return_parent.end();
- if(!facet_sort_param.param.empty()) {
- max_facets = facet_counts.size();
- }
-
for(size_t fi = 0; fi < max_facets; fi++) {
// remap facet value hash with actual string
auto & kv = facet_counts[fi];
@@ -2104,9 +2092,6 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
if(!facet_found) {
continue;
}
- if(!facet_sort_param.param.empty()) {
- facet_count.sort_field_val = document[facet_sort_param.param].get<float>();
- }
}
if(the_field.nested && should_return_parent) {
@@ -2182,33 +2167,21 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
highlightedss << value[i];
i++;
}
- facet_value_t facet_value = {value, highlightedss.str(), facet_count.count, facet_count.sort_field_val};
+ facet_value_t facet_value = {value, highlightedss.str(), facet_count.count};
facet_values.emplace_back(facet_value);
}
}
- if(facet_sort_param.param == "alpha") {
- bool is_asc = facet_sort_param.order == "asc";
+ if(a_facet.is_sort_by_alpha) {
+ bool is_asc = a_facet.sort_order == "asc";
std::stable_sort(facet_values.begin(), facet_values.end(),
- [&](const auto& fv1, const auto& fv2) {
+ [&] (const auto& fv1, const auto& fv2) {
if(is_asc) {
return fv1.value < fv2.value;
}
+
return fv1.value > fv2.value;
});
- } else if(!facet_sort_param.param.empty()) {
- bool is_asc = facet_sort_param.order == "asc";
- std::stable_sort(facet_values.begin(), facet_values.end(),
- [&](const auto& fv1, const auto& fv2) {
- if(is_asc) {
- return fv1.sort_field_val < fv2.sort_field_val;
- }
- return fv1.sort_field_val > fv2.sort_field_val;
- });
-
- if(facet_values.size() > max_facet_values) {
- facet_values.erase(facet_values.begin() + max_facet_values, facet_values.end());
- }
} else {
std::stable_sort(facet_values.begin(), facet_values.end(), Collection::facet_count_str_compare);
}
@@ -4851,12 +4824,14 @@ bool Collection::get_enable_nested_fields() {
return enable_nested_fields;
}
-Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector<facet>& facets) const{
- const std::regex base_pattern(".+\\(.*\\)");
- const std::regex range_pattern("[[a-zA-Z]+:\\[([0-9]+)\\,\\s*([0-9]+)\\]");
-
- if(facet_field.find(":") != std::string::npos) { //range based facet
- if(!std::regex_match(facet_field, base_pattern)){
+Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector<facet>& facets) const {
+ const std::regex base_pattern(".+\\(.*\\)");
+ const std::regex range_pattern("[[a-zA-Z]+:\\[([0-9]+)\\,\\s*([0-9]+)\\]");
+
+ if ((facet_field.find(":") != std::string::npos)
+ && (facet_field.find("sort") == std::string::npos)) { //range based facet
+
+ if (!std::regex_match(facet_field, base_pattern)) {
std::string error = "Facet range value is not valid.";
return Option<bool>(400, error);
}
@@ -4864,14 +4839,14 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
auto startpos = facet_field.find("(");
auto field_name = facet_field.substr(0, startpos);
- if(search_schema.count(field_name) == 0) {
+ if (search_schema.count(field_name) == 0) {
std::string error = "Could not find a facet field named `" + field_name + "` in the schema.";
return Option<bool>(404, error);
}
- const field& a_field = search_schema.at(field_name);
+ const field &a_field = search_schema.at(field_name);
- if(!a_field.is_integer() && !a_field.is_float()){
+ if (!a_field.is_integer() && !a_field.is_float()) {
std::string error = "Range facet is restricted to only integer and float fields.";
return Option<bool>(400, error);
}
@@ -4884,32 +4859,28 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
//split the ranges
std::vector<std::string> result;
startpos = 0;
- int index=0;
+ int index = 0;
int commaFound = 0, rangeFound = 0;
- bool range_open=false;
- while(index < range_string.size()){
- if(range_string[index] == ']'){
- if(range_open == true){
+ bool range_open = false;
+ while (index < range_string.size()) {
+ if (range_string[index] == ']') {
+ if (range_open == true) {
std::string range = range_string.substr(startpos, index + 1 - startpos);
- range=StringUtils::trim(range);
+ range = StringUtils::trim(range);
result.emplace_back(range);
rangeFound++;
- range_open=false;
- }
- else{
+ range_open = false;
+ } else {
result.clear();
break;
}
- }
- else if(range_string[index] == ',' && range_open == false){
- startpos = index+1;
+ } else if (range_string[index] == ',' && range_open == false) {
+ startpos = index + 1;
commaFound++;
- }
- else if(range_string[index] == '['){
- if((commaFound == rangeFound) && range_open==false){
- range_open=true;
- }
- else{
+ } else if (range_string[index] == '[') {
+ if ((commaFound == rangeFound) && range_open == false) {
+ range_open = true;
+ } else {
result.clear();
break;
}
@@ -4918,17 +4889,17 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
index++;
}
- if((result.empty()) || (range_open==true)){
+ if ((result.empty()) || (range_open == true)) {
std::string error = "Error splitting the facet range values.";
return Option<bool>(400, error);
}
std::vector<std::tuple<std::string, std::string, std::string>> tupVec;
- auto& range_map = a_facet.facet_range_map;
- for(const auto& range : result){
+ auto &range_map = a_facet.facet_range_map;
+ for (const auto &range: result) {
//validate each range syntax
- if(!std::regex_match(range, range_pattern)){
+ if (!std::regex_match(range, range_pattern)) {
std::string error = "Facet range value is not valid.";
return Option<bool>(400, error);
}
@@ -4944,7 +4915,7 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
auto upper_range_start = pos2 + 1;
auto upper_range_len = pos3 - upper_range_start;
- if(a_field.is_integer()) {
+ if (a_field.is_integer()) {
lower_range = range.substr(lower_range_start, lower_range_len);
StringUtils::trim(lower_range);
upper_range = range.substr(upper_range_start, upper_range_len);
@@ -4963,33 +4934,33 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
//sort the range values so that we can check continuity
sort(tupVec.begin(), tupVec.end());
- for(const auto& tup : tupVec){
+ for (const auto &tup: tupVec) {
- const auto& lower_range = std::get<0>(tup);
- const auto& upper_range = std::get<1>(tup);
- const std::string& range_val = std::get<2>(tup);
+ const auto &lower_range = std::get<0>(tup);
+ const auto &upper_range = std::get<1>(tup);
+ const std::string &range_val = std::get<2>(tup);
//check if ranges are continous or not
- if((!range_map.empty()) && (range_map.find(lower_range)== range_map.end())){
+ if ((!range_map.empty()) && (range_map.find(lower_range) == range_map.end())) {
std::string error = "Ranges in range facet syntax should be continous.";
return Option<bool>(400, error);
}
- range_map[upper_range] = range_val;
+ range_map[upper_range] = range_val;
}
a_facet.is_range_query = true;
facets.emplace_back(std::move(a_facet));
} else if (facet_field.find('*') != std::string::npos) { // Wildcard
- if (facet_field[facet_field.size() - 1] != '*') {
- return Option<bool>(404, "Only prefix matching with a wildcard is allowed.");
- }
+ if (facet_field[facet_field.size() - 1] != '*') {
+ return Option<bool>(404, "Only prefix matching with a wildcard is allowed.");
+ }
// Trim * from the end.
auto prefix = facet_field.substr(0, facet_field.size() - 1);
auto pair = search_schema.equal_prefix_range(prefix);
- if(pair.first == pair.second) {
+ if (pair.first == pair.second) {
// not found
std::string error = "Could not find a facet field for `" + facet_field + "` in the schema.";
return Option<bool>(404, error);
@@ -5002,43 +4973,40 @@ Option<bool> Collection::parse_facet(const std::string& facet_field, std::vector
facets.back().is_wildcard_match = true;
}
}
- } else {
- // normal facet
- if(search_schema.count(facet_field) == 0 || !search_schema.at(facet_field).facet) {
- std::string error = "Could not find a facet field named `" + facet_field + "` in the schema.";
- return Option<bool>(404, error);
- }
- facets.emplace_back(facet(facet_field));
- }
-
- return Option<bool>(true);
-}
-
-Option<bool> Collection::validate_facet_sort_by_field(const facet_sort_by& facet_sort_params) const {
- if(facet_sort_params.param == "alpha") {
- //sort param can be either alphabetical sort or sort by other field
} else {
- if (search_schema.count(facet_sort_params.param) == 0) {
- std::string error = "Could not find a facet field named `" + facet_sort_params.param + "` in the schema.";
- return Option<bool>(404, error);
- }
+ // normal facet
+ std::string order = "";
+ bool sort_alpha = false;
+ std::string facet_field_copy = facet_field;
+ auto pos = facet_field_copy.find("(");
+ if(pos != std::string::npos) {
+ facet_field_copy = facet_field_copy.substr(0, pos);
+ }
- const field &a_field = search_schema.at(facet_sort_params.param);
- if (!a_field.nested) {
- std::string error = "Field for `facet_sort_by` should be nested from same facet field";
- return Option<bool>(400, error);
- }
+ if (search_schema.count(facet_field_copy) == 0 || !search_schema.at(facet_field_copy).facet) {
+ std::string error = "Could not find a facet field named `" + facet_field_copy + "` in the schema.";
+ return Option<bool>(404, error);
+ }
- if (a_field.is_string()) {
- std::string error = "Field for `facet_sort_by` should not be string";
- return Option<bool>(400, error);
- }
- }
+ const field &a_field = search_schema.at(facet_field_copy);
+
+ if (facet_field.find("sort") != std::string::npos) { //sort params are supplied with facet
+ if(!a_field.is_string()) {
+ std::string error = "Facet field should be string type to apply alpha sort.";
+ return Option<bool>(400, error);
+ }
+
+ if (facet_field.find("asc") != std::string::npos) {
+ order = "asc";
+ sort_alpha = true;
+ } else if (facet_field.find("desc") != std::string::npos) {
+ order = "desc";
+ sort_alpha = true;
+ }
+ }
- if ((facet_sort_params.order != "asc") && (facet_sort_params.order != "desc")) {
- std::string error = "Sort order for field `facet_sort_by` should be asc/desc";
- return Option<bool>(400, error);
- }
+ facets.emplace_back(facet(facet_field_copy, {}, false, sort_alpha, order));
+ }
return Option<bool>(true);
}
@@ -5151,4 +5119,4 @@ Option<bool> Collection::truncate_after_top_k(const string &field_name, size_t k
}
return Option<bool>(true);
-}
+}
\ No newline at end of file
diff --git a/src/collection_manager.cpp b/src/collection_manager.cpp
index 449387ce..9bd3c09a 100644
--- a/src/collection_manager.cpp
+++ b/src/collection_manager.cpp
@@ -662,24 +662,6 @@ bool CollectionManager::parse_sort_by_str(std::string sort_by_str, std::vector<s
return true;
}
-bool CollectionManager::parse_facet_sort_by_str(std::string facet_sort_by_str, facet_sort_by& facet_sort_params) {
- std::vector<std::string> params;
- StringUtils::split(facet_sort_by_str, params, ":");
-
- if(params.size() != 2) { //can have only 2 params seperated by colon
- return false;
- }
-
- for(auto& param : params) {
- std::transform(param.begin(), param.end(), param.begin(), ::tolower);
- }
-
- facet_sort_params.param = params[0];
- facet_sort_params.order = params[1];
-
- return true;
-}
-
Option<bool> add_unsigned_int_param(const std::string& param_name, const std::string& str_val, size_t* int_val) {
if(!StringUtils::is_uint32_t(str_val)) {
return Option<bool>(400, "Parameter `" + std::string(param_name) + "` must be an unsigned integer.");
@@ -824,7 +806,6 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
const char *MAX_FACET_VALUES = "max_facet_values";
const char *FACET_RETURN_PARENT = "facet_return_parent";
- const char* FACET_SORT_BY = "facet_sort_by";
const char *VECTOR_QUERY = "vector_query";
@@ -956,8 +937,6 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
std::vector<std::string> facet_return_parent;
- facet_sort_by facet_sort_params;
-
std::string vector_query;
std::vector<std::string> include_fields_vec;
@@ -1169,15 +1148,6 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
return Option<bool>(400, "Only upto 3 sort fields are allowed.");
}
- if(!req_params[FACET_SORT_BY].empty()) {
- bool parse_validate_facet_sort_by = parse_facet_sort_by_str(req_params[FACET_SORT_BY],
- facet_sort_params);
-
- if(!parse_validate_facet_sort_by) {
- return Option<bool>(400,std::string("Parameter `") + FACET_SORT_BY + "` is malformed.");
- }
- }
-
if(req_params.count(INFIX) != 0) {
std::vector<std::string> infix_strs;
StringUtils::split(req_params[INFIX], infix_strs, ",");
@@ -1254,9 +1224,7 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
remote_embedding_timeout_ms,
remote_embedding_num_try,
stopwords_set,
- facet_return_parent,
- facet_sort_params
- );
+ facet_return_parent);
uint64_t timeMillis = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::high_resolution_clock::now() - begin).count();
diff --git a/src/index.cpp b/src/index.cpp
index bebb87e7..b9c2aa93 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -1247,7 +1247,7 @@ void Index::do_facets(std::vector<facet> & facets, facet_query_t & facet_query,
const size_t group_limit, const std::vector<std::string>& group_by_fields,
const uint32_t* result_ids, size_t results_size,
int max_facet_count, bool is_wildcard_query, bool no_filters_provided,
- facet_index_type_t facet_index_type, const facet_sort_by& facet_sort_params) const {
+ facet_index_type_t facet_index_type) const {
if(results_size == 0) {
return ;
@@ -1284,21 +1284,24 @@ void Index::do_facets(std::vector<facet> & facets, facet_query_t & facet_query,
(results_size > 1000 && num_facet_values < 250) ||
(results_size > 1000 && results_size * 2 > total_docs));
- if(!facet_sort_params.param.empty() && facet_sort_params.param == "alpha") {
+ if(a_facet.is_sort_by_alpha) {
+ a_facet.is_intersected = true;
+
std::map<std::string, uint32_t> facet_results;
- facet_index_v4->intersect(facet_field.name, result_ids, results_size, max_facet_count,
- facet_results, is_wildcard_no_filter_query, facet_sort_params.order);
+
+ facet_index_v4->intersect(facet_field.name, result_ids,
+ results_size, max_facet_count, facet_results, is_wildcard_no_filter_query,
+ a_facet.sort_order);
for(const auto& kv : facet_results) {
- facet_count_t& facet_count = a_facet.result_map[kv.first];
+ facet_count_t &facet_count = a_facet.result_map[kv.first];
facet_count.count = kv.second;
}
- a_facet.is_intersected = true;
- }
+
#ifdef TEST_BUILD
- else if(facet_index_type == VALUE) {
+ } else if(facet_index_type == VALUE) {
#else
- else if(facet_value_index_exists && use_value_index) {
+ } else if(facet_value_index_exists && use_value_index) {
#endif
// LOG(INFO) << "Using intersection to find facets";
a_facet.is_intersected = true;
@@ -1753,7 +1756,7 @@ Option<bool> Index::do_reference_filtering_with_lock(filter_node_t* const filter
}
Option<bool> Index::run_search(search_args* search_params, const std::string& collection_name,
- facet_index_type_t facet_index_type, const facet_sort_by& facet_sort_params) {
+ facet_index_type_t facet_index_type) {
return search(search_params->field_query_tokens,
search_params->search_fields,
search_params->match_type,
@@ -1789,8 +1792,7 @@ Option<bool> Index::run_search(search_args* search_params, const std::string& co
search_params->facet_sample_percent,
search_params->facet_sample_threshold,
collection_name,
- facet_index_type,
- facet_sort_params);
+ facet_index_type);
}
void Index::collate_included_ids(const std::vector<token_t>& q_included_tokens,
@@ -2239,8 +2241,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
const bool filter_curated_hits, const enable_t split_join_tokens,
const vector_query_t& vector_query,
size_t facet_sample_percent, size_t facet_sample_threshold,
- const std::string& collection_name, facet_index_type_t facet_index_type,
- const facet_sort_by& facet_sort_params) const {
+ const std::string& collection_name, facet_index_type_t facet_index_type) const {
std::shared_lock lock(mutex);
auto filter_result_iterator = new filter_result_iterator_t(collection_name, this, filter_tree_root);
@@ -2861,7 +2862,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
batch_result_ids, batch_res_len, &facet_infos, max_facet_values,
is_wildcard_query, no_filters_provided, estimate_facets, facet_sample_percent,
&parent_search_begin, &parent_search_stop_ms, &parent_search_cutoff,
- &num_processed, &m_process, &cv_process, facet_index_type, facet_sort_params]() {
+ &num_processed, &m_process, &cv_process, facet_index_type]() {
search_begin_us = parent_search_begin;
search_stop_us = parent_search_stop_ms;
search_cutoff = parent_search_cutoff;
@@ -2872,7 +2873,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
facet_infos, group_limit, group_by_fields,
batch_result_ids, batch_res_len, max_facet_values,
is_wildcard_query, no_filters_provided,
- facet_index_type, facet_sort_params);
+ facet_index_type);
std::unique_lock<std::mutex> lock(m_process);
num_processed++;
parent_search_cutoff = parent_search_cutoff || search_cutoff;
@@ -2954,7 +2955,7 @@ Option<bool> Index::search(std::vector<query_tokens_t>& field_query_tokens, cons
do_facets(facets, facet_query, estimate_facets, facet_sample_percent,
facet_infos, group_limit, group_by_fields, &included_ids_vec[0],
included_ids_vec.size(), max_facet_values, is_wildcard_query, no_filters_provided,
- facet_index_type, facet_sort_params);
+ facet_index_type);
all_result_ids_len += curated_topster->size;
diff --git a/test/collection_faceting_test.cpp b/test/collection_faceting_test.cpp
index 10ca9e42..dd36a0fa 100644
--- a/test/collection_faceting_test.cpp
+++ b/test/collection_faceting_test.cpp
@@ -1877,129 +1877,13 @@ TEST_F(CollectionFacetingTest, FacetingReturnParentObject) {
ASSERT_EQ("{\"b\":255,\"color\":\"blue\",\"g\":0,\"r\":0}", results["facet_counts"][0]["counts"][1]["value"]);
}
-TEST_F(CollectionFacetingTest, FacetSortByOtherFieldVal) {
- nlohmann::json schema = R"({
- "name": "coll1",
- "enable_nested_fields": true,
- "fields": [
- {"name": "car", "type": "object", "optional": false, "facet": true }
- ]
- })"_json;
-
- auto op = collectionManager.create_collection(schema);
- ASSERT_TRUE(op.ok());
- Collection* coll1 = op.get();
-
- nlohmann::json doc1 = R"({
- "car": {
- "speed": 130,
- "brand": "Tata",
- "type": "Hatchback"
- }
- })"_json;
-
- nlohmann::json doc2 = R"({
- "car": {
- "speed": 140,
- "brand": "Hyundai",
- "type": "Sedan"
- }
- })"_json;
-
- nlohmann::json doc3 = R"({
- "car": {
- "speed": 120,
- "brand": "Maruti",
- "type": "Sedan"
- }
- })"_json;
-
- nlohmann::json doc4 = R"({
- "car": {
- "speed": 135,
- "brand": "Toyota",
- "type": "Hatchback"
- }
- })"_json;
-
- auto add_op = coll1->add(doc1.dump(), CREATE);
- ASSERT_TRUE(add_op.ok());
- add_op = coll1->add(doc2.dump(), CREATE);
- ASSERT_TRUE(add_op.ok());
- add_op = coll1->add(doc3.dump(), CREATE);
- ASSERT_TRUE(add_op.ok());
- add_op = coll1->add(doc4.dump(), CREATE);
- ASSERT_TRUE(add_op.ok());
-
- //sort cars brands by top speed in asc order
- facet_sort_by facet_sort_param{"car.speed", "asc"};
- auto search_op = coll1->search("*", {},"", {"car.brand"},
- {}, {2}, 10, 1,FREQUENCY, {true},
- 1, spp::sparse_hash_set<std::string>(),
- spp::sparse_hash_set<std::string>(),10, "",
- 30, 4, "",
- Index::TYPO_TOKENS_THRESHOLD, "", "",{},
- 3, "<mark>", "</mark>", {},
- UINT32_MAX, true, false, true,
- "", false, 6000*1000, 4, 7,
- fallback, 4, {off}, INT16_MAX, INT16_MAX,
- 2, 2, false, "",
- true, 0, max_score, 100,
- 0, 0, HASH, 30000,
- 2, "", {}, facet_sort_param);
-
- if(!search_op.ok()) {
- LOG(ERROR) << search_op.error();
- FAIL();
- }
-
- auto results = search_op.get();
- ASSERT_EQ(1, results["facet_counts"].size());
- ASSERT_EQ(4, results["facet_counts"][0]["counts"].size());
- ASSERT_EQ("Maruti", results["facet_counts"][0]["counts"][0]["value"]);
- ASSERT_EQ("Tata", results["facet_counts"][0]["counts"][1]["value"]);
- ASSERT_EQ("Toyota", results["facet_counts"][0]["counts"][2]["value"]);
- ASSERT_EQ("Hyundai", results["facet_counts"][0]["counts"][3]["value"]);
-
- //sort cars brands by top speed in desc order
- facet_sort_param.param = "car.speed";
- facet_sort_param.order = "desc";
-
- search_op = coll1->search("*", {},"", {"car.brand"},
- {}, {2}, 10, 1,FREQUENCY, {true},
- 1, spp::sparse_hash_set<std::string>(),
- spp::sparse_hash_set<std::string>(),10, "",
- 30, 4, "",
- Index::TYPO_TOKENS_THRESHOLD, "", "",{},
- 3, "<mark>", "</mark>", {},
- UINT32_MAX, true, false, true,
- "", false, 6000*1000, 4, 7,
- fallback, 4, {off}, INT16_MAX, INT16_MAX,
- 2, 2, false, "",
- true, 0, max_score, 100,
- 0, 0, HASH, 30000,
- 2, "", {}, facet_sort_param);
-
- if(!search_op.ok()) {
- LOG(ERROR) << search_op.error();
- FAIL();
- }
-
- results = search_op.get();
- ASSERT_EQ(1, results["facet_counts"].size());
- ASSERT_EQ(4, results["facet_counts"][0]["counts"].size());
- ASSERT_EQ("Hyundai", results["facet_counts"][0]["counts"][0]["value"]);
- ASSERT_EQ("Toyota", results["facet_counts"][0]["counts"][1]["value"]);
- ASSERT_EQ("Tata", results["facet_counts"][0]["counts"][2]["value"]);
- ASSERT_EQ("Maruti", results["facet_counts"][0]["counts"][3]["value"]);
-}
-
TEST_F(CollectionFacetingTest, FacetSortByAlpha) {
nlohmann::json schema = R"({
"name": "coll1",
"fields": [
{"name": "phone", "type": "string", "optional": false, "facet": true },
- {"name": "brand", "type": "string", "optional": false, "facet": true }
+ {"name": "brand", "type": "string", "optional": false, "facet": true },
+ {"name": "rating", "type": "float", "optional": false, "facet": true }
]
})"_json;
@@ -2011,55 +1895,49 @@ TEST_F(CollectionFacetingTest, FacetSortByAlpha) {
doc["phone"] = "Oneplus 11R";
doc["brand"] = "Oneplus";
+ doc["rating"] = 4.6;
auto add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "Fusion Plus";
doc["brand"] = "Moto";
+ doc["rating"] = 4.2;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "S22 Ultra";
doc["brand"] = "Samsung";
+ doc["rating"] = 4.1;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "GT Master";
doc["brand"] = "Realme";
+ doc["rating"] = 4.4;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "T2";
doc["brand"] = "Vivo";
+ doc["rating"] = 4.0;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "Mi 6";
doc["brand"] = "Xiaomi";
+ doc["rating"] = 3.9;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
doc["phone"] = "Z6 Lite";
doc["brand"] = "Iqoo";
+ doc["rating"] = 4.3;
add_op = coll1->add(doc.dump(), CREATE);
ASSERT_TRUE(add_op.ok());
//sort facets by phone in asc order
- facet_sort_by facet_sort_param{"alpha", "asc"};
- auto search_op = coll1->search("*", {}, "", {"phone"},
- {}, {2}, 10, 1, FREQUENCY, {true},
- 1, spp::sparse_hash_set<std::string>(),
- spp::sparse_hash_set<std::string>(), 10, "",
- 30, 4, "",
- Index::TYPO_TOKENS_THRESHOLD, "", "", {},
- 3, "<mark>", "</mark>", {},
- UINT32_MAX, true, false, true,
- "", false, 6000 * 1000, 4, 7,
- fallback, 4, {off}, INT16_MAX, INT16_MAX,
- 2, 2, false, "",
- true, 0, max_score, 100,
- 0, 0, HASH, 30000,
- 2, "", {}, facet_sort_param);
+ auto search_op = coll1->search("*", {}, "", {"phone(sort:asc)"},
+ {}, {2});
if (!search_op.ok()) {
LOG(ERROR) << search_op.error();
@@ -2078,22 +1956,8 @@ TEST_F(CollectionFacetingTest, FacetSortByAlpha) {
ASSERT_EQ("Z6 Lite", results["facet_counts"][0]["counts"][6]["value"]);
//sort facets by brand in desc order
- facet_sort_param.param = "alpha";
- facet_sort_param.order = "desc";
- search_op = coll1->search("*", {}, "", {"brand"},
- {}, {2}, 10, 1, FREQUENCY, {true},
- 1, spp::sparse_hash_set<std::string>(),
- spp::sparse_hash_set<std::string>(), 10, "",
- 30, 4, "",
- Index::TYPO_TOKENS_THRESHOLD, "", "", {},
- 3, "<mark>", "</mark>", {},
- UINT32_MAX, true, false, true,
- "", false, 6000 * 1000, 4, 7,
- fallback, 4, {off}, INT16_MAX, INT16_MAX,
- 2, 2, false, "",
- true, 0, max_score, 100,
- 0, 0, HASH, 30000,
- 2, "", {}, facet_sort_param);
+ search_op = coll1->search("*", {}, "", {"brand(sort:desc)"},
+ {}, {2});
if (!search_op.ok()) {
LOG(ERROR) << search_op.error();
@@ -2110,4 +1974,41 @@ TEST_F(CollectionFacetingTest, FacetSortByAlpha) {
ASSERT_EQ("Oneplus", results["facet_counts"][0]["counts"][4]["value"]);
ASSERT_EQ("Moto", results["facet_counts"][0]["counts"][5]["value"]);
ASSERT_EQ("Iqoo", results["facet_counts"][0]["counts"][6]["value"]);
+
+ //sort facets by brand in desc order and phone by asc order
+ search_op = coll1->search("*", {}, "", {"brand(sort:desc)", "phone(sort:asc)"},
+ {}, {2});
+
+ if (!search_op.ok()) {
+ LOG(ERROR) << search_op.error();
+ FAIL();
+ }
+
+ results = search_op.get();
+ ASSERT_EQ(2, results["facet_counts"].size());
+
+ ASSERT_EQ(7, results["facet_counts"][0]["counts"].size());
+ ASSERT_EQ("Xiaomi", results["facet_counts"][0]["counts"][0]["value"]);
+ ASSERT_EQ("Vivo", results["facet_counts"][0]["counts"][1]["value"]);
+ ASSERT_EQ("Samsung", results["facet_counts"][0]["counts"][2]["value"]);
+ ASSERT_EQ("Realme", results["facet_counts"][0]["counts"][3]["value"]);
+ ASSERT_EQ("Oneplus", results["facet_counts"][0]["counts"][4]["value"]);
+ ASSERT_EQ("Moto", results["facet_counts"][0]["counts"][5]["value"]);
+ ASSERT_EQ("Iqoo", results["facet_counts"][0]["counts"][6]["value"]);
+
+ ASSERT_EQ(7, results["facet_counts"][1]["counts"].size());
+ ASSERT_EQ("Fusion Plus", results["facet_counts"][1]["counts"][0]["value"]);
+ ASSERT_EQ("GT Master", results["facet_counts"][1]["counts"][1]["value"]);
+ ASSERT_EQ("Mi 6", results["facet_counts"][1]["counts"][2]["value"]);
+ ASSERT_EQ("Oneplus 11R", results["facet_counts"][1]["counts"][3]["value"]);
+ ASSERT_EQ("S22 Ultra", results["facet_counts"][1]["counts"][4]["value"]);
+ ASSERT_EQ("T2", results["facet_counts"][1]["counts"][5]["value"]);
+ ASSERT_EQ("Z6 Lite", results["facet_counts"][1]["counts"][6]["value"]);
+
+ //try sort on non stirng field
+ search_op = coll1->search("*", {}, "", {"rating(sort:desc)"},
+ {}, {2});
+
+ ASSERT_EQ(400, search_op.code());
+ ASSERT_EQ("Facet field should be string type to apply alpha sort.", search_op.error());
}
\ No newline at end of file