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
C++ algoliadatastoreelasticsearchenterprise-searchfacetingfull-text-searchfuzzy-searchgeosearchin-memoryinstantsearchmerchandisingpineconesearchsearch-enginesemantic-searchsimilarity-searchsite-searchsynonymstypo-tolerancevector-search
String sort: allow missing values to be sent to either end.
Kishore Nallancf3b28bb77b3
diff --git a/include/adi_tree.h b/include/adi_tree.hindex 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.hindex 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.cppindex 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.cppindex 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 iscores[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 iscores[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 iscores[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.cppindex 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.cppindex 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),