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

String sort: allow missing values to be sent to either end.

Kishore Nallancf3b28bb77b3
diff --git a/include/adi_tree.h b/include/adi_tree.h
index dd20bf87..a5aee168 100644
--- a/include/adi_tree.h
+++ b/include/adi_tree.h
@@ -7,7 +7,6 @@ struct adi_node_t;
class adi_tree_t {
private:
- static constexpr size_t NOT_FOUND = UINT64_MAX;
spp::sparse_hash_map<uint32_t, std::string> id_keys;
adi_node_t* root = nullptr;
@@ -22,6 +21,7 @@ private:
void remove_node(adi_node_t* node, const std::string& key, const size_t key_index);
public:
+ static constexpr size_t NOT_FOUND = INT64_MAX;
adi_tree_t();
diff --git a/include/field.h b/include/field.h
index 4c63bd63..0f87263b 100644
--- a/include/field.h
+++ b/include/field.h
@@ -446,9 +446,17 @@ namespace sort_field_const {
static const std::string exclude_radius = "exclude_radius";
static const std::string precision = "precision";
+
+ static const std::string missing_values = "missing_values";
}
struct sort_by {
+ enum missing_values_t {
+ first,
+ last,
+ ordered,
+ };
+
std::string name;
std::string order;
@@ -460,15 +468,19 @@ struct sort_by {
uint32_t exclude_radius;
uint32_t geo_precision;
+ missing_values_t missing_values;
+
sort_by(const std::string & name, const std::string & order):
- name(name), order(order), text_match_buckets(0), geopoint(0), exclude_radius(0), geo_precision(0) {
+ name(name), order(order), text_match_buckets(0), geopoint(0), exclude_radius(0), geo_precision(0),
+ missing_values(ordered) {
}
sort_by(const std::string &name, const std::string &order, uint32_t text_match_buckets, int64_t geopoint,
uint32_t exclude_radius, uint32_t geo_precision) :
name(name), order(order), text_match_buckets(text_match_buckets),
- geopoint(geopoint), exclude_radius(exclude_radius), geo_precision(geo_precision) {
+ geopoint(geopoint), exclude_radius(exclude_radius), geo_precision(geo_precision),
+ missing_values(ordered) {
}
@@ -479,6 +491,7 @@ struct sort_by {
geopoint = other.geopoint;
exclude_radius = other.exclude_radius;
geo_precision = other.geo_precision;
+ missing_values = other.missing_values;
return *this;
}
};
diff --git a/src/collection.cpp b/src/collection.cpp
index 7c8d1847..e8b3b8c1 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -522,6 +522,7 @@ Option<bool> Collection::validate_and_standardize_sort_fields(const std::vector<
}
const std::string& actual_field_name = sort_field_std.name.substr(0, paran_start);
+ const auto field_it = search_schema.find(actual_field_name);
if(actual_field_name == sort_field_const::text_match) {
std::vector<std::string> match_parts;
@@ -539,97 +540,129 @@ Option<bool> Collection::validate_and_standardize_sort_fields(const std::vector<
sort_field_std.text_match_buckets = std::stoll(match_parts[1]);
} else {
- if(search_schema.count(actual_field_name) == 0 || !search_schema.at(actual_field_name).sort) {
+ if(field_it == search_schema.end() || !field_it->second.sort) {
std::string error = "Could not find a field named `" + actual_field_name + "` in the schema for sorting.";
return Option<bool>(404, error);
}
- const std::string& geo_coordstr = sort_field_std.name.substr(paran_start+1, sort_field_std.name.size() - paran_start - 2);
+ std::string error = "Bad syntax for sorting field `" + actual_field_name + "`";
- // e.g. geopoint_field(lat1, lng1, exclude_radius: 10 miles)
-
- std::vector<std::string> geo_parts;
- StringUtils::split(geo_coordstr, geo_parts, ",");
-
- std::string error = "Bad syntax for geopoint sorting field `" + actual_field_name + "`";
-
- if(geo_parts.size() != 2 && geo_parts.size() != 3) {
- return Option<bool>(400, error);
- }
-
- if(!StringUtils::is_float(geo_parts[0]) || !StringUtils::is_float(geo_parts[1])) {
- return Option<bool>(400, error);
- }
-
- if(geo_parts.size() == 3) {
- // try to parse the exclude radius option
- bool is_exclude_option = false;
-
- if(StringUtils::begins_with(geo_parts[2], sort_field_const::exclude_radius)) {
- is_exclude_option = true;
- } else if(StringUtils::begins_with(geo_parts[2], sort_field_const::precision)) {
- is_exclude_option = false;
- } else {
- return Option<bool>(400, error);
- }
+ if(field_it->second.type == field_types::STRING) {
+ // check for null value order
+ const std::string& sort_params_str = sort_field_std.name.substr(paran_start + 1,
+ sort_field_std.name.size() -
+ paran_start - 2);
std::vector<std::string> param_parts;
- StringUtils::split(geo_parts[2], param_parts, ":");
+ StringUtils::split(sort_params_str, param_parts, ":");
if(param_parts.size() != 2) {
return Option<bool>(400, error);
}
- // param_parts[1] is the value, in either "20km" or "20 km" format
+ if(param_parts[0] != sort_field_const::missing_values) {
+ return Option<bool>(400, error);
+ }
- if(param_parts[1].size() < 2) {
+ auto missing_values_op = magic_enum::enum_cast<sort_by::missing_values_t>(param_parts[1]);
+ if(missing_values_op.has_value()) {
+ sort_field_std.missing_values = missing_values_op.value();
+ } else {
return Option<bool>(400, error);
}
+ }
- std::string unit = param_parts[1].substr(param_parts[1].size()-2, 2);
+ else if(field_it->second.is_geopoint()) {
+ const std::string& geo_coordstr = sort_field_std.name.substr(paran_start+1, sort_field_std.name.size() - paran_start - 2);
- if(unit != "km" && unit != "mi") {
- return Option<bool>(400, "Sort field's parameter unit must be either `km` or `mi`.");
- }
+ // e.g. geopoint_field(lat1, lng1, exclude_radius: 10 miles)
- std::vector<std::string> dist_values;
- StringUtils::split(param_parts[1], dist_values, unit);
+ std::vector<std::string> geo_parts;
+ StringUtils::split(geo_coordstr, geo_parts, ",");
- if(dist_values.size() != 1) {
+ if(geo_parts.size() != 2 && geo_parts.size() != 3) {
return Option<bool>(400, error);
}
- if(!StringUtils::is_float(dist_values[0])) {
+ if(!StringUtils::is_float(geo_parts[0]) || !StringUtils::is_float(geo_parts[1])) {
return Option<bool>(400, error);
}
- int32_t value_meters;
+ if(geo_parts.size() == 3) {
+ // try to parse the exclude radius option
+ bool is_exclude_option = false;
- if(unit == "km") {
- value_meters = std::stof(dist_values[0]) * 1000;
- } else if(unit == "mi") {
- value_meters = std::stof(dist_values[0]) * 1609.34;
- } else {
- return Option<bool>(400, "Sort field's parameter "
- "unit must be either `km` or `mi`.");
- }
+ if(StringUtils::begins_with(geo_parts[2], sort_field_const::exclude_radius)) {
+ is_exclude_option = true;
+ } else if(StringUtils::begins_with(geo_parts[2], sort_field_const::precision)) {
+ is_exclude_option = false;
+ } else {
+ return Option<bool>(400, error);
+ }
- if(value_meters <= 0) {
- return Option<bool>(400, "Sort field's parameter must be a positive number.");
- }
+ std::vector<std::string> param_parts;
+ StringUtils::split(geo_parts[2], param_parts, ":");
- if(is_exclude_option) {
- sort_field_std.exclude_radius = value_meters;
- } else {
- sort_field_std.geo_precision = value_meters;
+ if(param_parts.size() != 2) {
+ return Option<bool>(400, error);
+ }
+
+ // param_parts[1] is the value, in either "20km" or "20 km" format
+
+ if(param_parts[1].size() < 2) {
+ return Option<bool>(400, error);
+ }
+
+ std::string unit = param_parts[1].substr(param_parts[1].size()-2, 2);
+
+ if(unit != "km" && unit != "mi") {
+ return Option<bool>(400, "Sort field's parameter unit must be either `km` or `mi`.");
+ }
+
+ std::vector<std::string> dist_values;
+ StringUtils::split(param_parts[1], dist_values, unit);
+
+ if(dist_values.size() != 1) {
+ return Option<bool>(400, error);
+ }
+
+ if(!StringUtils::is_float(dist_values[0])) {
+ return Option<bool>(400, error);
+ }
+
+ int32_t value_meters;
+
+ if(unit == "km") {
+ value_meters = std::stof(dist_values[0]) * 1000;
+ } else if(unit == "mi") {
+ value_meters = std::stof(dist_values[0]) * 1609.34;
+ } else {
+ return Option<bool>(400, "Sort field's parameter "
+ "unit must be either `km` or `mi`.");
+ }
+
+ if(value_meters <= 0) {
+ return Option<bool>(400, "Sort field's parameter must be a positive number.");
+ }
+
+ if(is_exclude_option) {
+ sort_field_std.exclude_radius = value_meters;
+ } else {
+ sort_field_std.geo_precision = value_meters;
+ }
}
+
+ double lat = std::stod(geo_parts[0]);
+ double lng = std::stod(geo_parts[1]);
+ int64_t lat_lng = GeoPoint::pack_lat_lng(lat, lng);
+ sort_field_std.geopoint = lat_lng;
+ }
+
+ else {
+ return Option<bool>(400, error);
}
- double lat = std::stod(geo_parts[0]);
- double lng = std::stod(geo_parts[1]);
- int64_t lat_lng = GeoPoint::pack_lat_lng(lat, lng);
sort_field_std.name = actual_field_name;
- sort_field_std.geopoint = lat_lng;
}
}
diff --git a/src/index.cpp b/src/index.cpp
index cabc3d13..e9daa20a 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -3265,6 +3265,17 @@ void Index::compute_sort_scores(const std::vector<sort_by>& sort_fields, const i
scores[0] = geopoint_distances[0];
} else if(field_values[0] == &str_sentinel_value) {
scores[0] = str_sort_index.at(sort_fields[0].name)->rank(seq_id);
+ if(scores[0] == adi_tree_t::NOT_FOUND) {
+ if(sort_fields[0].order == sort_field_const::asc &&
+ sort_fields[0].missing_values == sort_by::missing_values_t::first) {
+ scores[0] = -scores[0];
+ }
+
+ else if(sort_fields[0].order == sort_field_const::desc &&
+ sort_fields[0].missing_values == sort_by::missing_values_t::last) {
+ scores[0] = -scores[0];
+ }
+ }
} else {
auto it = field_values[0]->find(seq_id);
scores[0] = (it == field_values[0]->end()) ? default_score : it->second;
@@ -3285,6 +3296,17 @@ void Index::compute_sort_scores(const std::vector<sort_by>& sort_fields, const i
scores[1] = geopoint_distances[1];
} else if(field_values[1] == &str_sentinel_value) {
scores[1] = str_sort_index.at(sort_fields[1].name)->rank(seq_id);
+ if(scores[1] == adi_tree_t::NOT_FOUND) {
+ if(sort_fields[1].order == sort_field_const::asc &&
+ sort_fields[1].missing_values == sort_by::missing_values_t::first) {
+ scores[1] = -scores[1];
+ }
+
+ else if(sort_fields[1].order == sort_field_const::desc &&
+ sort_fields[1].missing_values == sort_by::missing_values_t::last) {
+ scores[1] = -scores[1];
+ }
+ }
} else {
auto it = field_values[1]->find(seq_id);
scores[1] = (it == field_values[1]->end()) ? default_score : it->second;
@@ -3305,6 +3327,17 @@ void Index::compute_sort_scores(const std::vector<sort_by>& sort_fields, const i
scores[2] = geopoint_distances[2];
} else if(field_values[2] == &str_sentinel_value) {
scores[2] = str_sort_index.at(sort_fields[2].name)->rank(seq_id);
+ if(scores[2] == adi_tree_t::NOT_FOUND) {
+ if(sort_fields[2].order == sort_field_const::asc &&
+ sort_fields[2].missing_values == sort_by::missing_values_t::first) {
+ scores[2] = -scores[2];
+ }
+
+ else if(sort_fields[2].order == sort_field_const::desc &&
+ sort_fields[2].missing_values == sort_by::missing_values_t::last) {
+ scores[2] = -scores[2];
+ }
+ }
} else {
auto it = field_values[2]->find(seq_id);
scores[2] = (it == field_values[2]->end()) ? default_score : it->second;
diff --git a/test/adi_tree_test.cpp b/test/adi_tree_test.cpp
index e78e18d0..e9409ae0 100644
--- a/test/adi_tree_test.cpp
+++ b/test/adi_tree_test.cpp
@@ -19,7 +19,7 @@ TEST_F(ADITreeTest, BasicOps) {
adi_tree_t tree;
// operations on fresh tree
- ASSERT_EQ(UINT64_MAX, tree.rank(100));
+ ASSERT_EQ(INT64_MAX, tree.rank(100));
tree.remove(100);
tree.index(100, "f");
@@ -33,8 +33,8 @@ TEST_F(ADITreeTest, BasicOps) {
ASSERT_EQ(1, tree.rank(100));
tree.remove(100);
- ASSERT_EQ(UINT64_MAX, tree.rank(100));
- ASSERT_EQ(UINT64_MAX, tree.rank(101));
+ ASSERT_EQ(INT64_MAX, tree.rank(100));
+ ASSERT_EQ(INT64_MAX, tree.rank(101));
}
TEST_F(ADITreeTest, OverlappedString) {
@@ -48,8 +48,8 @@ TEST_F(ADITreeTest, OverlappedString) {
tree.remove(1);
tree.remove(2);
- ASSERT_EQ(UINT64_MAX, tree.rank(2));
- ASSERT_EQ(UINT64_MAX, tree.rank(1));
+ ASSERT_EQ(INT64_MAX, tree.rank(2));
+ ASSERT_EQ(INT64_MAX, tree.rank(1));
}
TEST_F(ADITreeTest, OrderInsertedStrings) {
@@ -100,8 +100,8 @@ TEST_F(ADITreeTest, InsertDuplicateAndDelete) {
tree.remove(100);
tree.remove(101);
- ASSERT_EQ(UINT64_MAX, tree.rank(100));
- ASSERT_EQ(UINT64_MAX, tree.rank(101));
+ ASSERT_EQ(INT64_MAX, tree.rank(100));
+ ASSERT_EQ(INT64_MAX, tree.rank(101));
ASSERT_EQ(nullptr, tree.get_root());
}
diff --git a/test/collection_sorting_test.cpp b/test/collection_sorting_test.cpp
index 1b8fa703..4672f9de 100644
--- a/test/collection_sorting_test.cpp
+++ b/test/collection_sorting_test.cpp
@@ -661,7 +661,7 @@ TEST_F(CollectionSortingTest, GeoPointSorting) {
{}, bad_geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_STREQ("Bad syntax for geopoint sorting field `loc`", res_op.error().c_str());
+ ASSERT_STREQ("Bad syntax for sorting field `loc`", res_op.error().c_str());
bad_geo_sort_fields = {
sort_by("loc(x, y)", "ASC")
@@ -672,7 +672,7 @@ TEST_F(CollectionSortingTest, GeoPointSorting) {
{}, bad_geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_STREQ("Bad syntax for geopoint sorting field `loc`", res_op.error().c_str());
+ ASSERT_STREQ("Bad syntax for sorting field `loc`", res_op.error().c_str());
bad_geo_sort_fields = {
sort_by("loc(", "ASC")
@@ -809,7 +809,7 @@ TEST_F(CollectionSortingTest, GeoPointSortingWithExcludeRadius) {
{}, geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_EQ("Bad syntax for geopoint sorting field `loc`", res_op.error());
+ ASSERT_EQ("Bad syntax for sorting field `loc`", res_op.error());
geo_sort_fields = { sort_by("loc(32.24348, 77.1893, exclude_radius: 1 meter)", "ASC") };
res_op = coll1->search("*", {}, "loc: (32.24348, 77.1893, 20 km)",
@@ -830,7 +830,7 @@ TEST_F(CollectionSortingTest, GeoPointSortingWithExcludeRadius) {
{}, geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_EQ("Bad syntax for geopoint sorting field `loc`", res_op.error());
+ ASSERT_EQ("Bad syntax for sorting field `loc`", res_op.error());
geo_sort_fields = { sort_by("loc(32.24348, 77.1893, exclude_radius: 1k)", "ASC") };
res_op = coll1->search("*", {}, "loc: (32.24348, 77.1893, 20 km)",
@@ -842,7 +842,7 @@ TEST_F(CollectionSortingTest, GeoPointSortingWithExcludeRadius) {
res_op = coll1->search("*", {}, "loc: (32.24348, 77.1893, 20 km)",
{}, geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_EQ("Bad syntax for geopoint sorting field `loc`", res_op.error());
+ ASSERT_EQ("Bad syntax for sorting field `loc`", res_op.error());
collectionManager.drop_collection("coll1");
}
@@ -915,7 +915,7 @@ TEST_F(CollectionSortingTest, GeoPointSortingWithPrecision) {
{}, geo_sort_fields, {0}, 10, 1, FREQUENCY);
ASSERT_FALSE(res_op.ok());
- ASSERT_EQ("Bad syntax for geopoint sorting field `loc`", res_op.error());
+ ASSERT_EQ("Bad syntax for sorting field `loc`", res_op.error());
geo_sort_fields = { sort_by("loc(32.24348, 77.1893, precision: 1 meter)", "ASC") };
res_op = coll1->search("*", {}, "loc: (32.24348, 77.1893, 20 km)",
@@ -1259,6 +1259,264 @@ TEST_F(CollectionSortingTest, SortByIntegerAndString) {
collectionManager.drop_collection("coll1");
}
+TEST_F(CollectionSortingTest, SortByStringEmptyValuesConfigFirstField) {
+ Collection *coll1;
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", true),
+ field("points1", field_types::INT32, false),
+ field("points2", field_types::INT32, false)};
+
+ coll1 = collectionManager.get_collection("coll1").get();
+ if(coll1 == nullptr) {
+ coll1 = collectionManager.create_collection("coll1", 1, fields, "points1").get();
+ }
+
+ std::vector<std::string> tokens = {
+ "alpha", "beta", "", "gamma"
+ };
+
+ for(size_t i = 0; i < tokens.size(); i++) {
+ std::string title = tokens[i];
+ nlohmann::json doc;
+ doc["title"] = title;
+ doc["points1"] = 100;
+ doc["points2"] = 100;
+ coll1->add(doc.dump());
+ }
+
+ // ascending
+ std::vector<sort_by> sort_fields = {
+ sort_by("title(missing_values: first)", "ASC"),
+ };
+ auto results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("title(missing_values: last)", "ASC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // descending
+ sort_fields = {
+ sort_by("title(missing_values: first)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("title(missing_values: last)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // without explicit arg, missing values will be deemed as having largest value (same as SQL)
+ sort_fields = {
+ sort_by("title", "asc"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("title", "desc"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ // natural order
+ sort_fields = {
+ sort_by("title(missing_values: ordered)", "asc"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("title(missing_values: ordered)", "desc"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ // bad syntax
+ sort_fields = {
+ sort_by("title(foo: bar)", "desc"),
+ };
+ auto res_op = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true});
+ ASSERT_FALSE(res_op.ok());
+ ASSERT_EQ("Bad syntax for sorting field `title`", res_op.error());
+
+ sort_fields = {
+ sort_by("title(missing_values: bar)", "desc"),
+ };
+ res_op = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true});
+ ASSERT_FALSE(res_op.ok());
+ ASSERT_EQ("Bad syntax for sorting field `title`", res_op.error());
+}
+
+TEST_F(CollectionSortingTest, SortByStringEmptyValuesConfigSecondField) {
+ Collection *coll1;
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", true),
+ field("points1", field_types::INT32, false),
+ field("points2", field_types::INT32, false)};
+
+ coll1 = collectionManager.get_collection("coll1").get();
+ if(coll1 == nullptr) {
+ coll1 = collectionManager.create_collection("coll1", 1, fields, "points1").get();
+ }
+
+ std::vector<std::string> tokens = {
+ "alpha", "beta", "", "gamma"
+ };
+
+ for(size_t i = 0; i < tokens.size(); i++) {
+ std::string title = tokens[i];
+ nlohmann::json doc;
+ doc["title"] = title;
+ doc["points1"] = 100;
+ doc["points2"] = 100;
+ coll1->add(doc.dump());
+ }
+
+ // ascending
+ std::vector<sort_by> sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title(missing_values: first)", "ASC"),
+ };
+ auto results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title(missing_values: last)", "ASC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // descending
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title(missing_values: first)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title(missing_values: last)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // without explicit arg, missing values will be deemed as having largest value (same as SQL)
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title", "ASC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("title", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+}
+
+TEST_F(CollectionSortingTest, SortByStringEmptyValuesConfigThirdField) {
+ Collection *coll1;
+ std::vector<field> fields = {field("title", field_types::STRING, false, false, true, "", true),
+ field("points1", field_types::INT32, false),
+ field("points2", field_types::INT32, false)};
+
+ coll1 = collectionManager.get_collection("coll1").get();
+ if(coll1 == nullptr) {
+ coll1 = collectionManager.create_collection("coll1", 1, fields, "points1").get();
+ }
+
+ std::vector<std::string> tokens = {
+ "alpha", "beta", "", "gamma"
+ };
+
+ for(size_t i = 0; i < tokens.size(); i++) {
+ std::string title = tokens[i];
+ nlohmann::json doc;
+ doc["title"] = title;
+ doc["points1"] = 100;
+ doc["points2"] = 100;
+ coll1->add(doc.dump());
+ }
+
+ // ascending
+ std::vector<sort_by> sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title(missing_values: first)", "ASC"),
+ };
+ auto results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title(missing_values: last)", "ASC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // descending
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title(missing_values: first)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title(missing_values: last)", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ // without explicit arg, missing values will be deemed as having largest value (same as SQL)
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title", "ASC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][3]["document"]["id"].get<std::string>());
+
+ sort_fields = {
+ sort_by("points1", "ASC"),
+ sort_by("points2", "ASC"),
+ sort_by("title", "DESC"),
+ };
+ results = coll1->search("*", {"title"}, "", {}, sort_fields, {0}, 10, 1, MAX_SCORE, {true}).get();
+ ASSERT_EQ(4, results["hits"].size());
+ ASSERT_EQ("2", results["hits"][0]["document"]["id"].get<std::string>());
+}
+
TEST_F(CollectionSortingTest, TextMatchBucketRanking) {
std::vector<field> fields = {field("title", field_types::STRING, false),
field("description", field_types::STRING, false),