Return an error when an attribute is not searchable

meilisearch-types/src/error.rs

@@ -224,6 +224,7 @@ InvalidIndexLimit                     , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexOffset                    , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexPrimaryKey                , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexUid                       , InvalidRequest       , BAD_REQUEST ;
+InvalidAttributesToSearchOn   , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToCrop         , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToHighlight    , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToRetrieve     , InvalidRequest       , BAD_REQUEST ;
@@ -240,8 +241,6 @@ InvalidSearchOffset                   , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchPage                     , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchQ                        , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchShowMatchesPosition      , InvalidRequest       , BAD_REQUEST ;
-InvalidSearchShowRankingScore         , InvalidRequest       , BAD_REQUEST ;
-InvalidSearchShowRankingScoreDetails  , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchSort                     , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDisplayedAttributes    , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDistinctAttribute      , InvalidRequest       , BAD_REQUEST ;
@@ -332,6 +331,9 @@ impl ErrorCode for milli::Error {
                     UserError::SortRankingRuleMissing => Code::InvalidSearchSort,
                     UserError::InvalidFacetsDistribution { .. } => Code::InvalidSearchFacets,
                     UserError::InvalidSortableAttribute { .. } => Code::InvalidSearchSort,
+                    UserError::InvalidSearchableAttribute { .. } => {
+                        Code::InvalidAttributesToSearchOn
+                    }
                     UserError::CriterionError(_) => Code::InvalidSettingsRankingRules,
                     UserError::InvalidGeoField { .. } => Code::InvalidDocumentGeoField,
                     UserError::SortError(_) => Code::InvalidSearchSort,

meilisearch/src/routes/indexes/search.rs

@@ -56,10 +56,6 @@ pub struct SearchQueryGet {
     sort: Option<String>,
     #[deserr(default, error = DeserrQueryParamError<InvalidSearchShowMatchesPosition>)]
     show_matches_position: Param<bool>,
-    #[deserr(default, error = DeserrQueryParamError<InvalidSearchShowRankingScore>)]
-    show_ranking_score: Param<bool>,
-    #[deserr(default, error = DeserrQueryParamError<InvalidSearchShowRankingScoreDetails>)]
-    show_ranking_score_details: Param<bool>,
     #[deserr(default, error = DeserrQueryParamError<InvalidSearchFacets>)]
     facets: Option<CS<String>>,
     #[deserr( default = DEFAULT_HIGHLIGHT_PRE_TAG(), error = DeserrQueryParamError<InvalidSearchHighlightPreTag>)]
@@ -70,6 +66,8 @@ pub struct SearchQueryGet {
     crop_marker: String,
     #[deserr(default, error = DeserrQueryParamError<InvalidSearchMatchingStrategy>)]
     matching_strategy: MatchingStrategy,
+    #[deserr(default, error = DeserrQueryParamError<InvalidAttributesToSearchOn>)]
+    pub attributes_to_search_on: Option<CS<String>>,
 }
 
 impl From<SearchQueryGet> for SearchQuery {
@@ -95,13 +93,12 @@ impl From<SearchQueryGet> for SearchQuery {
             filter,
             sort: other.sort.map(|attr| fix_sort_query_parameters(&attr)),
             show_matches_position: other.show_matches_position.0,
-            show_ranking_score: other.show_ranking_score.0,
-            show_ranking_score_details: other.show_ranking_score_details.0,
             facets: other.facets.map(|o| o.into_iter().collect()),
             highlight_pre_tag: other.highlight_pre_tag,
             highlight_post_tag: other.highlight_post_tag,
             crop_marker: other.crop_marker,
             matching_strategy: other.matching_strategy,
+            attributes_to_search_on: other.attributes_to_search_on.map(|o| o.into_iter().collect()),
         }
     }
 }

meilisearch/src/search.rs

@@ -9,7 +9,6 @@ use meilisearch_auth::IndexSearchRules;
 use meilisearch_types::deserr::DeserrJsonError;
 use meilisearch_types::error::deserr_codes::*;
 use meilisearch_types::index_uid::IndexUid;
-use meilisearch_types::milli::score_details::{ScoreDetails, ScoringStrategy};
 use meilisearch_types::settings::DEFAULT_PAGINATION_MAX_TOTAL_HITS;
 use meilisearch_types::{milli, Document};
 use milli::tokenizer::TokenizerBuilder;
@@ -55,10 +54,6 @@ pub struct SearchQuery {
     pub attributes_to_highlight: Option<HashSet<String>>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchShowMatchesPosition>, default)]
     pub show_matches_position: bool,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchShowRankingScore>, default)]
-    pub show_ranking_score: bool,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchShowRankingScoreDetails>, default)]
-    pub show_ranking_score_details: bool,
     #[deserr(default, error = DeserrJsonError<InvalidSearchFilter>)]
     pub filter: Option<Value>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchSort>)]
@@ -73,6 +68,8 @@ pub struct SearchQuery {
     pub crop_marker: String,
     #[deserr(default, error = DeserrJsonError<InvalidSearchMatchingStrategy>, default)]
     pub matching_strategy: MatchingStrategy,
+    #[deserr(default, error = DeserrJsonError<InvalidAttributesToSearchOn>, default)]
+    pub attributes_to_search_on: Option<Vec<String>>,
 }
 
 impl SearchQuery {
@@ -108,10 +105,6 @@ pub struct SearchQueryWithIndex {
     pub crop_length: usize,
     #[deserr(default, error = DeserrJsonError<InvalidSearchAttributesToHighlight>)]
     pub attributes_to_highlight: Option<HashSet<String>>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchShowRankingScore>, default)]
-    pub show_ranking_score: bool,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchShowRankingScoreDetails>, default)]
-    pub show_ranking_score_details: bool,
     #[deserr(default, error = DeserrJsonError<InvalidSearchShowMatchesPosition>, default)]
     pub show_matches_position: bool,
     #[deserr(default, error = DeserrJsonError<InvalidSearchFilter>)]
@@ -128,6 +121,8 @@ pub struct SearchQueryWithIndex {
     pub crop_marker: String,
     #[deserr(default, error = DeserrJsonError<InvalidSearchMatchingStrategy>, default)]
     pub matching_strategy: MatchingStrategy,
+    #[deserr(default, error = DeserrJsonError<InvalidAttributesToSearchOn>, default)]
+    pub attributes_to_search_on: Option<Vec<String>>,
 }
 
 impl SearchQueryWithIndex {
@@ -143,8 +138,6 @@ impl SearchQueryWithIndex {
             attributes_to_crop,
             crop_length,
             attributes_to_highlight,
-            show_ranking_score,
-            show_ranking_score_details,
             show_matches_position,
             filter,
             sort,
@@ -153,6 +146,7 @@ impl SearchQueryWithIndex {
             highlight_post_tag,
             crop_marker,
             matching_strategy,
+            attributes_to_search_on,
         } = self;
         (
             index_uid,
@@ -166,8 +160,6 @@ impl SearchQueryWithIndex {
                 attributes_to_crop,
                 crop_length,
                 attributes_to_highlight,
-                show_ranking_score,
-                show_ranking_score_details,
                 show_matches_position,
                 filter,
                 sort,
@@ -176,6 +168,7 @@ impl SearchQueryWithIndex {
                 highlight_post_tag,
                 crop_marker,
                 matching_strategy,
+                attributes_to_search_on,
                 // do not use ..Default::default() here,
                 // rather add any missing field from `SearchQuery` to `SearchQueryWithIndex`
             },
@@ -207,7 +200,7 @@ impl From<MatchingStrategy> for TermsMatchingStrategy {
     }
 }
 
-#[derive(Debug, Clone, Serialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 pub struct SearchHit {
     #[serde(flatten)]
     pub document: Document,
@@ -215,10 +208,6 @@ pub struct SearchHit {
     pub formatted: Document,
     #[serde(rename = "_matchesPosition", skip_serializing_if = "Option::is_none")]
     pub matches_position: Option<MatchesPosition>,
-    #[serde(rename = "_rankingScore", skip_serializing_if = "Option::is_none")]
-    pub ranking_score: Option<f64>,
-    #[serde(rename = "_rankingScoreDetails", skip_serializing_if = "Option::is_none")]
-    pub ranking_score_details: Option<serde_json::Map<String, serde_json::Value>>,
 }
 
 #[derive(Serialize, Debug, Clone, PartialEq)]
@@ -291,6 +280,10 @@ pub fn perform_search(
         search.query(query);
     }
 
+    if let Some(ref searchable) = query.attributes_to_search_on {
+        search.searchable_attributes(searchable);
+    }
+
     let is_finite_pagination = query.is_finite_pagination();
     search.terms_matching_strategy(query.matching_strategy.into());
 
@@ -300,11 +293,6 @@ pub fn perform_search(
         .unwrap_or(DEFAULT_PAGINATION_MAX_TOTAL_HITS);
 
     search.exhaustive_number_hits(is_finite_pagination);
-    search.scoring_strategy(if query.show_ranking_score || query.show_ranking_score_details {
-        ScoringStrategy::Detailed
-    } else {
-        ScoringStrategy::Skip
-    });
 
     // compute the offset on the limit depending on the pagination mode.
     let (offset, limit) = if is_finite_pagination {
@@ -342,8 +330,7 @@ pub fn perform_search(
         search.sort_criteria(sort);
     }
 
-    let milli::SearchResult { documents_ids, matching_words, candidates, document_scores, .. } =
-        search.execute()?;
+    let milli::SearchResult { documents_ids, matching_words, candidates, .. } = search.execute()?;
 
     let fields_ids_map = index.fields_ids_map(&rtxn).unwrap();
 
@@ -415,7 +402,7 @@ pub fn perform_search(
 
     let documents_iter = index.documents(&rtxn, documents_ids)?;
 
-    for ((_id, obkv), score) in documents_iter.into_iter().zip(document_scores.into_iter()) {
+    for (_id, obkv) in documents_iter {
         // First generate a document with all the displayed fields
         let displayed_document = make_document(&displayed_ids, &fields_ids_map, obkv)?;
 
@@ -439,18 +426,7 @@ pub fn perform_search(
             insert_geo_distance(sort, &mut document);
         }
 
-        let ranking_score =
-            query.show_ranking_score.then(|| ScoreDetails::global_score(score.iter()));
-        let ranking_score_details =
-            query.show_ranking_score_details.then(|| ScoreDetails::to_json_map(score.iter()));
-
-        let hit = SearchHit {
-            document,
-            formatted,
-            matches_position,
-            ranking_score_details,
-            ranking_score,
-        };
+        let hit = SearchHit { document, formatted, matches_position };
         documents.push(hit);
     }
 

meilisearch/tests/search/errors.rs

@@ -963,3 +963,27 @@ async fn sort_unset_ranking_rule() {
         )
         .await;
 }
+
+#[actix_rt::test]
+async fn search_on_unknown_field() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let documents = DOCUMENTS.clone();
+    index.add_documents(documents, None).await;
+    index.wait_task(0).await;
+
+    index
+        .search(
+            json!({"q": "Captain Marvel", "attributesToSearchOn": ["unknown"]}),
+            |response, code| {
+                assert_eq!(400, code, "{}", response);
+                assert_eq!(response, json!({
+                    "message": "Attribute `unknown` is not searchable. Available searchable attributes are: `id, title`.",
+                    "code": "invalid_attributes_to_search_on",
+                    "type": "invalid_request",
+                    "link": "https://docs.meilisearch.com/errors#invalid_attributes_to_search_on"
+                }));
+            },
+        )
+        .await;
+}

meilisearch/tests/search/formatted.rs

@@ -1,4 +1,3 @@
-use insta::{allow_duplicates, assert_json_snapshot};
 use serde_json::json;
 
 use super::*;
@@ -19,43 +18,30 @@ async fn formatted_contain_wildcard() {
         |response, code|
         {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-              assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-              {
-                "_formatted": {
-                  "id": "852",
-                  "cattos": "<em>pésti</em>"
-                },
-                "_matchesPosition": {
-                  "cattos": [
-                    {
-                      "start": 0,
-                      "length": 5
-                    }
-                  ]
-                }
-              }
-              "###);
-            }
-    }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "_formatted": {
+                        "id": "852",
+                        "cattos": "<em>pésti</em>",
+                    },
+                    "_matchesPosition": {"cattos": [{"start": 0, "length": 5}]},
+                })
+            );
+        }
     )
     .await;
 
     index
         .search(json!({ "q": "pésti", "attributesToRetrieve": ["*"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852,
-                  "cattos": "pésti"
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                    "cattos": "pésti",
+                })
+            );
         })
         .await;
 
@@ -64,29 +50,20 @@ async fn formatted_contain_wildcard() {
             json!({ "q": "pésti", "attributesToRetrieve": ["*"], "attributesToHighlight": ["id"], "showMatchesPosition": true }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                  assert_json_snapshot!(response["hits"][0],
-                 { "._rankingScore" => "[score]" },
-                 @r###"
-                  {
-                    "id": 852,
-                    "cattos": "pésti",
-                    "_formatted": {
-                      "id": "852",
-                      "cattos": "pésti"
-                    },
-                    "_matchesPosition": {
-                      "cattos": [
-                        {
-                          "start": 0,
-                          "length": 5
-                        }
-                      ]
-                    }
-                  }
-                  "###)
-             }
-        })
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "id": 852,
+                        "cattos": "pésti",
+                        "_formatted": {
+                            "id": "852",
+                            "cattos": "pésti",
+                        },
+                        "_matchesPosition": {"cattos": [{"start": 0, "length": 5}]},
+                    })
+                );
+            }
+        )
         .await;
 
     index
@@ -94,20 +71,17 @@ async fn formatted_contain_wildcard() {
             json!({ "q": "pésti", "attributesToRetrieve": ["*"], "attributesToCrop": ["*"] }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "id": 852,
-                      "cattos": "pésti",
-                      "_formatted": {
-                        "id": "852",
-                        "cattos": "pésti"
-                      }
-                    }
-                    "###);
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "id": 852,
+                        "cattos": "pésti",
+                        "_formatted": {
+                            "id": "852",
+                            "cattos": "pésti",
+                        }
+                    })
+                );
             },
         )
         .await;
@@ -115,20 +89,17 @@ async fn formatted_contain_wildcard() {
     index
         .search(json!({ "q": "pésti", "attributesToCrop": ["*"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852,
-                  "cattos": "pésti",
-                  "_formatted": {
-                    "id": "852",
-                    "cattos": "pésti"
-                  }
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                    "cattos": "pésti",
+                    "_formatted": {
+                        "id": "852",
+                        "cattos": "pésti",
+                    }
+                })
+            );
         })
         .await;
 }
@@ -145,24 +116,21 @@ async fn format_nested() {
     index
         .search(json!({ "q": "pésti", "attributesToRetrieve": ["doggos"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "doggos": [
-                    {
-                      "name": "bobby",
-                      "age": 2
-                    },
-                    {
-                      "name": "buddy",
-                      "age": 4
-                    }
-                  ]
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "doggos": [
+                        {
+                            "name": "bobby",
+                            "age": 2,
+                        },
+                        {
+                            "name": "buddy",
+                            "age": 4,
+                        },
+                    ],
+                })
+            );
         })
         .await;
 
@@ -171,22 +139,19 @@ async fn format_nested() {
             json!({ "q": "pésti", "attributesToRetrieve": ["doggos.name"] }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "doggos": [
-                        {
-                          "name": "bobby"
-                        },
-                        {
-                          "name": "buddy"
-                        }
-                      ]
-                    }
-                    "###)
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "doggos": [
+                            {
+                                "name": "bobby",
+                            },
+                            {
+                                "name": "buddy",
+                            },
+                        ],
+                    })
+                );
             },
         )
         .await;
@@ -196,30 +161,20 @@ async fn format_nested() {
             json!({ "q": "bobby", "attributesToRetrieve": ["doggos.name"], "showMatchesPosition": true }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "doggos": [
-                        {
-                          "name": "bobby"
-                        },
-                        {
-                          "name": "buddy"
-                        }
-                      ],
-                      "_matchesPosition": {
-                        "doggos.name": [
-                          {
-                            "start": 0,
-                            "length": 5
-                          }
-                        ]
-                      }
-                    }
-                    "###)
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "doggos": [
+                            {
+                                "name": "bobby",
+                            },
+                            {
+                                "name": "buddy",
+                            },
+                        ],
+                        "_matchesPosition": {"doggos.name": [{"start": 0, "length": 5}]},
+                    })
+                );
             }
         )
         .await;
@@ -228,24 +183,21 @@ async fn format_nested() {
         .search(json!({ "q": "pésti", "attributesToRetrieve": [], "attributesToHighlight": ["doggos.name"] }),
         |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "_formatted": {
-                    "doggos": [
-                      {
-                        "name": "bobby"
-                      },
-                      {
-                        "name": "buddy"
-                      }
-                    ]
-                  }
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "_formatted": {
+                        "doggos": [
+                            {
+                                "name": "bobby",
+                            },
+                            {
+                                "name": "buddy",
+                            },
+                        ],
+                    },
+                })
+            );
         })
         .await;
 
@@ -253,24 +205,21 @@ async fn format_nested() {
         .search(json!({ "q": "pésti", "attributesToRetrieve": [], "attributesToCrop": ["doggos.name"] }),
         |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "_formatted": {
-                    "doggos": [
-                      {
-                        "name": "bobby"
-                      },
-                      {
-                        "name": "buddy"
-                      }
-                    ]
-                  }
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "_formatted": {
+                        "doggos": [
+                            {
+                                "name": "bobby",
+                            },
+                            {
+                                "name": "buddy",
+                            },
+                        ],
+                    },
+                })
+            );
         })
         .await;
 
@@ -278,61 +227,55 @@ async fn format_nested() {
         .search(json!({ "q": "pésti", "attributesToRetrieve": ["doggos.name"], "attributesToHighlight": ["doggos.age"] }),
         |response, code| {
     assert_eq!(code, 200, "{}", response);
-    allow_duplicates! {
-        assert_json_snapshot!(response["hits"][0],
-        { "._rankingScore" => "[score]" },
-        @r###"
-        {
-          "doggos": [
-            {
-              "name": "bobby"
-            },
-            {
-              "name": "buddy"
-            }
-          ],
-          "_formatted": {
+    assert_eq!(
+        response["hits"][0],
+        json!({
             "doggos": [
-              {
-                "name": "bobby",
-                "age": "2"
-              },
-              {
-                "name": "buddy",
-                "age": "4"
-              }
-            ]
-          }
-        }
-        "###)
-    }
-    })
+                {
+                    "name": "bobby",
+                },
+                {
+                    "name": "buddy",
+                },
+            ],
+            "_formatted": {
+                "doggos": [
+                    {
+                        "name": "bobby",
+                        "age": "2",
+                    },
+                    {
+                        "name": "buddy",
+                        "age": "4",
+                    },
+                ],
+            },
+        })
+    );
+        })
         .await;
 
     index
         .search(json!({ "q": "pésti", "attributesToRetrieve": [], "attributesToHighlight": ["doggos.age"], "attributesToCrop": ["doggos.name"] }),
         |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
+    assert_eq!(
+        response["hits"][0],
+        json!({
+            "_formatted": {
+                "doggos": [
                     {
-                      "_formatted": {
-                        "doggos": [
-                          {
-                            "name": "bobby",
-                            "age": "2"
-                          },
-                          {
-                            "name": "buddy",
-                            "age": "4"
-                          }
-                        ]
-                      }
-                    }
-                    "###)
-                }
+                        "name": "bobby",
+                        "age": "2",
+                    },
+                    {
+                        "name": "buddy",
+                        "age": "4",
+                    },
+                ],
+            },
+        })
+    );
             }
         )
         .await;
@@ -354,66 +297,54 @@ async fn displayedattr_2_smol() {
         .search(json!({ "attributesToRetrieve": ["father", "id"], "attributesToHighlight": ["mother"], "attributesToCrop": ["cattos"] }),
         |response, code| {
     assert_eq!(code, 200, "{}", response);
-    allow_duplicates! {
-        assert_json_snapshot!(response["hits"][0],
-        { "._rankingScore" => "[score]" },
-        @r###"
-        {
-          "id": 852
-        }
-        "###)
-    }
+    assert_eq!(
+        response["hits"][0],
+        json!({
+            "id": 852,
+        })
+    );
         })
         .await;
 
     index
         .search(json!({ "attributesToRetrieve": ["id"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                })
+            );
         })
         .await;
 
     index
         .search(json!({ "attributesToHighlight": ["id"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852,
-                  "_formatted": {
-                    "id": "852"
-                  }
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                    "_formatted": {
+                        "id": "852",
+                    }
+                })
+            );
         })
         .await;
 
     index
         .search(json!({ "attributesToCrop": ["id"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852,
-                  "_formatted": {
-                    "id": "852"
-                  }
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                    "_formatted": {
+                        "id": "852",
+                    }
+                })
+            );
         })
         .await;
 
@@ -422,18 +353,15 @@ async fn displayedattr_2_smol() {
             json!({ "attributesToHighlight": ["id"], "attributesToCrop": ["id"] }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "id": 852,
-                      "_formatted": {
-                        "id": "852"
-                      }
-                    }
-                    "###)
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "id": 852,
+                        "_formatted": {
+                            "id": "852",
+                        }
+                    })
+                );
             },
         )
         .await;
@@ -441,41 +369,31 @@ async fn displayedattr_2_smol() {
     index
         .search(json!({ "attributesToHighlight": ["cattos"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                })
+            );
         })
         .await;
 
     index
         .search(json!({ "attributesToCrop": ["cattos"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @r###"
-                {
-                  "id": 852
-                }
-                "###)
-            }
+            assert_eq!(
+                response["hits"][0],
+                json!({
+                    "id": 852,
+                })
+            );
         })
         .await;
 
     index
         .search(json!({ "attributesToRetrieve": ["cattos"] }), |response, code| {
             assert_eq!(code, 200, "{}", response);
-            allow_duplicates! {
-                assert_json_snapshot!(response["hits"][0],
-                { "._rankingScore" => "[score]" },
-                @"{}")
-            }
+            assert_eq!(response["hits"][0], json!({}));
         })
         .await;
 
@@ -484,11 +402,7 @@ async fn displayedattr_2_smol() {
             json!({ "attributesToRetrieve": ["cattos"], "attributesToHighlight": ["cattos"], "attributesToCrop": ["cattos"] }),
             |response, code| {
     assert_eq!(code, 200, "{}", response);
-    allow_duplicates! {
-        assert_json_snapshot!(response["hits"][0],
-        { "._rankingScore" => "[score]" },
-        @"{}")
-    }
+    assert_eq!(response["hits"][0], json!({}));
 
             }
         )
@@ -499,17 +413,14 @@ async fn displayedattr_2_smol() {
             json!({ "attributesToRetrieve": ["cattos"], "attributesToHighlight": ["id"] }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "_formatted": {
-                        "id": "852"
-                      }
-                    }
-                    "###)
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "_formatted": {
+                            "id": "852",
+                        }
+                    })
+                );
             },
         )
         .await;
@@ -519,17 +430,14 @@ async fn displayedattr_2_smol() {
             json!({ "attributesToRetrieve": ["cattos"], "attributesToCrop": ["id"] }),
             |response, code| {
                 assert_eq!(code, 200, "{}", response);
-                allow_duplicates! {
-                    assert_json_snapshot!(response["hits"][0],
-                    { "._rankingScore" => "[score]" },
-                    @r###"
-                    {
-                      "_formatted": {
-                        "id": "852"
-                      }
-                    }
-                    "###)
-                }
+                assert_eq!(
+                    response["hits"][0],
+                    json!({
+                        "_formatted": {
+                            "id": "852",
+                        }
+                    })
+                );
             },
         )
         .await;

meilisearch/tests/search/mod.rs

@@ -5,6 +5,7 @@ mod errors;
 mod formatted;
 mod multi;
 mod pagination;
+mod restrict_searchable;
 
 use once_cell::sync::Lazy;
 use serde_json::{json, Value};

meilisearch/tests/search/multi.rs

@@ -65,7 +65,7 @@ async fn simple_search_single_index() {
         ]}))
         .await;
     snapshot!(code, @"200 OK");
-    insta::assert_json_snapshot!(response["results"], { "[].processingTimeMs" => "[time]", ".**._rankingScore" => "[score]" }, @r###"
+    insta::assert_json_snapshot!(response["results"], { "[].processingTimeMs" => "[time]" }, @r###"
     [
       {
         "indexUid": "test",
@@ -170,7 +170,7 @@ async fn simple_search_two_indexes() {
         ]}))
         .await;
     snapshot!(code, @"200 OK");
-    insta::assert_json_snapshot!(response["results"], { "[].processingTimeMs" => "[time]", ".**._rankingScore" => "[score]" }, @r###"
+    insta::assert_json_snapshot!(response["results"], { "[].processingTimeMs" => "[time]" }, @r###"
     [
       {
         "indexUid": "test",

meilisearch/tests/search/restrict_searchable.rs

@@ -0,0 +1,241 @@
+use once_cell::sync::Lazy;
+use serde_json::{json, Value};
+
+use crate::common::index::Index;
+use crate::common::Server;
+
+async fn index_with_documents<'a>(server: &'a Server, documents: &Value) -> Index<'a> {
+    let index = server.index("test");
+
+    index.add_documents(documents.clone(), None).await;
+    index.wait_task(0).await;
+    index
+}
+
+static SIMPLE_SEARCH_DOCUMENTS: Lazy<Value> = Lazy::new(|| {
+    json!([
+    {
+        "title": "Shazam!",
+        "desc": "a Captain Marvel ersatz",
+        "id": "1",
+    },
+    {
+        "title": "Captain Planet",
+        "desc": "He's not part of the Marvel Cinematic Universe",
+        "id": "2",
+    },
+    {
+        "title": "Captain Marvel",
+        "desc": "a Shazam ersatz",
+        "id": "3",
+    }])
+});
+
+#[actix_rt::test]
+async fn simple_search_on_title() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+
+    // simple search should return 2 documents (ids: 2 and 3).
+    index
+        .search(
+            json!({"q": "Captain Marvel", "attributesToSearchOn": ["title"]}),
+            |response, code| {
+                assert_eq!(200, code, "{}", response);
+                assert_eq!(response["hits"].as_array().unwrap().len(), 2);
+            },
+        )
+        .await;
+}
+
+#[actix_rt::test]
+async fn simple_prefix_search_on_title() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+
+    // simple search should return 2 documents (ids: 2 and 3).
+    index
+        .search(json!({"q": "Captain Mar", "attributesToSearchOn": ["title"]}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(response["hits"].as_array().unwrap().len(), 2);
+        })
+        .await;
+}
+
+#[actix_rt::test]
+async fn simple_search_on_title_matching_strategy_all() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+    // simple search matching strategy all should only return 1 document (ids: 2).
+    index
+        .search(json!({"q": "Captain Marvel", "attributesToSearchOn": ["title"], "matchingStrategy": "all"}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(response["hits"].as_array().unwrap().len(), 1);
+        })
+        .await;
+}
+
+#[actix_rt::test]
+async fn simple_search_on_no_field() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+    // simple search on no field shouldn't return any document.
+    index
+        .search(json!({"q": "Captain Marvel", "attributesToSearchOn": []}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(response["hits"].as_array().unwrap().len(), 0);
+        })
+        .await;
+}
+
+#[actix_rt::test]
+async fn word_ranking_rule_order() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+
+    // Document 3 should appear before document 2.
+    index
+        .search(
+            json!({"q": "Captain Marvel", "attributesToSearchOn": ["title"], "attributesToRetrieve": ["id"]}),
+            |response, code| {
+                assert_eq!(200, code, "{}", response);
+                assert_eq!(
+                    response["hits"],
+                    json!([
+                        {"id": "3"},
+                        {"id": "2"},
+                    ])
+                );
+            },
+        )
+        .await;
+}
+
+#[actix_rt::test]
+async fn word_ranking_rule_order_exact_words() {
+    let server = Server::new().await;
+    let index = index_with_documents(&server, &SIMPLE_SEARCH_DOCUMENTS).await;
+    index.update_settings_typo_tolerance(json!({"disableOnWords": ["Captain", "Marvel"]})).await;
+    index.wait_task(1).await;
+
+    // simple search should return 2 documents (ids: 2 and 3).
+    index
+        .search(
+            json!({"q": "Captain Marvel", "attributesToSearchOn": ["title"], "attributesToRetrieve": ["id"]}),
+            |response, code| {
+                assert_eq!(200, code, "{}", response);
+                assert_eq!(
+                    response["hits"],
+                    json!([
+                        {"id": "3"},
+                        {"id": "2"},
+                    ])
+                );
+            },
+        )
+        .await;
+}
+
+#[actix_rt::test]
+async fn typo_ranking_rule_order() {
+    let server = Server::new().await;
+    let index = index_with_documents(
+        &server,
+        &json!([
+        {
+            "title": "Capitain Marivel",
+            "desc": "Captain Marvel",
+            "id": "1",
+        },
+        {
+            "title": "Captain Marivel",
+            "desc": "a Shazam ersatz",
+            "id": "2",
+        }]),
+    )
+    .await;
+
+    // Document 2 should appear before document 1.
+    index
+        .search(json!({"q": "Captain Marvel", "attributesToSearchOn": ["title"], "attributesToRetrieve": ["id"]}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(
+                response["hits"],
+                json!([
+                    {"id": "2"},
+                    {"id": "1"},
+                ])
+            );
+        })
+        .await;
+}
+
+#[actix_rt::test]
+async fn attributes_ranking_rule_order() {
+    let server = Server::new().await;
+    let index = index_with_documents(
+        &server,
+        &json!([
+        {
+            "title": "Captain Marvel",
+            "desc": "a Shazam ersatz",
+            "footer": "The story of Captain Marvel",
+            "id": "1",
+        },
+        {
+            "title": "The Avengers",
+            "desc": "Captain Marvel is far from the earth",
+            "footer": "A super hero team",
+            "id": "2",
+        }]),
+    )
+    .await;
+
+    // Document 2 should appear before document 1.
+    index
+        .search(json!({"q": "Captain Marvel", "attributesToSearchOn": ["desc", "footer"], "attributesToRetrieve": ["id"]}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(
+                response["hits"],
+                json!([
+                    {"id": "2"},
+                    {"id": "1"},
+                ])
+            );
+        })
+        .await;
+}
+
+#[actix_rt::test]
+async fn exactness_ranking_rule_order() {
+    let server = Server::new().await;
+    let index = index_with_documents(
+        &server,
+        &json!([
+        {
+            "title": "Captain Marvel",
+            "desc": "Captain Marivel",
+            "id": "1",
+        },
+        {
+            "title": "Captain Marvel",
+            "desc": "CaptainMarvel",
+            "id": "2",
+        }]),
+    )
+    .await;
+
+    // Document 2 should appear before document 1.
+    index
+        .search(json!({"q": "Captain Marvel", "attributesToRetrieve": ["id"], "attributesToSearchOn": ["desc"]}), |response, code| {
+            assert_eq!(200, code, "{}", response);
+            assert_eq!(
+                response["hits"],
+                json!([
+                    {"id": "2"},
+                    {"id": "1"},
+                ])
+            );
+        })
+        .await;
+}

milli/examples/search.rs

@@ -53,7 +53,6 @@ fn main() -> Result<(), Box<dyn Error>> {
                 &mut ctx,
                 &(!query.trim().is_empty()).then(|| query.trim().to_owned()),
                 TermsMatchingStrategy::Last,
-                milli::score_details::ScoringStrategy::Skip,
                 false,
                 &None,
                 &None,

milli/src/error.rs

@@ -124,6 +124,16 @@ only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and undersco
         }
     )]
     InvalidSortableAttribute { field: String, valid_fields: BTreeSet<String> },
+    #[error("Attribute `{}` is not searchable. Available searchable attributes are: `{}{}`.",
+        .field,
+        .valid_fields.iter().map(AsRef::as_ref).collect::<Vec<&str>>().join(", "),
+        .hidden_fields.then_some(", <..hidden-attributes>").unwrap_or(""),
+    )]
+    InvalidSearchableAttribute {
+        field: String,
+        valid_fields: BTreeSet<String>,
+        hidden_fields: bool,
+    },
     #[error("{}", HeedError::BadOpenOptions)]
     InvalidLmdbOpenOptions,
     #[error("You must specify where `sort` is listed in the rankingRules setting to use the sort parameter at search time.")]

milli/src/heed_codec/mod.rs

@@ -23,3 +23,9 @@ pub use self::roaring_bitmap_length::{
 pub use self::script_language_codec::ScriptLanguageCodec;
 pub use self::str_beu32_codec::{StrBEU16Codec, StrBEU32Codec};
 pub use self::str_str_u8_codec::{U8StrStrCodec, UncheckedU8StrStrCodec};
+
+pub trait BytesDecodeOwned {
+    type DItem;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem>;
+}

milli/src/heed_codec/roaring_bitmap/bo_roaring_bitmap_codec.rs

@@ -2,8 +2,11 @@ use std::borrow::Cow;
 use std::convert::TryInto;
 use std::mem::size_of;
 
+use heed::BytesDecode;
 use roaring::RoaringBitmap;
 
+use crate::heed_codec::BytesDecodeOwned;
+
 pub struct BoRoaringBitmapCodec;
 
 impl BoRoaringBitmapCodec {
@@ -13,7 +16,7 @@ impl BoRoaringBitmapCodec {
     }
 }
 
-impl heed::BytesDecode<'_> for BoRoaringBitmapCodec {
+impl BytesDecode<'_> for BoRoaringBitmapCodec {
     type DItem = RoaringBitmap;
 
     fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
@@ -28,6 +31,14 @@ impl heed::BytesDecode<'_> for BoRoaringBitmapCodec {
     }
 }
 
+impl BytesDecodeOwned for BoRoaringBitmapCodec {
+    type DItem = RoaringBitmap;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        Self::bytes_decode(bytes)
+    }
+}
+
 impl heed::BytesEncode<'_> for BoRoaringBitmapCodec {
     type EItem = RoaringBitmap;
 

milli/src/heed_codec/roaring_bitmap/cbo_roaring_bitmap_codec.rs

@@ -5,6 +5,8 @@ use std::mem::size_of;
 use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
 use roaring::RoaringBitmap;
 
+use crate::heed_codec::BytesDecodeOwned;
+
 /// This is the limit where using a byteorder became less size efficient
 /// than using a direct roaring encoding, it is also the point where we are able
 /// to determine the encoding used only by using the array of bytes length.
@@ -103,6 +105,14 @@ impl heed::BytesDecode<'_> for CboRoaringBitmapCodec {
     }
 }
 
+impl BytesDecodeOwned for CboRoaringBitmapCodec {
+    type DItem = RoaringBitmap;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        Self::deserialize_from(bytes).ok()
+    }
+}
+
 impl heed::BytesEncode<'_> for CboRoaringBitmapCodec {
     type EItem = RoaringBitmap;
 

milli/src/heed_codec/roaring_bitmap/roaring_bitmap_codec.rs

@@ -2,6 +2,8 @@ use std::borrow::Cow;
 
 use roaring::RoaringBitmap;
 
+use crate::heed_codec::BytesDecodeOwned;
+
 pub struct RoaringBitmapCodec;
 
 impl heed::BytesDecode<'_> for RoaringBitmapCodec {
@@ -12,6 +14,14 @@ impl heed::BytesDecode<'_> for RoaringBitmapCodec {
     }
 }
 
+impl BytesDecodeOwned for RoaringBitmapCodec {
+    type DItem = RoaringBitmap;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        RoaringBitmap::deserialize_from(bytes).ok()
+    }
+}
+
 impl heed::BytesEncode<'_> for RoaringBitmapCodec {
     type EItem = RoaringBitmap;
 

milli/src/heed_codec/roaring_bitmap_length/bo_roaring_bitmap_len_codec.rs

@@ -1,11 +1,23 @@
 use std::mem;
 
+use heed::BytesDecode;
+
+use crate::heed_codec::BytesDecodeOwned;
+
 pub struct BoRoaringBitmapLenCodec;
 
-impl heed::BytesDecode<'_> for BoRoaringBitmapLenCodec {
+impl BytesDecode<'_> for BoRoaringBitmapLenCodec {
     type DItem = u64;
 
     fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
         Some((bytes.len() / mem::size_of::<u32>()) as u64)
     }
 }
+
+impl BytesDecodeOwned for BoRoaringBitmapLenCodec {
+    type DItem = u64;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        Self::bytes_decode(bytes)
+    }
+}

milli/src/heed_codec/roaring_bitmap_length/cbo_roaring_bitmap_len_codec.rs

@@ -1,11 +1,14 @@
 use std::mem;
 
+use heed::BytesDecode;
+
 use super::{BoRoaringBitmapLenCodec, RoaringBitmapLenCodec};
 use crate::heed_codec::roaring_bitmap::cbo_roaring_bitmap_codec::THRESHOLD;
+use crate::heed_codec::BytesDecodeOwned;
 
 pub struct CboRoaringBitmapLenCodec;
 
-impl heed::BytesDecode<'_> for CboRoaringBitmapLenCodec {
+impl BytesDecode<'_> for CboRoaringBitmapLenCodec {
     type DItem = u64;
 
     fn bytes_decode(bytes: &[u8]) -> Option<Self::DItem> {
@@ -20,3 +23,11 @@ impl heed::BytesDecode<'_> for CboRoaringBitmapLenCodec {
         }
     }
 }
+
+impl BytesDecodeOwned for CboRoaringBitmapLenCodec {
+    type DItem = u64;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        Self::bytes_decode(bytes)
+    }
+}

milli/src/heed_codec/roaring_bitmap_length/roaring_bitmap_len_codec.rs

@@ -3,6 +3,8 @@ use std::mem;
 
 use byteorder::{LittleEndian, ReadBytesExt};
 
+use crate::heed_codec::BytesDecodeOwned;
+
 const SERIAL_COOKIE_NO_RUNCONTAINER: u32 = 12346;
 const SERIAL_COOKIE: u16 = 12347;
 
@@ -59,6 +61,14 @@ impl heed::BytesDecode<'_> for RoaringBitmapLenCodec {
     }
 }
 
+impl BytesDecodeOwned for RoaringBitmapLenCodec {
+    type DItem = u64;
+
+    fn bytes_decode_owned(bytes: &[u8]) -> Option<Self::DItem> {
+        RoaringBitmapLenCodec::deserialize_from_slice(bytes).ok()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use heed::BytesEncode;

milli/src/index.rs

@@ -1466,9 +1466,9 @@ pub(crate) mod tests {
 
         db_snap!(index, field_distribution,
             @r###"
-        age              1      |
-        id               2      |
-        name             2      |
+        age              1     
+        id               2     
+        name             2     
         "###
         );
 
@@ -1486,9 +1486,9 @@ pub(crate) mod tests {
 
         db_snap!(index, field_distribution,
             @r###"
-        age              1      |
-        id               2      |
-        name             2      |
+        age              1     
+        id               2     
+        name             2     
         "###
         );
 
@@ -1502,9 +1502,9 @@ pub(crate) mod tests {
 
         db_snap!(index, field_distribution,
             @r###"
-        has_dog          1      |
-        id               2      |
-        name             2      |
+        has_dog          1     
+        id               2     
+        name             2     
         "###
         );
     }
@@ -2488,12 +2488,8 @@ pub(crate) mod tests {
 
         let rtxn = index.read_txn().unwrap();
         let search = Search::new(&rtxn, &index);
-        let SearchResult {
-            matching_words: _,
-            candidates: _,
-            document_scores: _,
-            mut documents_ids,
-        } = search.execute().unwrap();
+        let SearchResult { matching_words: _, candidates: _, mut documents_ids } =
+            search.execute().unwrap();
         let primary_key_id = index.fields_ids_map(&rtxn).unwrap().id("primary_key").unwrap();
         documents_ids.sort_unstable();
         let docs = index.documents(&rtxn, documents_ids).unwrap();

milli/src/lib.rs

@@ -17,7 +17,6 @@ mod fields_ids_map;
 pub mod heed_codec;
 pub mod index;
 pub mod proximity;
-pub mod score_details;
 mod search;
 pub mod update;
 

milli/src/score_details.rs

@@ -1,316 +0,0 @@
-use serde::Serialize;
-
-use crate::distance_between_two_points;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum ScoreDetails {
-    Words(Words),
-    Typo(Typo),
-    Proximity(Rank),
-    Fid(Rank),
-    Position(Rank),
-    ExactAttribute(ExactAttribute),
-    Exactness(Rank),
-    Sort(Sort),
-    GeoSort(GeoSort),
-}
-
-impl ScoreDetails {
-    pub fn local_score(&self) -> Option<f64> {
-        self.rank().map(Rank::local_score)
-    }
-
-    pub fn rank(&self) -> Option<Rank> {
-        match self {
-            ScoreDetails::Words(details) => Some(details.rank()),
-            ScoreDetails::Typo(details) => Some(details.rank()),
-            ScoreDetails::Proximity(details) => Some(*details),
-            ScoreDetails::Fid(details) => Some(*details),
-            ScoreDetails::Position(details) => Some(*details),
-            ScoreDetails::ExactAttribute(details) => Some(details.rank()),
-            ScoreDetails::Exactness(details) => Some(*details),
-            ScoreDetails::Sort(_) => None,
-            ScoreDetails::GeoSort(_) => None,
-        }
-    }
-
-    pub fn global_score<'a>(details: impl Iterator<Item = &'a Self>) -> f64 {
-        Rank::global_score(details.filter_map(Self::rank))
-    }
-
-    /// Panics
-    ///
-    /// - If Position is not preceded by Fid
-    /// - If Exactness is not preceded by ExactAttribute
-    pub fn to_json_map<'a>(
-        details: impl Iterator<Item = &'a Self>,
-    ) -> serde_json::Map<String, serde_json::Value> {
-        let mut order = 0;
-        let mut fid_details = None;
-        let mut details_map = serde_json::Map::default();
-        for details in details {
-            match details {
-                ScoreDetails::Words(words) => {
-                    let words_details = serde_json::json!({
-                            "order": order,
-                            "matchingWords": words.matching_words,
-                            "maxMatchingWords": words.max_matching_words,
-                            "score": words.rank().local_score(),
-                    });
-                    details_map.insert("words".into(), words_details);
-                    order += 1;
-                }
-                ScoreDetails::Typo(typo) => {
-                    let typo_details = serde_json::json!({
-                        "order": order,
-                        "typoCount": typo.typo_count,
-                        "maxTypoCount": typo.max_typo_count,
-                        "score": typo.rank().local_score(),
-                    });
-                    details_map.insert("typo".into(), typo_details);
-                    order += 1;
-                }
-                ScoreDetails::Proximity(proximity) => {
-                    let proximity_details = serde_json::json!({
-                        "order": order,
-                        "score": proximity.local_score(),
-                    });
-                    details_map.insert("proximity".into(), proximity_details);
-                    order += 1;
-                }
-                ScoreDetails::Fid(fid) => {
-                    // copy the rank for future use in Position.
-                    fid_details = Some(*fid);
-                    // For now, fid is a virtual rule always followed by the "position" rule
-                    let fid_details = serde_json::json!({
-                        "order": order,
-                        "attributes_ranking_order": fid.local_score(),
-                    });
-                    details_map.insert("attribute".into(), fid_details);
-                    order += 1;
-                }
-                ScoreDetails::Position(position) => {
-                    // For now, position is a virtual rule always preceded by the "fid" rule
-                    let attribute_details = details_map
-                        .get_mut("attribute")
-                        .expect("position not preceded by attribute");
-                    let attribute_details = attribute_details
-                        .as_object_mut()
-                        .expect("attribute details was not an object");
-                    let Some(fid_details) = fid_details
-                    else {
-                        panic!("position not preceded by attribute");
-                    };
-
-                    attribute_details.insert(
-                        "attributes_query_word_order".into(),
-                        position.local_score().into(),
-                    );
-                    let score = Rank::global_score([fid_details, *position].iter().copied());
-                    attribute_details.insert("score".into(), score.into());
-
-                    // do not update the order since this was already done by fid
-                }
-                ScoreDetails::ExactAttribute(exact_attribute) => {
-                    let exactness_details = serde_json::json!({
-                        "order": order,
-                        "matchType": exact_attribute,
-                        "score": exact_attribute.rank().local_score(),
-                    });
-                    details_map.insert("exactness".into(), exactness_details);
-                    order += 1;
-                }
-                ScoreDetails::Exactness(details) => {
-                    // For now, exactness is a virtual rule always preceded by the "ExactAttribute" rule
-                    let exactness_details = details_map
-                        .get_mut("exactness")
-                        .expect("Exactness not preceded by exactAttribute");
-                    let exactness_details = exactness_details
-                        .as_object_mut()
-                        .expect("exactness details was not an object");
-                    if exactness_details.get("matchType").expect("missing 'matchType'")
-                        == &serde_json::json!(ExactAttribute::NoExactMatch)
-                    {
-                        let score = Rank::global_score(
-                            [ExactAttribute::NoExactMatch.rank(), *details].iter().copied(),
-                        );
-                        *exactness_details.get_mut("score").expect("missing score") = score.into();
-                    }
-                    // do not update the order since this was already done by exactAttribute
-                }
-                ScoreDetails::Sort(details) => {
-                    let sort = if details.redacted {
-                        format!("<hidden-rule-{order}>")
-                    } else {
-                        format!(
-                            "{}:{}",
-                            details.field_name,
-                            if details.ascending { "asc" } else { "desc" }
-                        )
-                    };
-                    let value =
-                        if details.redacted { "<hidden>".into() } else { details.value.clone() };
-                    let sort_details = serde_json::json!({
-                        "order": order,
-                        "value": value,
-                    });
-                    details_map.insert(sort, sort_details);
-                    order += 1;
-                }
-                ScoreDetails::GeoSort(details) => {
-                    let sort = format!(
-                        "_geoPoint({}, {}):{}",
-                        details.target_point[0],
-                        details.target_point[1],
-                        if details.ascending { "asc" } else { "desc" }
-                    );
-                    let point = if let Some(value) = details.value {
-                        serde_json::json!({ "lat": value[0], "lng": value[1]})
-                    } else {
-                        serde_json::Value::Null
-                    };
-                    let sort_details = serde_json::json!({
-                        "order": order,
-                        "value": point,
-                        "distance": details.distance(),
-                    });
-                    details_map.insert(sort, sort_details);
-                    order += 1;
-                }
-            }
-        }
-        details_map
-    }
-}
-
-/// The strategy to compute scores.
-///
-/// It makes sense to pass down this strategy to the internals of the search, because
-/// some optimizations (today, mainly skipping ranking rules for universes of a single document)
-/// are not correct to do when computing the scores.
-///
-/// This strategy could feasibly be extended to differentiate between the normalized score and the
-/// detailed scores, but it is not useful today as the normalized score is *derived from* the
-/// detailed scores.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum ScoringStrategy {
-    /// Don't compute scores
-    #[default]
-    Skip,
-    /// Compute detailed scores
-    Detailed,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Words {
-    pub matching_words: u32,
-    pub max_matching_words: u32,
-}
-
-impl Words {
-    pub fn rank(&self) -> Rank {
-        Rank { rank: self.matching_words, max_rank: self.max_matching_words }
-    }
-
-    pub(crate) fn from_rank(rank: Rank) -> Words {
-        Words { matching_words: rank.rank, max_matching_words: rank.max_rank }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Typo {
-    pub typo_count: u32,
-    pub max_typo_count: u32,
-}
-
-impl Typo {
-    pub fn rank(&self) -> Rank {
-        Rank {
-            rank: self.max_typo_count - self.typo_count + 1,
-            max_rank: (self.max_typo_count + 1),
-        }
-    }
-
-    // max_rank = max_typo + 1
-    // max_typo = max_rank - 1
-    //
-    // rank = max_typo - typo + 1
-    // rank = max_rank - 1 - typo + 1
-    // rank + typo = max_rank
-    // typo = max_rank - rank
-    pub fn from_rank(rank: Rank) -> Typo {
-        Typo { typo_count: rank.max_rank - rank.rank, max_typo_count: rank.max_rank - 1 }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Rank {
-    /// The ordinal rank, such that `max_rank` is the first rank, and 0 is the last rank.
-    ///
-    /// The higher the better. Documents with a rank of 0 have a score of 0 and are typically never returned
-    /// (they don't match the query).
-    pub rank: u32,
-    /// The maximum possible rank. Documents with this rank have a score of 1.
-    ///
-    /// The max rank should not be 0.
-    pub max_rank: u32,
-}
-
-impl Rank {
-    pub fn local_score(self) -> f64 {
-        self.rank as f64 / self.max_rank as f64
-    }
-
-    pub fn global_score(details: impl Iterator<Item = Self>) -> f64 {
-        let mut rank = Rank { rank: 1, max_rank: 1 };
-        for inner_rank in details {
-            rank.rank -= 1;
-
-            rank.rank *= inner_rank.max_rank;
-            rank.max_rank *= inner_rank.max_rank;
-
-            rank.rank += inner_rank.rank;
-        }
-        rank.local_score()
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub enum ExactAttribute {
-    ExactMatch,
-    MatchesStart,
-    NoExactMatch,
-}
-
-impl ExactAttribute {
-    pub fn rank(&self) -> Rank {
-        let rank = match self {
-            ExactAttribute::ExactMatch => 3,
-            ExactAttribute::MatchesStart => 2,
-            ExactAttribute::NoExactMatch => 1,
-        };
-        Rank { rank, max_rank: 3 }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Sort {
-    pub field_name: String,
-    pub ascending: bool,
-    pub redacted: bool,
-    pub value: serde_json::Value,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
-pub struct GeoSort {
-    pub target_point: [f64; 2],
-    pub ascending: bool,
-    pub value: Option<[f64; 2]>,
-}
-
-impl GeoSort {
-    pub fn distance(&self) -> Option<f64> {
-        self.value.map(|value| distance_between_two_points(&self.target_point, &value))
-    }
-}

milli/src/search/mod.rs

@@ -7,7 +7,6 @@ use roaring::bitmap::RoaringBitmap;
 pub use self::facet::{FacetDistribution, Filter, DEFAULT_VALUES_PER_FACET};
 pub use self::new::matches::{FormatOptions, MatchBounds, Matcher, MatcherBuilder, MatchingWords};
 use self::new::PartialSearchResult;
-use crate::score_details::{ScoreDetails, ScoringStrategy};
 use crate::{
     execute_search, AscDesc, DefaultSearchLogger, DocumentId, Index, Result, SearchContext,
 };
@@ -28,9 +27,9 @@ pub struct Search<'a> {
     offset: usize,
     limit: usize,
     sort_criteria: Option<Vec<AscDesc>>,
+    searchable_attributes: Option<&'a [String]>,
     geo_strategy: new::GeoSortStrategy,
     terms_matching_strategy: TermsMatchingStrategy,
-    scoring_strategy: ScoringStrategy,
     words_limit: usize,
     exhaustive_number_hits: bool,
     rtxn: &'a heed::RoTxn<'a>,
@@ -45,9 +44,9 @@ impl<'a> Search<'a> {
             offset: 0,
             limit: 20,
             sort_criteria: None,
+            searchable_attributes: None,
             geo_strategy: new::GeoSortStrategy::default(),
             terms_matching_strategy: TermsMatchingStrategy::default(),
-            scoring_strategy: Default::default(),
             exhaustive_number_hits: false,
             words_limit: 10,
             rtxn,
@@ -75,13 +74,13 @@ impl<'a> Search<'a> {
         self
     }
 
-    pub fn terms_matching_strategy(&mut self, value: TermsMatchingStrategy) -> &mut Search<'a> {
-        self.terms_matching_strategy = value;
+    pub fn searchable_attributes(&mut self, searchable: &'a [String]) -> &mut Search<'a> {
+        self.searchable_attributes = Some(searchable);
         self
     }
 
-    pub fn scoring_strategy(&mut self, value: ScoringStrategy) -> &mut Search<'a> {
-        self.scoring_strategy = value;
+    pub fn terms_matching_strategy(&mut self, value: TermsMatchingStrategy) -> &mut Search<'a> {
+        self.terms_matching_strategy = value;
         self
     }
 
@@ -101,7 +100,7 @@ impl<'a> Search<'a> {
         self
     }
 
-    /// Forces the search to exhaustively compute the number of candidates,
+    /// Force the search to exhastivelly compute the number of candidates,
     /// this will increase the search time but allows finite pagination.
     pub fn exhaustive_number_hits(&mut self, exhaustive_number_hits: bool) -> &mut Search<'a> {
         self.exhaustive_number_hits = exhaustive_number_hits;
@@ -110,12 +109,16 @@ impl<'a> Search<'a> {
 
     pub fn execute(&self) -> Result<SearchResult> {
         let mut ctx = SearchContext::new(self.index, self.rtxn);
-        let PartialSearchResult { located_query_terms, candidates, documents_ids, document_scores } =
+
+        if let Some(searchable_attributes) = self.searchable_attributes {
+            ctx.searchable_attributes(searchable_attributes)?;
+        }
+
+        let PartialSearchResult { located_query_terms, candidates, documents_ids } =
             execute_search(
                 &mut ctx,
                 &self.query,
                 self.terms_matching_strategy,
-                self.scoring_strategy,
                 self.exhaustive_number_hits,
                 &self.filter,
                 &self.sort_criteria,
@@ -133,7 +136,7 @@ impl<'a> Search<'a> {
             None => MatchingWords::default(),
         };
 
-        Ok(SearchResult { matching_words, candidates, document_scores, documents_ids })
+        Ok(SearchResult { matching_words, candidates, documents_ids })
     }
 }
 
@@ -145,9 +148,9 @@ impl fmt::Debug for Search<'_> {
             offset,
             limit,
             sort_criteria,
+            searchable_attributes,
             geo_strategy: _,
             terms_matching_strategy,
-            scoring_strategy,
             words_limit,
             exhaustive_number_hits,
             rtxn: _,
@@ -159,8 +162,8 @@ impl fmt::Debug for Search<'_> {
             .field("offset", offset)
             .field("limit", limit)
             .field("sort_criteria", sort_criteria)
+            .field("searchable_attributes", searchable_attributes)
             .field("terms_matching_strategy", terms_matching_strategy)
-            .field("scoring_strategy", scoring_strategy)
             .field("exhaustive_number_hits", exhaustive_number_hits)
             .field("words_limit", words_limit)
             .finish()
@@ -171,8 +174,8 @@ impl fmt::Debug for Search<'_> {
 pub struct SearchResult {
     pub matching_words: MatchingWords,
     pub candidates: RoaringBitmap,
+    // TODO those documents ids should be associated with their criteria scores.
     pub documents_ids: Vec<DocumentId>,
-    pub document_scores: Vec<Vec<ScoreDetails>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

milli/src/search/new/bucket_sort.rs

@@ -3,18 +3,14 @@ use roaring::RoaringBitmap;
 use super::logger::SearchLogger;
 use super::ranking_rules::{BoxRankingRule, RankingRuleQueryTrait};
 use super::SearchContext;
-use crate::score_details::{ScoreDetails, ScoringStrategy};
 use crate::search::new::distinct::{apply_distinct_rule, distinct_single_docid, DistinctOutput};
 use crate::Result;
 
 pub struct BucketSortOutput {
     pub docids: Vec<u32>,
-    pub scores: Vec<Vec<ScoreDetails>>,
     pub all_candidates: RoaringBitmap,
 }
 
-// TODO: would probably be good to regroup some of these inside of a struct?
-#[allow(clippy::too_many_arguments)]
 pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
     ctx: &mut SearchContext<'ctx>,
     mut ranking_rules: Vec<BoxRankingRule<'ctx, Q>>,
@@ -22,7 +18,6 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
     universe: &RoaringBitmap,
     from: usize,
     length: usize,
-    scoring_strategy: ScoringStrategy,
     logger: &mut dyn SearchLogger<Q>,
 ) -> Result<BucketSortOutput> {
     logger.initial_query(query);
@@ -36,11 +31,7 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
     };
 
     if universe.len() < from as u64 {
-        return Ok(BucketSortOutput {
-            docids: vec![],
-            scores: vec![],
-            all_candidates: universe.clone(),
-        });
+        return Ok(BucketSortOutput { docids: vec![], all_candidates: universe.clone() });
     }
     if ranking_rules.is_empty() {
         if let Some(distinct_fid) = distinct_fid {
@@ -58,32 +49,22 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
             }
             let mut all_candidates = universe - excluded;
             all_candidates.extend(results.iter().copied());
-            return Ok(BucketSortOutput {
-                scores: vec![Default::default(); results.len()],
-                docids: results,
-                all_candidates,
-            });
+            return Ok(BucketSortOutput { docids: results, all_candidates });
         } else {
-            let docids: Vec<u32> = universe.iter().skip(from).take(length).collect();
-            return Ok(BucketSortOutput {
-                scores: vec![Default::default(); docids.len()],
-                docids,
-                all_candidates: universe.clone(),
-            });
+            let docids = universe.iter().skip(from).take(length).collect();
+            return Ok(BucketSortOutput { docids, all_candidates: universe.clone() });
         };
     }
 
     let ranking_rules_len = ranking_rules.len();
 
     logger.start_iteration_ranking_rule(0, ranking_rules[0].as_ref(), query, universe);
-
     ranking_rules[0].start_iteration(ctx, logger, universe, query)?;
 
-    let mut ranking_rule_scores: Vec<ScoreDetails> = vec![];
-
     let mut ranking_rule_universes: Vec<RoaringBitmap> =
         vec![RoaringBitmap::default(); ranking_rules_len];
     ranking_rule_universes[0] = universe.clone();
+
     let mut cur_ranking_rule_index = 0;
 
     /// Finish iterating over the current ranking rule, yielding
@@ -108,16 +89,11 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
             } else {
                 cur_ranking_rule_index -= 1;
             }
-            // FIXME: check off by one
-            if ranking_rule_scores.len() > cur_ranking_rule_index {
-                ranking_rule_scores.pop();
-            }
         };
     }
 
     let mut all_candidates = universe.clone();
     let mut valid_docids = vec![];
-    let mut valid_scores = vec![];
     let mut cur_offset = 0usize;
 
     macro_rules! maybe_add_to_results {
@@ -128,26 +104,21 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
                 length,
                 logger,
                 &mut valid_docids,
-                &mut valid_scores,
                 &mut all_candidates,
                 &mut ranking_rule_universes,
                 &mut ranking_rules,
                 cur_ranking_rule_index,
                 &mut cur_offset,
                 distinct_fid,
-                &ranking_rule_scores,
                 $candidates,
             )?;
         };
     }
 
     while valid_docids.len() < length {
-        // The universe for this bucket is zero, so we don't need to sort
-        // anything, just go back to the parent ranking rule.
-        if ranking_rule_universes[cur_ranking_rule_index].is_empty()
-            || (scoring_strategy == ScoringStrategy::Skip
-                && ranking_rule_universes[cur_ranking_rule_index].len() == 1)
-        {
+        // The universe for this bucket is zero or one element, so we don't need to sort
+        // anything, just extend the results and go back to the parent ranking rule.
+        if ranking_rule_universes[cur_ranking_rule_index].len() <= 1 {
             let bucket = std::mem::take(&mut ranking_rule_universes[cur_ranking_rule_index]);
             maybe_add_to_results!(bucket);
             back!();
@@ -159,8 +130,6 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
             continue;
         };
 
-        ranking_rule_scores.push(next_bucket.score);
-
         logger.next_bucket_ranking_rule(
             cur_ranking_rule_index,
             ranking_rules[cur_ranking_rule_index].as_ref(),
@@ -174,12 +143,10 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
         ranking_rule_universes[cur_ranking_rule_index] -= &next_bucket.candidates;
 
         if cur_ranking_rule_index == ranking_rules_len - 1
-            || (scoring_strategy == ScoringStrategy::Skip && next_bucket.candidates.len() <= 1)
+            || next_bucket.candidates.len() <= 1
             || cur_offset + (next_bucket.candidates.len() as usize) < from
         {
             maybe_add_to_results!(next_bucket.candidates);
-            // FIXME: use index based logic like all the other rules so that you don't have to maintain the pop/push?
-            ranking_rule_scores.pop();
             continue;
         }
 
@@ -199,7 +166,7 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
         )?;
     }
 
-    Ok(BucketSortOutput { docids: valid_docids, scores: valid_scores, all_candidates })
+    Ok(BucketSortOutput { docids: valid_docids, all_candidates })
 }
 
 /// Add the candidates to the results. Take `distinct`, `from`, `length`, and `cur_offset`
@@ -212,18 +179,14 @@ fn maybe_add_to_results<'ctx, Q: RankingRuleQueryTrait>(
     logger: &mut dyn SearchLogger<Q>,
 
     valid_docids: &mut Vec<u32>,
-    valid_scores: &mut Vec<Vec<ScoreDetails>>,
     all_candidates: &mut RoaringBitmap,
 
     ranking_rule_universes: &mut [RoaringBitmap],
     ranking_rules: &mut [BoxRankingRule<'ctx, Q>],
-
     cur_ranking_rule_index: usize,
 
     cur_offset: &mut usize,
-
     distinct_fid: Option<u16>,
-    ranking_rule_scores: &[ScoreDetails],
     candidates: RoaringBitmap,
 ) -> Result<()> {
     // First apply the distinct rule on the candidates, reducing the universes if necessary
@@ -268,17 +231,13 @@ fn maybe_add_to_results<'ctx, Q: RankingRuleQueryTrait>(
             let candidates =
                 candidates.iter().take(length - valid_docids.len()).copied().collect::<Vec<_>>();
             logger.add_to_results(&candidates);
-            valid_docids.extend_from_slice(&candidates);
-            valid_scores
-                .extend(std::iter::repeat(ranking_rule_scores.to_owned()).take(candidates.len()));
+            valid_docids.extend(&candidates);
         }
     } else {
         // if we have passed the offset already, add some of the documents (up to the limit)
         let candidates = candidates.iter().take(length - valid_docids.len()).collect::<Vec<u32>>();
         logger.add_to_results(&candidates);
-        valid_docids.extend_from_slice(&candidates);
-        valid_scores
-            .extend(std::iter::repeat(ranking_rule_scores.to_owned()).take(candidates.len()));
+        valid_docids.extend(&candidates);
     }
 
     *cur_offset += candidates.len() as usize;

milli/src/search/new/db_cache.rs

@@ -4,12 +4,13 @@ use std::hash::Hash;
 
 use fxhash::FxHashMap;
 use heed::types::ByteSlice;
-use heed::{BytesDecode, BytesEncode, Database, RoTxn};
+use heed::{BytesEncode, Database, RoTxn};
 use roaring::RoaringBitmap;
 
 use super::interner::Interned;
 use super::Word;
-use crate::heed_codec::StrBEU16Codec;
+use crate::heed_codec::{BytesDecodeOwned, StrBEU16Codec};
+use crate::update::{merge_cbo_roaring_bitmaps, MergeFn};
 use crate::{
     CboRoaringBitmapCodec, CboRoaringBitmapLenCodec, Result, RoaringBitmapCodec, SearchContext,
 };
@@ -22,50 +23,110 @@ use crate::{
 #[derive(Default)]
 pub struct DatabaseCache<'ctx> {
     pub word_pair_proximity_docids:
-        FxHashMap<(u8, Interned<String>, Interned<String>), Option<&'ctx [u8]>>,
+        FxHashMap<(u8, Interned<String>, Interned<String>), Option<Cow<'ctx, [u8]>>>,
     pub word_prefix_pair_proximity_docids:
-        FxHashMap<(u8, Interned<String>, Interned<String>), Option<&'ctx [u8]>>,
+        FxHashMap<(u8, Interned<String>, Interned<String>), Option<Cow<'ctx, [u8]>>>,
     pub prefix_word_pair_proximity_docids:
-        FxHashMap<(u8, Interned<String>, Interned<String>), Option<&'ctx [u8]>>,
-    pub word_docids: FxHashMap<Interned<String>, Option<&'ctx [u8]>>,
-    pub exact_word_docids: FxHashMap<Interned<String>, Option<&'ctx [u8]>>,
-    pub word_prefix_docids: FxHashMap<Interned<String>, Option<&'ctx [u8]>>,
-    pub exact_word_prefix_docids: FxHashMap<Interned<String>, Option<&'ctx [u8]>>,
+        FxHashMap<(u8, Interned<String>, Interned<String>), Option<Cow<'ctx, [u8]>>>,
+    pub word_docids: FxHashMap<Interned<String>, Option<Cow<'ctx, [u8]>>>,
+    pub exact_word_docids: FxHashMap<Interned<String>, Option<Cow<'ctx, [u8]>>>,
+    pub word_prefix_docids: FxHashMap<Interned<String>, Option<Cow<'ctx, [u8]>>>,
+    pub exact_word_prefix_docids: FxHashMap<Interned<String>, Option<Cow<'ctx, [u8]>>>,
 
     pub words_fst: Option<fst::Set<Cow<'ctx, [u8]>>>,
-    pub word_position_docids: FxHashMap<(Interned<String>, u16), Option<&'ctx [u8]>>,
-    pub word_prefix_position_docids: FxHashMap<(Interned<String>, u16), Option<&'ctx [u8]>>,
+    pub word_position_docids: FxHashMap<(Interned<String>, u16), Option<Cow<'ctx, [u8]>>>,
+    pub word_prefix_position_docids: FxHashMap<(Interned<String>, u16), Option<Cow<'ctx, [u8]>>>,
     pub word_positions: FxHashMap<Interned<String>, Vec<u16>>,
     pub word_prefix_positions: FxHashMap<Interned<String>, Vec<u16>>,
 
-    pub word_fid_docids: FxHashMap<(Interned<String>, u16), Option<&'ctx [u8]>>,
-    pub word_prefix_fid_docids: FxHashMap<(Interned<String>, u16), Option<&'ctx [u8]>>,
+    pub word_fid_docids: FxHashMap<(Interned<String>, u16), Option<Cow<'ctx, [u8]>>>,
+    pub word_prefix_fid_docids: FxHashMap<(Interned<String>, u16), Option<Cow<'ctx, [u8]>>>,
     pub word_fids: FxHashMap<Interned<String>, Vec<u16>>,
     pub word_prefix_fids: FxHashMap<Interned<String>, Vec<u16>>,
 }
 impl<'ctx> DatabaseCache<'ctx> {
-    fn get_value<'v, K1, KC>(
+    fn get_value<'v, K1, KC, DC>(
         txn: &'ctx RoTxn,
         cache_key: K1,
         db_key: &'v KC::EItem,
-        cache: &mut FxHashMap<K1, Option<&'ctx [u8]>>,
+        cache: &mut FxHashMap<K1, Option<Cow<'ctx, [u8]>>>,
         db: Database<KC, ByteSlice>,
-    ) -> Result<Option<&'ctx [u8]>>
+    ) -> Result<Option<DC::DItem>>
     where
         K1: Copy + Eq + Hash,
         KC: BytesEncode<'v>,
+        DC: BytesDecodeOwned,
     {
-        let bitmap_ptr = match cache.entry(cache_key) {
-            Entry::Occupied(bitmap_ptr) => *bitmap_ptr.get(),
+        match cache.entry(cache_key) {
+            Entry::Occupied(_) => {}
             Entry::Vacant(entry) => {
-                let bitmap_ptr = db.get(txn, db_key)?;
+                let bitmap_ptr = db.get(txn, db_key)?.map(Cow::Borrowed);
+                entry.insert(bitmap_ptr);
+            }
+        }
+
+        match cache.get(&cache_key).unwrap() {
+            Some(Cow::Borrowed(bytes)) => {
+                DC::bytes_decode_owned(bytes).ok_or(heed::Error::Decoding.into()).map(Some)
+            }
+            Some(Cow::Owned(bytes)) => {
+                DC::bytes_decode_owned(bytes).ok_or(heed::Error::Decoding.into()).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn get_value_from_keys<'v, K1, KC, DC>(
+        txn: &'ctx RoTxn,
+        cache_key: K1,
+        db_keys: &'v [KC::EItem],
+        cache: &mut FxHashMap<K1, Option<Cow<'ctx, [u8]>>>,
+        db: Database<KC, ByteSlice>,
+        merger: MergeFn,
+    ) -> Result<Option<DC::DItem>>
+    where
+        K1: Copy + Eq + Hash,
+        KC: BytesEncode<'v>,
+        DC: BytesDecodeOwned,
+        KC::EItem: Sized,
+    {
+        match cache.entry(cache_key) {
+            Entry::Occupied(_) => {}
+            Entry::Vacant(entry) => {
+                let bitmap_ptr: Option<Cow<'ctx, [u8]>> = match db_keys {
+                    [] => None,
+                    [key] => db.get(txn, key)?.map(Cow::Borrowed),
+                    keys => {
+                        let bitmaps = keys
+                            .iter()
+                            .filter_map(|key| db.get(txn, key).transpose())
+                            .map(|v| v.map(Cow::Borrowed))
+                            .collect::<std::result::Result<Vec<Cow<[u8]>>, _>>()?;
+
+                        if bitmaps.is_empty() {
+                            None
+                        } else {
+                            Some(merger(&[], &bitmaps[..])?)
+                        }
+                    }
+                };
+
                 entry.insert(bitmap_ptr);
-                bitmap_ptr
             }
         };
-        Ok(bitmap_ptr)
+
+        match cache.get(&cache_key).unwrap() {
+            Some(Cow::Borrowed(bytes)) => {
+                DC::bytes_decode_owned(bytes).ok_or(heed::Error::Decoding.into()).map(Some)
+            }
+            Some(Cow::Owned(bytes)) => {
+                DC::bytes_decode_owned(bytes).ok_or(heed::Error::Decoding.into()).map(Some)
+            }
+            None => Ok(None),
+        }
     }
 }
+
 impl<'ctx> SearchContext<'ctx> {
     pub fn get_words_fst(&mut self) -> Result<fst::Set<Cow<'ctx, [u8]>>> {
         if let Some(fst) = self.db_cache.words_fst.clone() {
@@ -99,30 +160,41 @@ impl<'ctx> SearchContext<'ctx> {
 
     /// Retrieve or insert the given value in the `word_docids` database.
     fn get_db_word_docids(&mut self, word: Interned<String>) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
-            self.txn,
-            word,
-            self.word_interner.get(word).as_str(),
-            &mut self.db_cache.word_docids,
-            self.index.word_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| RoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        match &self.restricted_fids {
+            Some(restricted_fids) => {
+                let interned = self.word_interner.get(word).as_str();
+                let keys: Vec<_> = restricted_fids.iter().map(|fid| (interned, *fid)).collect();
+
+                DatabaseCache::get_value_from_keys::<_, _, CboRoaringBitmapCodec>(
+                    self.txn,
+                    word,
+                    &keys[..],
+                    &mut self.db_cache.word_docids,
+                    self.index.word_fid_docids.remap_data_type::<ByteSlice>(),
+                    merge_cbo_roaring_bitmaps,
+                )
+            }
+            None => DatabaseCache::get_value::<_, _, RoaringBitmapCodec>(
+                self.txn,
+                word,
+                self.word_interner.get(word).as_str(),
+                &mut self.db_cache.word_docids,
+                self.index.word_docids.remap_data_type::<ByteSlice>(),
+            ),
+        }
     }
 
     fn get_db_exact_word_docids(
         &mut self,
         word: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, RoaringBitmapCodec>(
             self.txn,
             word,
             self.word_interner.get(word).as_str(),
             &mut self.db_cache.exact_word_docids,
             self.index.exact_word_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| RoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn word_prefix_docids(&mut self, prefix: Word) -> Result<Option<RoaringBitmap>> {
@@ -150,30 +222,41 @@ impl<'ctx> SearchContext<'ctx> {
         &mut self,
         prefix: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
-            self.txn,
-            prefix,
-            self.word_interner.get(prefix).as_str(),
-            &mut self.db_cache.word_prefix_docids,
-            self.index.word_prefix_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| RoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        match &self.restricted_fids {
+            Some(restricted_fids) => {
+                let interned = self.word_interner.get(prefix).as_str();
+                let keys: Vec<_> = restricted_fids.iter().map(|fid| (interned, *fid)).collect();
+
+                DatabaseCache::get_value_from_keys::<_, _, CboRoaringBitmapCodec>(
+                    self.txn,
+                    prefix,
+                    &keys[..],
+                    &mut self.db_cache.word_prefix_docids,
+                    self.index.word_prefix_fid_docids.remap_data_type::<ByteSlice>(),
+                    merge_cbo_roaring_bitmaps,
+                )
+            }
+            None => DatabaseCache::get_value::<_, _, RoaringBitmapCodec>(
+                self.txn,
+                prefix,
+                self.word_interner.get(prefix).as_str(),
+                &mut self.db_cache.word_prefix_docids,
+                self.index.word_prefix_docids.remap_data_type::<ByteSlice>(),
+            ),
+        }
     }
 
     fn get_db_exact_word_prefix_docids(
         &mut self,
         prefix: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, RoaringBitmapCodec>(
             self.txn,
             prefix,
             self.word_interner.get(prefix).as_str(),
             &mut self.db_cache.exact_word_prefix_docids,
             self.index.exact_word_prefix_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| RoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_pair_proximity_docids(
@@ -182,7 +265,7 @@ impl<'ctx> SearchContext<'ctx> {
         word2: Interned<String>,
         proximity: u8,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (proximity, word1, word2),
             &(
@@ -192,9 +275,7 @@ impl<'ctx> SearchContext<'ctx> {
             ),
             &mut self.db_cache.word_pair_proximity_docids,
             self.index.word_pair_proximity_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_pair_proximity_docids_len(
@@ -203,7 +284,7 @@ impl<'ctx> SearchContext<'ctx> {
         word2: Interned<String>,
         proximity: u8,
     ) -> Result<Option<u64>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapLenCodec>(
             self.txn,
             (proximity, word1, word2),
             &(
@@ -213,11 +294,7 @@ impl<'ctx> SearchContext<'ctx> {
             ),
             &mut self.db_cache.word_pair_proximity_docids,
             self.index.word_pair_proximity_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| {
-            CboRoaringBitmapLenCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into())
-        })
-        .transpose()
+        )
     }
 
     pub fn get_db_word_prefix_pair_proximity_docids(
@@ -226,7 +303,7 @@ impl<'ctx> SearchContext<'ctx> {
         prefix2: Interned<String>,
         proximity: u8,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (proximity, word1, prefix2),
             &(
@@ -236,9 +313,7 @@ impl<'ctx> SearchContext<'ctx> {
             ),
             &mut self.db_cache.word_prefix_pair_proximity_docids,
             self.index.word_prefix_pair_proximity_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
     pub fn get_db_prefix_word_pair_proximity_docids(
         &mut self,
@@ -246,7 +321,7 @@ impl<'ctx> SearchContext<'ctx> {
         right: Interned<String>,
         proximity: u8,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (proximity, left_prefix, right),
             &(
@@ -256,9 +331,7 @@ impl<'ctx> SearchContext<'ctx> {
             ),
             &mut self.db_cache.prefix_word_pair_proximity_docids,
             self.index.prefix_word_pair_proximity_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_fid_docids(
@@ -266,15 +339,18 @@ impl<'ctx> SearchContext<'ctx> {
         word: Interned<String>,
         fid: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        // if the requested fid isn't in the restricted list, return None.
+        if self.restricted_fids.as_ref().map_or(false, |fids| !fids.contains(&fid)) {
+            return Ok(None);
+        }
+
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (word, fid),
             &(self.word_interner.get(word).as_str(), fid),
             &mut self.db_cache.word_fid_docids,
             self.index.word_fid_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_prefix_fid_docids(
@@ -282,15 +358,18 @@ impl<'ctx> SearchContext<'ctx> {
         word_prefix: Interned<String>,
         fid: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        // if the requested fid isn't in the restricted list, return None.
+        if self.restricted_fids.as_ref().map_or(false, |fids| !fids.contains(&fid)) {
+            return Ok(None);
+        }
+
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (word_prefix, fid),
             &(self.word_interner.get(word_prefix).as_str(), fid),
             &mut self.db_cache.word_prefix_fid_docids,
             self.index.word_prefix_fid_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_fids(&mut self, word: Interned<String>) -> Result<Vec<u16>> {
@@ -309,7 +388,7 @@ impl<'ctx> SearchContext<'ctx> {
                 for result in remap_key_type {
                     let ((_, fid), value) = result?;
                     // filling other caches to avoid searching for them again
-                    self.db_cache.word_fid_docids.insert((word, fid), Some(value));
+                    self.db_cache.word_fid_docids.insert((word, fid), Some(Cow::Borrowed(value)));
                     fids.push(fid);
                 }
                 entry.insert(fids.clone());
@@ -335,7 +414,9 @@ impl<'ctx> SearchContext<'ctx> {
                 for result in remap_key_type {
                     let ((_, fid), value) = result?;
                     // filling other caches to avoid searching for them again
-                    self.db_cache.word_prefix_fid_docids.insert((word_prefix, fid), Some(value));
+                    self.db_cache
+                        .word_prefix_fid_docids
+                        .insert((word_prefix, fid), Some(Cow::Borrowed(value)));
                     fids.push(fid);
                 }
                 entry.insert(fids.clone());
@@ -350,15 +431,13 @@ impl<'ctx> SearchContext<'ctx> {
         word: Interned<String>,
         position: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (word, position),
             &(self.word_interner.get(word).as_str(), position),
             &mut self.db_cache.word_position_docids,
             self.index.word_position_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_prefix_position_docids(
@@ -366,15 +445,13 @@ impl<'ctx> SearchContext<'ctx> {
         word_prefix: Interned<String>,
         position: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value(
+        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
             self.txn,
             (word_prefix, position),
             &(self.word_interner.get(word_prefix).as_str(), position),
             &mut self.db_cache.word_prefix_position_docids,
             self.index.word_prefix_position_docids.remap_data_type::<ByteSlice>(),
-        )?
-        .map(|bytes| CboRoaringBitmapCodec::bytes_decode(bytes).ok_or(heed::Error::Decoding.into()))
-        .transpose()
+        )
     }
 
     pub fn get_db_word_positions(&mut self, word: Interned<String>) -> Result<Vec<u16>> {
@@ -393,7 +470,9 @@ impl<'ctx> SearchContext<'ctx> {
                 for result in remap_key_type {
                     let ((_, position), value) = result?;
                     // filling other caches to avoid searching for them again
-                    self.db_cache.word_position_docids.insert((word, position), Some(value));
+                    self.db_cache
+                        .word_position_docids
+                        .insert((word, position), Some(Cow::Borrowed(value)));
                     positions.push(position);
                 }
                 entry.insert(positions.clone());
@@ -424,7 +503,7 @@ impl<'ctx> SearchContext<'ctx> {
                     // filling other caches to avoid searching for them again
                     self.db_cache
                         .word_prefix_position_docids
-                        .insert((word_prefix, position), Some(value));
+                        .insert((word_prefix, position), Some(Cow::Borrowed(value)));
                     positions.push(position);
                 }
                 entry.insert(positions.clone());

milli/src/search/new/exact_attribute.rs

@@ -2,7 +2,6 @@ use roaring::{MultiOps, RoaringBitmap};
 
 use super::query_graph::QueryGraph;
 use super::ranking_rules::{RankingRule, RankingRuleOutput};
-use crate::score_details::{self, ScoreDetails};
 use crate::search::new::query_graph::QueryNodeData;
 use crate::search::new::query_term::ExactTerm;
 use crate::{Result, SearchContext, SearchLogger};
@@ -245,13 +244,7 @@ impl State {
                 candidates &= universe;
                 (
                     State::AttributeStarts(query_graph.clone(), candidates_per_attribute),
-                    Some(RankingRuleOutput {
-                        query: query_graph,
-                        candidates,
-                        score: ScoreDetails::ExactAttribute(
-                            score_details::ExactAttribute::ExactMatch,
-                        ),
-                    }),
+                    Some(RankingRuleOutput { query: query_graph, candidates }),
                 )
             }
             State::AttributeStarts(query_graph, candidates_per_attribute) => {
@@ -264,24 +257,12 @@ impl State {
                 candidates &= universe;
                 (
                     State::Empty(query_graph.clone()),
-                    Some(RankingRuleOutput {
-                        query: query_graph,
-                        candidates,
-                        score: ScoreDetails::ExactAttribute(
-                            score_details::ExactAttribute::MatchesStart,
-                        ),
-                    }),
+                    Some(RankingRuleOutput { query: query_graph, candidates }),
                 )
             }
             State::Empty(query_graph) => (
                 State::Empty(query_graph.clone()),
-                Some(RankingRuleOutput {
-                    query: query_graph,
-                    candidates: universe.clone(),
-                    score: ScoreDetails::ExactAttribute(
-                        score_details::ExactAttribute::NoExactMatch,
-                    ),
-                }),
+                Some(RankingRuleOutput { query: query_graph, candidates: universe.clone() }),
             ),
         };
         (state, output)

milli/src/search/new/geo_sort.rs

@@ -8,7 +8,6 @@ use rstar::RTree;
 
 use super::ranking_rules::{RankingRule, RankingRuleOutput, RankingRuleQueryTrait};
 use crate::heed_codec::facet::{FieldDocIdFacetCodec, OrderedF64Codec};
-use crate::score_details::{self, ScoreDetails};
 use crate::{
     distance_between_two_points, lat_lng_to_xyz, GeoPoint, Index, Result, SearchContext,
     SearchLogger,
@@ -81,7 +80,7 @@ pub struct GeoSort<Q: RankingRuleQueryTrait> {
     field_ids: Option<[u16; 2]>,
     rtree: Option<RTree<GeoPoint>>,
 
-    cached_sorted_docids: VecDeque<(u32, [f64; 2])>,
+    cached_sorted_docids: VecDeque<u32>,
     geo_candidates: RoaringBitmap,
 }
 
@@ -131,7 +130,7 @@ impl<Q: RankingRuleQueryTrait> GeoSort<Q> {
                 let point = lat_lng_to_xyz(&self.point);
                 for point in rtree.nearest_neighbor_iter(&point) {
                     if self.geo_candidates.contains(point.data.0) {
-                        self.cached_sorted_docids.push_back(point.data);
+                        self.cached_sorted_docids.push_back(point.data.0);
                         if self.cached_sorted_docids.len() >= cache_size {
                             break;
                         }
@@ -143,7 +142,7 @@ impl<Q: RankingRuleQueryTrait> GeoSort<Q> {
                 let point = lat_lng_to_xyz(&opposite_of(self.point));
                 for point in rtree.nearest_neighbor_iter(&point) {
                     if self.geo_candidates.contains(point.data.0) {
-                        self.cached_sorted_docids.push_front(point.data);
+                        self.cached_sorted_docids.push_front(point.data.0);
                         if self.cached_sorted_docids.len() >= cache_size {
                             break;
                         }
@@ -178,7 +177,7 @@ impl<Q: RankingRuleQueryTrait> GeoSort<Q> {
             // computing the distance between two points is expensive thus we cache the result
             documents
                 .sort_by_cached_key(|(_, p)| distance_between_two_points(&self.point, p) as usize);
-            self.cached_sorted_docids.extend(documents.into_iter());
+            self.cached_sorted_docids.extend(documents.into_iter().map(|(doc_id, _)| doc_id));
         };
 
         Ok(())
@@ -221,19 +220,12 @@ impl<'ctx, Q: RankingRuleQueryTrait> RankingRule<'ctx, Q> for GeoSort<Q> {
         logger: &mut dyn SearchLogger<Q>,
         universe: &RoaringBitmap,
     ) -> Result<Option<RankingRuleOutput<Q>>> {
+        assert!(universe.len() > 1);
         let query = self.query.as_ref().unwrap().clone();
         self.geo_candidates &= universe;
 
         if self.geo_candidates.is_empty() {
-            return Ok(Some(RankingRuleOutput {
-                query,
-                candidates: universe.clone(),
-                score: ScoreDetails::GeoSort(score_details::GeoSort {
-                    target_point: self.point,
-                    ascending: self.ascending,
-                    value: None,
-                }),
-            }));
+            return Ok(Some(RankingRuleOutput { query, candidates: universe.clone() }));
         }
 
         let ascending = self.ascending;
@@ -244,16 +236,11 @@ impl<'ctx, Q: RankingRuleQueryTrait> RankingRule<'ctx, Q> for GeoSort<Q> {
                 cache.pop_back()
             }
         };
-        while let Some((id, point)) = next(&mut self.cached_sorted_docids) {
+        while let Some(id) = next(&mut self.cached_sorted_docids) {
             if self.geo_candidates.contains(id) {
                 return Ok(Some(RankingRuleOutput {
                     query,
                     candidates: RoaringBitmap::from_iter([id]),
-                    score: ScoreDetails::GeoSort(score_details::GeoSort {
-                        target_point: self.point,
-                        ascending: self.ascending,
-                        value: Some(point),
-                    }),
                 }));
             }
         }

milli/src/search/new/graph_based_ranking_rule.rs

@@ -50,7 +50,6 @@ use super::ranking_rule_graph::{
 };
 use super::small_bitmap::SmallBitmap;
 use super::{QueryGraph, RankingRule, RankingRuleOutput, SearchContext};
-use crate::score_details::Rank;
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::ranking_rule_graph::PathVisitor;
 use crate::{Result, TermsMatchingStrategy};
@@ -119,8 +118,6 @@ pub struct GraphBasedRankingRuleState<G: RankingRuleGraphTrait> {
     all_costs: MappedInterner<QueryNode, Vec<u64>>,
     /// An index in the first element of `all_distances`, giving the cost of the next bucket
     cur_cost: u64,
-    /// One above the highest possible cost for this rule
-    next_max_cost: u64,
 }
 
 impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBasedRankingRule<G> {
@@ -134,20 +131,7 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
         _universe: &RoaringBitmap,
         query_graph: &QueryGraph,
     ) -> Result<()> {
-        // the `next_max_cost` is the successor integer to the maximum cost of the paths in the graph.
-        //
-        // When there is a matching strategy, it also factors the additional costs of:
-        // 1. The words that are matched in phrases
-        // 2. Skipping words (by adding them to the paths with a cost)
-        let mut next_max_cost = 1;
         let removal_cost = if let Some(terms_matching_strategy) = self.terms_matching_strategy {
-            // add the cost of the phrase to the next_max_cost
-            next_max_cost += query_graph
-                .words_in_phrases_count(ctx)
-                // remove 1 from the words in phrases count, because when there is a phrase we can now have a document
-                // where only the phrase is matching, and none of the non-phrase words.
-                // With the `1` that `next_max_cost` is initialized with, this gets counted twice.
-                .saturating_sub(1) as u64;
             match terms_matching_strategy {
                 TermsMatchingStrategy::Last => {
                     let removal_order =
@@ -155,12 +139,13 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
                     let mut forbidden_nodes =
                         SmallBitmap::for_interned_values_in(&query_graph.nodes);
                     let mut costs = query_graph.nodes.map(|_| None);
-                    // FIXME: this works because only words uses termsmatchingstrategy at the moment.
+                    let mut cost = 100;
                     for ns in removal_order {
                         for n in ns.iter() {
-                            *costs.get_mut(n) = Some((1, forbidden_nodes.clone()));
+                            *costs.get_mut(n) = Some((cost, forbidden_nodes.clone()));
                         }
                         forbidden_nodes.union(&ns);
+                        cost += 100;
                     }
                     costs
                 }
@@ -177,16 +162,12 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
         // Then pre-compute the cost of all paths from each node to the end node
         let all_costs = graph.find_all_costs_to_end();
 
-        next_max_cost +=
-            all_costs.get(graph.query_graph.root_node).iter().copied().max().unwrap_or(0);
-
         let state = GraphBasedRankingRuleState {
             graph,
             conditions_cache: condition_docids_cache,
             dead_ends_cache,
             all_costs,
             cur_cost: 0,
-            next_max_cost,
         };
 
         self.state = Some(state);
@@ -200,13 +181,17 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
         logger: &mut dyn SearchLogger<QueryGraph>,
         universe: &RoaringBitmap,
     ) -> Result<Option<RankingRuleOutput<QueryGraph>>> {
+        // If universe.len() <= 1, the bucket sort algorithm
+        // should not have called this function.
+        assert!(universe.len() > 1);
         // Will crash if `next_bucket` is called before `start_iteration` or after `end_iteration`,
         // should never happen
         let mut state = self.state.take().unwrap();
 
-        let all_costs = state.all_costs.get(state.graph.query_graph.root_node);
         // Retrieve the cost of the paths to compute
-        let Some(&cost) = all_costs
+        let Some(&cost) = state
+            .all_costs
+            .get(state.graph.query_graph.root_node)
             .iter()
             .find(|c| **c >= state.cur_cost) else {
                 self.state = None;
@@ -222,12 +207,8 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
             dead_ends_cache,
             all_costs,
             cur_cost: _,
-            next_max_cost,
         } = &mut state;
 
-        let rank = *next_max_cost - cost;
-        let score = G::rank_to_score(Rank { rank: rank as u32, max_rank: *next_max_cost as u32 });
-
         let mut universe = universe.clone();
 
         let mut used_conditions = SmallBitmap::for_interned_values_in(&graph.conditions_interner);
@@ -314,6 +295,8 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
 
         // We modify the next query graph so that it only contains the subgraph
         // that was used to compute this bucket
+        // But we only do it in case the bucket length is >1, because otherwise
+        // we know the child ranking rule won't be called anyway
 
         let paths: Vec<Vec<(Option<LocatedQueryTermSubset>, LocatedQueryTermSubset)>> = good_paths
             .into_iter()
@@ -342,7 +325,7 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
 
         self.state = Some(state);
 
-        Ok(Some(RankingRuleOutput { query: next_query_graph, candidates: bucket, score }))
+        Ok(Some(RankingRuleOutput { query: next_query_graph, candidates: bucket }))
     }
 
     fn end_iteration(

milli/src/search/new/matches/mod.rs

@@ -510,7 +510,6 @@ mod tests {
                 &mut ctx,
                 &Some(query.to_string()),
                 crate::TermsMatchingStrategy::default(),
-                crate::score_details::ScoringStrategy::Skip,
                 false,
                 &None,
                 &None,

milli/src/search/new/mod.rs

@@ -20,7 +20,7 @@ mod sort;
 #[cfg(test)]
 mod tests;
 
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
 
 use bucket_sort::{bucket_sort, BucketSortOutput};
 use charabia::TokenizerBuilder;
@@ -44,7 +44,7 @@ use self::geo_sort::GeoSort;
 pub use self::geo_sort::Strategy as GeoSortStrategy;
 use self::graph_based_ranking_rule::Words;
 use self::interner::Interned;
-use crate::score_details::{ScoreDetails, ScoringStrategy};
+use crate::error::FieldIdMapMissingEntry;
 use crate::search::new::distinct::apply_distinct_rule;
 use crate::{AscDesc, DocumentId, Filter, Index, Member, Result, TermsMatchingStrategy, UserError};
 
@@ -57,6 +57,7 @@ pub struct SearchContext<'ctx> {
     pub phrase_interner: DedupInterner<Phrase>,
     pub term_interner: Interner<QueryTerm>,
     pub phrase_docids: PhraseDocIdsCache,
+    pub restricted_fids: Option<Vec<u16>>,
 }
 
 impl<'ctx> SearchContext<'ctx> {
@@ -69,8 +70,66 @@ impl<'ctx> SearchContext<'ctx> {
             phrase_interner: <_>::default(),
             term_interner: <_>::default(),
             phrase_docids: <_>::default(),
+            restricted_fids: None,
         }
     }
+
+    pub fn searchable_attributes(&mut self, searchable_attributes: &'ctx [String]) -> Result<()> {
+        let fids_map = self.index.fields_ids_map(self.txn)?;
+        let searchable_names = self.index.searchable_fields(self.txn)?;
+
+        let mut restricted_fids = Vec::new();
+        for field_name in searchable_attributes {
+            let searchable_contains_name =
+                searchable_names.as_ref().map(|sn| sn.iter().any(|name| name == field_name));
+            let fid = match (fids_map.id(field_name), searchable_contains_name) {
+                // The Field id exist and the field is searchable
+                (Some(fid), Some(true)) | (Some(fid), None) => fid,
+                // The field is searchable but the Field id doesn't exist => Internal Error
+                (None, Some(true)) => {
+                    return Err(FieldIdMapMissingEntry::FieldName {
+                        field_name: field_name.to_string(),
+                        process: "search",
+                    }
+                    .into())
+                }
+                // The field is not searchable => User error
+                _otherwise => {
+                    let mut valid_fields: BTreeSet<_> =
+                        fids_map.names().map(String::from).collect();
+
+                    // Filter by the searchable names
+                    if let Some(sn) = searchable_names {
+                        let searchable_names = sn.iter().map(|s| s.to_string()).collect();
+                        valid_fields = &valid_fields & &searchable_names;
+                    }
+
+                    let searchable_count = valid_fields.len();
+
+                    // Remove hidden fields
+                    if let Some(dn) = self.index.displayed_fields(self.txn)? {
+                        let displayable_names = dn.iter().map(|s| s.to_string()).collect();
+                        valid_fields = &valid_fields & &displayable_names;
+                    }
+
+                    let hidden_fields = searchable_count > valid_fields.len();
+                    let field = field_name.to_string();
+                    return Err(UserError::InvalidSearchableAttribute {
+                        field,
+                        valid_fields,
+                        hidden_fields,
+                    }
+                    .into());
+                }
+            };
+
+            restricted_fids.push(fid);
+        }
+
+        self.restricted_fids = Some(restricted_fids);
+
+        Ok(())
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, Ord, Eq)]
@@ -351,7 +410,6 @@ pub fn execute_search(
     ctx: &mut SearchContext,
     query: &Option<String>,
     terms_matching_strategy: TermsMatchingStrategy,
-    scoring_strategy: ScoringStrategy,
     exhaustive_number_hits: bool,
     filters: &Option<Filter>,
     sort_criteria: &Option<Vec<AscDesc>>,
@@ -413,16 +471,7 @@ pub fn execute_search(
         universe =
             resolve_universe(ctx, &universe, &graph, terms_matching_strategy, query_graph_logger)?;
 
-        bucket_sort(
-            ctx,
-            ranking_rules,
-            &graph,
-            &universe,
-            from,
-            length,
-            scoring_strategy,
-            query_graph_logger,
-        )?
+        bucket_sort(ctx, ranking_rules, &graph, &universe, from, length, query_graph_logger)?
     } else {
         let ranking_rules =
             get_ranking_rules_for_placeholder_search(ctx, sort_criteria, geo_strategy)?;
@@ -433,20 +482,17 @@ pub fn execute_search(
             &universe,
             from,
             length,
-            scoring_strategy,
             placeholder_search_logger,
         )?
     };
 
-    let BucketSortOutput { docids, scores, mut all_candidates } = bucket_sort_output;
-
-    let fields_ids_map = ctx.index.fields_ids_map(ctx.txn)?;
+    let BucketSortOutput { docids, mut all_candidates } = bucket_sort_output;
 
     // The candidates is the universe unless the exhaustive number of hits
     // is requested and a distinct attribute is set.
     if exhaustive_number_hits {
         if let Some(f) = ctx.index.distinct_field(ctx.txn)? {
-            if let Some(distinct_fid) = fields_ids_map.id(f) {
+            if let Some(distinct_fid) = ctx.index.fields_ids_map(ctx.txn)?.id(f) {
                 all_candidates = apply_distinct_rule(ctx, distinct_fid, &all_candidates)?.remaining;
             }
         }
@@ -454,7 +500,6 @@ pub fn execute_search(
 
     Ok(PartialSearchResult {
         candidates: all_candidates,
-        document_scores: scores,
         documents_ids: docids,
         located_query_terms,
     })
@@ -506,5 +551,4 @@ pub struct PartialSearchResult {
     pub located_query_terms: Option<Vec<LocatedQueryTerm>>,
     pub candidates: RoaringBitmap,
     pub documents_ids: Vec<DocumentId>,
-    pub document_scores: Vec<Vec<ScoreDetails>>,
 }

milli/src/search/new/query_graph.rs

@@ -342,25 +342,6 @@ impl QueryGraph {
         }
         res
     }
-
-    /// Number of words in the phrases in this query graph
-    pub(crate) fn words_in_phrases_count(&self, ctx: &SearchContext) -> usize {
-        let mut word_count = 0;
-        for (_, node) in self.nodes.iter() {
-            match &node.data {
-                QueryNodeData::Term(term) => {
-                    let Some(phrase) = term.term_subset.original_phrase(ctx)
-                    else {
-                        continue
-                    };
-                    let phrase = ctx.phrase_interner.get(phrase);
-                    word_count += phrase.words.iter().copied().filter(|a| a.is_some()).count()
-                }
-                _ => continue,
-            }
-        }
-        word_count
-    }
 }
 
 fn add_node(nodes_data: &mut Vec<QueryNodeData>, node_data: QueryNodeData) -> u16 {

milli/src/search/new/ranking_rule_graph/build.rs

@@ -49,15 +49,10 @@ impl<G: RankingRuleGraphTrait> RankingRuleGraph<G> {
                 if let Some((cost_of_ignoring, forbidden_nodes)) =
                     cost_of_ignoring_node.get(dest_idx)
                 {
-                    let dest = graph_nodes.get(dest_idx);
-                    let dest_size = match &dest.data {
-                        QueryNodeData::Term(term) => term.term_ids.len(),
-                        _ => panic!(),
-                    };
                     let new_edge_id = edges_store.insert(Some(Edge {
                         source_node: source_id,
                         dest_node: dest_idx,
-                        cost: *cost_of_ignoring * dest_size as u32,
+                        cost: *cost_of_ignoring,
                         condition: None,
                         nodes_to_skip: forbidden_nodes.clone(),
                     }));

milli/src/search/new/ranking_rule_graph/exactness/mod.rs

@@ -1,7 +1,6 @@
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::{ExactTerm, LocatedQueryTermSubset};
 use crate::search::new::resolve_query_graph::compute_query_term_subset_docids;
@@ -85,8 +84,4 @@ impl RankingRuleGraphTrait for ExactnessGraph {
 
         Ok(vec![(0, exact_condition), (dest_node.term_ids.len() as u32, skip_condition)])
     }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Exactness(rank)
-    }
 }

milli/src/search/new/ranking_rule_graph/fid/mod.rs

@@ -2,7 +2,6 @@ use fxhash::FxHashSet;
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::resolve_query_graph::compute_query_term_subset_docids_within_field_id;
@@ -69,7 +68,7 @@ impl RankingRuleGraphTrait for FidGraph {
         }
 
         let mut edges = vec![];
-        for fid in all_fields.iter().copied() {
+        for fid in all_fields {
             // TODO: We can improve performances and relevancy by storing
             //       the term subsets associated to each field ids fetched.
             edges.push((
@@ -81,35 +80,6 @@ impl RankingRuleGraphTrait for FidGraph {
             ));
         }
 
-        // always lookup the max_fid if we don't already and add an artificial condition for max scoring
-        let max_fid: Option<u16> = {
-            if let Some(max_fid) = ctx
-                .index
-                .searchable_fields_ids(ctx.txn)?
-                .map(|field_ids| field_ids.into_iter().max())
-            {
-                max_fid
-            } else {
-                ctx.index.fields_ids_map(ctx.txn)?.ids().max()
-            }
-        };
-
-        if let Some(max_fid) = max_fid {
-            if !all_fields.contains(&max_fid) {
-                edges.push((
-                    max_fid as u32 * term.term_ids.len() as u32, // TODO improve the fid score i.e. fid^10.
-                    conditions_interner.insert(FidCondition {
-                        term: term.clone(), // TODO remove this ugly clone
-                        fid: max_fid,
-                    }),
-                ));
-            }
-        }
-
         Ok(edges)
     }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Fid(rank)
-    }
 }

milli/src/search/new/ranking_rule_graph/mod.rs

@@ -41,7 +41,6 @@ use super::interner::{DedupInterner, FixedSizeInterner, Interned, MappedInterner
 use super::query_term::LocatedQueryTermSubset;
 use super::small_bitmap::SmallBitmap;
 use super::{QueryGraph, QueryNode, SearchContext};
-use crate::score_details::{Rank, ScoreDetails};
 use crate::Result;
 
 pub struct ComputedCondition {
@@ -111,9 +110,6 @@ pub trait RankingRuleGraphTrait: Sized + 'static {
         source_node: Option<&LocatedQueryTermSubset>,
         dest_node: &LocatedQueryTermSubset,
     ) -> Result<Vec<(u32, Interned<Self::Condition>)>>;
-
-    /// Convert the rank of a path to its corresponding score for the ranking rule
-    fn rank_to_score(rank: Rank) -> ScoreDetails;
 }
 
 /// The graph used by graph-based ranking rules.

milli/src/search/new/ranking_rule_graph/position/mod.rs

@@ -2,7 +2,6 @@ use fxhash::{FxHashMap, FxHashSet};
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::resolve_query_graph::compute_query_term_subset_docids_within_position;
@@ -78,8 +77,6 @@ impl RankingRuleGraphTrait for PositionGraph {
         let mut positions_for_costs = FxHashMap::<u32, Vec<u16>>::default();
 
         for position in all_positions {
-            // FIXME: bucketed position???
-            let distance = position.abs_diff(*term.positions.start());
             let cost = {
                 let mut cost = 0;
                 for i in 0..term.term_ids.len() {
@@ -87,17 +84,15 @@ impl RankingRuleGraphTrait for PositionGraph {
                     // Because if two words are in the same bucketed position (e.g. 32) and consecutive,
                     // then their position cost will be 32+32=64, but an ngram of these two words at the
                     // same position will have a cost of 32+32+1=65
-                    cost += cost_from_distance(distance as u32 + i as u32);
+                    cost += cost_from_position(position as u32 + i as u32);
                 }
                 cost
             };
             positions_for_costs.entry(cost).or_default().push(position);
         }
 
-        let max_cost = term.term_ids.len() as u32 * 10;
-        let max_cost_exists = positions_for_costs.contains_key(&max_cost);
-
         let mut edges = vec![];
+
         for (cost, positions) in positions_for_costs {
             // TODO: We can improve performances and relevancy by storing
             //       the term subsets associated to each position fetched
@@ -110,25 +105,12 @@ impl RankingRuleGraphTrait for PositionGraph {
             ));
         }
 
-        if !max_cost_exists {
-            // artificial empty condition for computing max cost
-            edges.push((
-                max_cost,
-                conditions_interner
-                    .insert(PositionCondition { term: term.clone(), positions: Vec::default() }),
-            ));
-        }
-
         Ok(edges)
     }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Position(rank)
-    }
 }
 
-fn cost_from_distance(distance: u32) -> u32 {
-    match distance {
+fn cost_from_position(sum_positions: u32) -> u32 {
+    match sum_positions {
         0 => 0,
         1 => 1,
         2..=4 => 2,

milli/src/search/new/ranking_rule_graph/proximity/build.rs

@@ -12,11 +12,11 @@ pub fn build_edges(
     left_term: Option<&LocatedQueryTermSubset>,
     right_term: &LocatedQueryTermSubset,
 ) -> Result<Vec<(u32, Interned<ProximityCondition>)>> {
-    let right_ngram_max = right_term.term_ids.len().saturating_sub(1);
+    let right_ngram_length = right_term.term_ids.len();
 
     let Some(left_term) = left_term else {
         return Ok(vec![(
-            right_ngram_max as u32,
+            (right_ngram_length - 1) as u32,
             conditions_interner.insert(ProximityCondition::Term { term: right_term.clone() }),
         )])
     };
@@ -29,25 +29,25 @@ pub fn build_edges(
         // The remaining query graph represents `the sun .. are beautiful`
         // but `sun` and `are` have no proximity condition between them
         return Ok(vec![(
-            right_ngram_max as u32,
+            (right_ngram_length - 1) as u32,
             conditions_interner.insert(ProximityCondition::Term { term: right_term.clone() }),
         )]);
     }
 
     let mut conditions = vec![];
-    for cost in right_ngram_max..(7 + right_ngram_max) {
+    for cost in right_ngram_length..(7 + right_ngram_length) {
         conditions.push((
             cost as u32,
             conditions_interner.insert(ProximityCondition::Uninit {
                 left_term: left_term.clone(),
                 right_term: right_term.clone(),
-                cost: (cost + 1) as u8,
+                cost: cost as u8,
             }),
         ))
     }
 
     conditions.push((
-        (7 + right_ngram_max) as u32,
+        (7 + right_ngram_length) as u32,
         conditions_interner.insert(ProximityCondition::Term { term: right_term.clone() }),
     ));
 

milli/src/search/new/ranking_rule_graph/proximity/mod.rs

@@ -4,7 +4,6 @@ pub mod compute_docids;
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::SearchContext;
@@ -37,8 +36,4 @@ impl RankingRuleGraphTrait for ProximityGraph {
     ) -> Result<Vec<(u32, Interned<Self::Condition>)>> {
         build::build_edges(ctx, conditions_interner, source_term, dest_term)
     }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Proximity(rank)
-    }
 }

milli/src/search/new/ranking_rule_graph/typo/mod.rs

@@ -1,7 +1,6 @@
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{self, Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::resolve_query_graph::compute_query_term_subset_docids;
@@ -76,8 +75,4 @@ impl RankingRuleGraphTrait for TypoGraph {
         }
         Ok(edges)
     }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Typo(score_details::Typo::from_rank(rank))
-    }
 }

milli/src/search/new/ranking_rule_graph/words/mod.rs

@@ -1,7 +1,6 @@
 use roaring::RoaringBitmap;
 
 use super::{ComputedCondition, RankingRuleGraphTrait};
-use crate::score_details::{self, Rank, ScoreDetails};
 use crate::search::new::interner::{DedupInterner, Interned};
 use crate::search::new::query_term::LocatedQueryTermSubset;
 use crate::search::new::resolve_query_graph::compute_query_term_subset_docids;
@@ -42,10 +41,9 @@ impl RankingRuleGraphTrait for WordsGraph {
         _from: Option<&LocatedQueryTermSubset>,
         to_term: &LocatedQueryTermSubset,
     ) -> Result<Vec<(u32, Interned<Self::Condition>)>> {
-        Ok(vec![(0, conditions_interner.insert(WordsCondition { term: to_term.clone() }))])
-    }
-
-    fn rank_to_score(rank: Rank) -> ScoreDetails {
-        ScoreDetails::Words(score_details::Words::from_rank(rank))
+        Ok(vec![(
+            to_term.term_ids.len() as u32,
+            conditions_interner.insert(WordsCondition { term: to_term.clone() }),
+        )])
     }
 }

milli/src/search/new/ranking_rules.rs

@@ -2,7 +2,6 @@ use roaring::RoaringBitmap;
 
 use super::logger::SearchLogger;
 use super::{QueryGraph, SearchContext};
-use crate::score_details::ScoreDetails;
 use crate::Result;
 
 /// An internal trait implemented by only [`PlaceholderQuery`] and [`QueryGraph`]
@@ -67,6 +66,4 @@ pub struct RankingRuleOutput<Q> {
     pub query: Q,
     /// The allowed candidates for the child ranking rule
     pub candidates: RoaringBitmap,
-    /// The score for the candidates of the current bucket
-    pub score: ScoreDetails,
 }

milli/src/search/new/sort.rs

@@ -1,11 +1,9 @@
-use heed::BytesDecode;
 use roaring::RoaringBitmap;
 
 use super::logger::SearchLogger;
 use super::{RankingRule, RankingRuleOutput, RankingRuleQueryTrait, SearchContext};
-use crate::heed_codec::facet::{FacetGroupKeyCodec, OrderedF64Codec};
-use crate::heed_codec::{ByteSliceRefCodec, StrRefCodec};
-use crate::score_details::{self, ScoreDetails};
+use crate::heed_codec::facet::FacetGroupKeyCodec;
+use crate::heed_codec::ByteSliceRefCodec;
 use crate::search::facet::{ascending_facet_sort, descending_facet_sort};
 use crate::{FieldId, Index, Result};
 
@@ -51,7 +49,6 @@ pub struct Sort<'ctx, Query> {
     is_ascending: bool,
     original_query: Option<Query>,
     iter: Option<RankingRuleOutputIterWrapper<'ctx, Query>>,
-    must_redact: bool,
 }
 impl<'ctx, Query> Sort<'ctx, Query> {
     pub fn new(
@@ -62,30 +59,15 @@ impl<'ctx, Query> Sort<'ctx, Query> {
     ) -> Result<Self> {
         let fields_ids_map = index.fields_ids_map(rtxn)?;
         let field_id = fields_ids_map.id(&field_name);
-        let must_redact = Self::must_redact(index, rtxn, &field_name)?;
 
-        Ok(Self {
-            field_name,
-            field_id,
-            is_ascending,
-            original_query: None,
-            iter: None,
-            must_redact,
-        })
-    }
-
-    fn must_redact(index: &Index, rtxn: &'ctx heed::RoTxn, field_name: &str) -> Result<bool> {
-        let Some(displayed_fields) = index.displayed_fields(rtxn)?
-        else { return Ok(false); };
-
-        Ok(!displayed_fields.iter().any(|&field| field == field_name))
+        Ok(Self { field_name, field_id, is_ascending, original_query: None, iter: None })
     }
 }
 
 impl<'ctx, Query: RankingRuleQueryTrait> RankingRule<'ctx, Query> for Sort<'ctx, Query> {
     fn id(&self) -> String {
         let Self { field_name, is_ascending, .. } = self;
-        format!("{field_name}:{}", if *is_ascending { "asc" } else { "desc" })
+        format!("{field_name}:{}", if *is_ascending { "asc" } else { "desc " })
     }
     fn start_iteration(
         &mut self,
@@ -136,45 +118,12 @@ impl<'ctx, Query: RankingRuleQueryTrait> RankingRule<'ctx, Query> for Sort<'ctx,
 
                     (itertools::Either::Right(number_iter), itertools::Either::Right(string_iter))
                 };
-                let number_iter = number_iter.map(|r| -> Result<_> {
-                    let (docids, bytes) = r?;
-                    Ok((
-                        docids,
-                        serde_json::Value::Number(
-                            serde_json::Number::from_f64(
-                                OrderedF64Codec::bytes_decode(bytes).expect("some number"),
-                            )
-                            .expect("too big float"),
-                        ),
-                    ))
-                });
-                let string_iter = string_iter.map(|r| -> Result<_> {
-                    let (docids, bytes) = r?;
-                    Ok((
-                        docids,
-                        serde_json::Value::String(
-                            StrRefCodec::bytes_decode(bytes).expect("some string").to_owned(),
-                        ),
-                    ))
-                });
 
                 let query_graph = parent_query.clone();
-                let ascending = self.is_ascending;
-                let field_name = self.field_name.clone();
-                let must_redact = self.must_redact;
                 RankingRuleOutputIterWrapper::new(Box::new(number_iter.chain(string_iter).map(
                     move |r| {
-                        let (docids, value) = r?;
-                        Ok(RankingRuleOutput {
-                            query: query_graph.clone(),
-                            candidates: docids,
-                            score: ScoreDetails::Sort(score_details::Sort {
-                                field_name: field_name.clone(),
-                                ascending,
-                                redacted: must_redact,
-                                value,
-                            }),
-                        })
+                        let (docids, _) = r?;
+                        Ok(RankingRuleOutput { query: query_graph.clone(), candidates: docids })
                     },
                 )))
             }
@@ -201,16 +150,7 @@ impl<'ctx, Query: RankingRuleQueryTrait> RankingRule<'ctx, Query> for Sort<'ctx,
             Ok(Some(bucket))
         } else {
             let query = self.original_query.as_ref().unwrap().clone();
-            Ok(Some(RankingRuleOutput {
-                query,
-                candidates: universe.clone(),
-                score: ScoreDetails::Sort(score_details::Sort {
-                    field_name: self.field_name.clone(),
-                    ascending: self.is_ascending,
-                    redacted: self.must_redact,
-                    value: serde_json::Value::Null,
-                }),
-            }))
+            Ok(Some(RankingRuleOutput { query, candidates: universe.clone() }))
         }
     }
 

milli/src/search/new/tests/attribute_fid.rs

@@ -122,11 +122,8 @@ fn test_attribute_fid_simple() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 6, 5, 4, 3, 9, 7, 8, 11, 10, 12, 13, 14, 0]");
 }
 
 #[test]
@@ -138,11 +135,6 @@ fn test_attribute_fid_ngrams() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 6, 5, 4, 3, 9, 7, 8, 11, 10, 12, 13, 14, 0]");
 }

milli/src/search/new/tests/attribute_position.rs

@@ -40,68 +40,68 @@ fn create_index() -> TempIndex {
             },
             {
                 "id": 5,
-                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
                 a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
                 the quick brown fox",
             },
             {
                 "id": 6,
-                "text": "quick a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                "text": "quick a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
                 brown",
             },
             {
                 "id": 7,
-                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a  
                 quickbrown",
             },
             {
                 "id": 8,
-                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a  
                 quick brown",
             },
             {
                 "id": 9,
-                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
-                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a
+                "text": "a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a 
+                a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a  
                 quickbrown",
             },
             {
@@ -137,13 +137,8 @@ fn test_attribute_position_simple() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("quick brown");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[10, 11, 12, 13, 2, 3, 4, 1, 0, 6, 8, 7, 9, 5]");
 }
 #[test]
 fn test_attribute_position_repeated() {
@@ -154,13 +149,8 @@ fn test_attribute_position_repeated() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("a a a a a");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[5, 7, 8, 9, 6]");
 }
 
 #[test]
@@ -172,13 +162,8 @@ fn test_attribute_position_different_fields() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("quick brown");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[10, 11, 12, 13, 2, 3, 4, 1, 0, 6, 8, 7, 9, 5]");
 }
 
 #[test]
@@ -190,11 +175,6 @@ fn test_attribute_position_ngrams() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("quick brown");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[10, 11, 12, 13, 2, 3, 4, 1, 0, 6, 8, 7, 9, 5]");
 }

milli/src/search/new/tests/exactness.rs

@@ -474,14 +474,8 @@ fn test_exactness_simple_ordered() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[9, 8, 7, 6, 5, 4, 3, 2, 1]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -507,14 +501,8 @@ fn test_exactness_simple_reversed() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[9, 8, 3, 4, 5, 6, 7]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -531,14 +519,8 @@ fn test_exactness_simple_reversed() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[9, 8, 3, 4, 5, 6, 7]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -562,14 +544,8 @@ fn test_exactness_simple_random() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[8, 7, 4, 6, 3, 5]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -592,14 +568,8 @@ fn test_exactness_attribute_starts_with_simple() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("this balcony");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 1, 0]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -619,14 +589,8 @@ fn test_exactness_attribute_starts_with_phrase() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("\"overlooking the sea\" is a beautiful balcony");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[6, 5, 4, 1]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -640,14 +604,8 @@ fn test_exactness_attribute_starts_with_phrase() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("overlooking the sea is a beautiful balcony");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[6, 5, 4, 3, 1, 7]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
@@ -670,14 +628,8 @@ fn test_exactness_all_candidates_with_typo() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("overlocking the sea is a beautiful balcony");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[4, 5, 6, 1, 7]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     // "overlooking" is returned here because the term matching strategy allows it
     // but it has the worst exactness score (0 exact words)
@@ -707,14 +659,8 @@ fn test_exactness_after_words() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[19, 9, 18, 8, 17, 16, 6, 7, 15, 5, 14, 4, 13, 3, 12, 2, 1, 11]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     insta::assert_debug_snapshot!(texts, @r###"
@@ -756,13 +702,7 @@ fn test_words_after_exactness() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[19, 9, 18, 8, 17, 16, 6, 7, 15, 5, 14, 4, 13, 3, 12, 2, 1, 11]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
@@ -805,14 +745,7 @@ fn test_proximity_after_exactness() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
-
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 1, 0, 4, 5, 8, 7, 3, 6]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
@@ -843,13 +776,7 @@ fn test_proximity_after_exactness() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("the quick brown fox jumps over the lazy dog");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[0, 1, 2]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
@@ -877,13 +804,7 @@ fn test_exactness_followed_by_typo_prefer_no_typo_prefix() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("quick brown fox extra");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 1, 0, 4, 3]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
@@ -913,13 +834,7 @@ fn test_typo_followed_by_exactness() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::Last);
     s.query("extraordinarily quick brown fox");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
-
-    let document_ids_scores: Vec<_> =
-        documents_ids.iter().zip(document_scores.into_iter()).collect();
-    insta::assert_snapshot!(format!("{document_ids_scores:#?}"));
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[1, 0, 4, 3]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 

milli/src/search/new/tests/geo_sort.rs

@@ -7,7 +7,6 @@ use heed::RoTxn;
 use maplit::hashset;
 
 use crate::index::tests::TempIndex;
-use crate::score_details::ScoreDetails;
 use crate::search::new::tests::collect_field_values;
 use crate::{AscDesc, Criterion, GeoSortStrategy, Member, Search, SearchResult};
 
@@ -29,37 +28,30 @@ fn execute_iterative_and_rtree_returns_the_same<'a>(
     rtxn: &RoTxn<'a>,
     index: &TempIndex,
     search: &mut Search<'a>,
-) -> (Vec<usize>, Vec<Vec<ScoreDetails>>) {
+) -> Vec<usize> {
     search.geo_sort_strategy(GeoSortStrategy::AlwaysIterative(2));
-    let SearchResult { documents_ids, document_scores: iterative_scores_bucketed, .. } =
-        search.execute().unwrap();
+    let SearchResult { documents_ids, .. } = search.execute().unwrap();
     let iterative_ids_bucketed = collect_field_values(index, rtxn, "id", &documents_ids);
 
     search.geo_sort_strategy(GeoSortStrategy::AlwaysIterative(1000));
-    let SearchResult { documents_ids, document_scores: iterative_scores, .. } =
-        search.execute().unwrap();
+    let SearchResult { documents_ids, .. } = search.execute().unwrap();
     let iterative_ids = collect_field_values(index, rtxn, "id", &documents_ids);
 
     assert_eq!(iterative_ids_bucketed, iterative_ids, "iterative bucket");
-    assert_eq!(iterative_scores_bucketed, iterative_scores, "iterative bucket score");
 
     search.geo_sort_strategy(GeoSortStrategy::AlwaysRtree(2));
-    let SearchResult { documents_ids, document_scores: rtree_scores_bucketed, .. } =
-        search.execute().unwrap();
+    let SearchResult { documents_ids, .. } = search.execute().unwrap();
     let rtree_ids_bucketed = collect_field_values(index, rtxn, "id", &documents_ids);
 
     search.geo_sort_strategy(GeoSortStrategy::AlwaysRtree(1000));
-    let SearchResult { documents_ids, document_scores: rtree_scores, .. } =
-        search.execute().unwrap();
+    let SearchResult { documents_ids, .. } = search.execute().unwrap();
     let rtree_ids = collect_field_values(index, rtxn, "id", &documents_ids);
 
     assert_eq!(rtree_ids_bucketed, rtree_ids, "rtree bucket");
-    assert_eq!(rtree_scores_bucketed, rtree_scores, "rtree bucket score");
 
     assert_eq!(iterative_ids, rtree_ids, "iterative vs rtree");
-    assert_eq!(iterative_scores, rtree_scores, "iterative vs rtree scores");
 
-    (iterative_ids.into_iter().map(|id| id.parse().unwrap()).collect(), iterative_scores)
+    iterative_ids.into_iter().map(|id| id.parse().unwrap()).collect()
 }
 
 #[test]
@@ -81,17 +73,14 @@ fn test_geo_sort() {
     let rtxn = index.read_txn().unwrap();
 
     let mut s = Search::new(&rtxn, &index);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
 
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 1, 2, 3, 4, 5, 6, 8, 7, 10, 9]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([0., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[5, 4, 3, 2, 1, 0, 6, 8, 7, 10, 9]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 }
 
 #[test]
@@ -112,63 +101,52 @@ fn test_geo_sort_around_the_edge_of_the_flat_earth() {
     let rtxn = index.read_txn().unwrap();
 
     let mut s = Search::new(&rtxn, &index);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
 
     // --- asc
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 1, 2, 3, 4]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     // ensuring the lat doesn't wrap around
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([85., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[1, 0, 3, 4, 2]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([-85., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[2, 0, 3, 4, 1]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     // ensuring the lng does wrap around
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., 175.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[3, 4, 2, 1, 0]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., -175.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[4, 3, 2, 1, 0]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     // --- desc
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([0., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[4, 3, 2, 1, 0]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     // ensuring the lat doesn't wrap around
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([85., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[2, 4, 3, 0, 1]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([-85., 0.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[1, 4, 3, 0, 2]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     // ensuring the lng does wrap around
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([0., 175.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 1, 2, 4, 3]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.sort_criteria(vec![AscDesc::Desc(Member::Geo([0., -175.]))]);
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 1, 2, 3, 4]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 }
 
 #[test]
@@ -188,98 +166,19 @@ fn geo_sort_mixed_with_words() {
     let rtxn = index.read_txn().unwrap();
 
     let mut s = Search::new(&rtxn, &index);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., 0.]))]);
 
     s.query("jean");
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 2, 3]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 
     s.query("bob");
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[2, 4]");
-    insta::assert_snapshot!(format!("{scores:#?}"), @r###"
-    [
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 1,
-                },
-            ),
-            GeoSort(
-                GeoSort {
-                    target_point: [
-                        0.0,
-                        0.0,
-                    ],
-                    ascending: true,
-                    value: Some(
-                        [
-                            -89.0,
-                            0.0,
-                        ],
-                    ),
-                },
-            ),
-        ],
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 1,
-                },
-            ),
-            GeoSort(
-                GeoSort {
-                    target_point: [
-                        0.0,
-                        0.0,
-                    ],
-                    ascending: true,
-                    value: Some(
-                        [
-                            0.0,
-                            -179.0,
-                        ],
-                    ),
-                },
-            ),
-        ],
-    ]
-    "###);
 
     s.query("intel");
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[1]");
-    insta::assert_snapshot!(format!("{scores:#?}"), @r###"
-    [
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 1,
-                },
-            ),
-            GeoSort(
-                GeoSort {
-                    target_point: [
-                        0.0,
-                        0.0,
-                    ],
-                    ascending: true,
-                    value: Some(
-                        [
-                            88.0,
-                            0.0,
-                        ],
-                    ),
-                },
-            ),
-        ],
-    ]
-    "###);
 }
 
 #[test]
@@ -299,11 +198,9 @@ fn geo_sort_without_any_geo_faceted_documents() {
     let rtxn = index.read_txn().unwrap();
 
     let mut s = Search::new(&rtxn, &index);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.sort_criteria(vec![AscDesc::Asc(Member::Geo([0., 0.]))]);
 
     s.query("jean");
-    let (ids, scores) = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
+    let ids = execute_iterative_and_rtree_returns_the_same(&rtxn, &index, &mut s);
     insta::assert_snapshot!(format!("{ids:?}"), @"[0, 2, 3]");
-    insta::assert_snapshot!(format!("{scores:#?}"));
 }

milli/src/search/new/tests/ngram_split_words.rs

@@ -80,13 +80,10 @@ fn test_2gram_simple() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("sun flower");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     // will also match documents with "sunflower" + prefix tolerance
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[0, 1, 2, 3, 5]");
-    // scores are empty because the only rule is Words with All matching strategy
-    insta::assert_snapshot!(format!("{document_scores:?}"), @"[[], [], [], [], []]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [

milli/src/search/new/tests/proximity.rs

@@ -122,11 +122,11 @@ fn create_edge_cases_index() -> TempIndex {
             sta stb stc ste stf stg sth sti stj stk stl stm stn sto stp stq str stst stt stu stv stw stx sty stz
             "
         },
-        // The next 5 documents lay out a trap with the split word, phrase search, or synonym `sun flower`.
-        // If the search query is "sunflower", the split word "Sun Flower" will match some documents.
+        // The next 5 documents lay out a trap with the split word, phrase search, or synonym `sun flower`. 
+        // If the search query is "sunflower", the split word "Sun Flower" will match some documents. 
         // If the query is `sunflower wilting`, then we should make sure that
         // the sprximity condition `flower wilting: sprx N` also comes with the condition
-        // `sun wilting: sprx N+1`. TODO: this is not the exact condition we use for now.
+        // `sun wilting: sprx N+1`. TODO: this is not the exact condition we use for now. 
         // We only check that the phrase `sun flower` exists and `flower wilting: sprx N`, which
         // is better than nothing but not the best.
         {
@@ -139,7 +139,7 @@ fn create_edge_cases_index() -> TempIndex {
         },
         {
             "id": 3,
-            // This document matches the query `sunflower wilting`, but the sprximity condition
+            // This document matches the query `sunflower wilting`, but the sprximity condition 
             // between `sunflower` and `wilting` cannot be through the split-word `Sun Flower`
             // which would reduce to only `flower` and `wilting` being in sprximity.
             "text": "A flower wilting under the sun, unlike a sunflower"
@@ -270,13 +270,13 @@ fn test_proximity_simple() {
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("the quick brown fox jumps over the lazy dog");
     let SearchResult { documents_ids, .. } = s.execute().unwrap();
-    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[9, 10, 4, 7, 6, 5, 2, 3, 0, 1]");
+    insta::assert_snapshot!(format!("{documents_ids:?}"), @"[4, 9, 10, 7, 6, 5, 2, 3, 0, 1]");
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     insta::assert_debug_snapshot!(texts, @r###"
     [
+        "\"the quickbrown fox jumps over the lazy dog\"",
         "\"the quack brown fox jumps over the lazy dog\"",
         "\"the quick brown fox jumps over the lazy dog\"",
-        "\"the quickbrown fox jumps over the lazy dog\"",
         "\"the really quick brown fox jumps over the lazy dog\"",
         "\"the really quick brown fox jumps over the very lazy dog\"",
         "\"brown quick fox jumps over the lazy dog\"",
@@ -295,12 +295,9 @@ fn test_proximity_split_word() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("sunflower wilting");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 4, 5, 1, 3]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
-
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     // TODO: "2" and "4" should be swapped ideally
     insta::assert_debug_snapshot!(texts, @r###"
@@ -315,11 +312,9 @@ fn test_proximity_split_word() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("\"sun flower\" wilting");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 4, 1]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     // TODO: "2" and "4" should be swapped ideally
     insta::assert_debug_snapshot!(texts, @r###"
@@ -342,11 +337,9 @@ fn test_proximity_split_word() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("xyz wilting");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[2, 4, 1]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     // TODO: "2" and "4" should be swapped ideally
     insta::assert_debug_snapshot!(texts, @r###"
@@ -365,11 +358,9 @@ fn test_proximity_prefix_db() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("best s");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[10, 13, 9, 12, 8, 6, 7, 11, 15]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     // This test illustrates the loss of precision from using the prefix DB
@@ -390,11 +381,9 @@ fn test_proximity_prefix_db() {
     // Difference when using the `su` prefix, which is not in the prefix DB
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("best su");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[10, 13, 9, 12, 8, 11, 7, 6, 15]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     insta::assert_debug_snapshot!(texts, @r###"
@@ -417,11 +406,9 @@ fn test_proximity_prefix_db() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("best win");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[15, 16, 17, 18, 19, 20, 21, 22]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     insta::assert_debug_snapshot!(texts, @r###"
@@ -441,11 +428,9 @@ fn test_proximity_prefix_db() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("best wint");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[19, 22, 18, 21, 17, 20, 16, 15]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     insta::assert_debug_snapshot!(texts, @r###"
@@ -465,11 +450,9 @@ fn test_proximity_prefix_db() {
 
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
     s.query("best wi");
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[19, 22, 18, 21, 17, 15, 16, 20]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"));
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
 
     insta::assert_debug_snapshot!(texts, @r###"

milli/src/search/new/tests/proximity_typo.rs

@@ -61,41 +61,8 @@ fn test_trap_basic() {
     let mut s = Search::new(&txn, &index);
     s.terms_matching_strategy(TermsMatchingStrategy::All);
     s.query("summer holiday");
-    s.scoring_strategy(crate::score_details::ScoringStrategy::Detailed);
-    let SearchResult { documents_ids, document_scores, .. } = s.execute().unwrap();
+    let SearchResult { documents_ids, .. } = s.execute().unwrap();
     insta::assert_snapshot!(format!("{documents_ids:?}"), @"[0, 1]");
-    insta::assert_snapshot!(format!("{document_scores:#?}"), @r###"
-    [
-        [
-            Proximity(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 0,
-                    max_typo_count: 2,
-                },
-            ),
-        ],
-        [
-            Proximity(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 0,
-                    max_typo_count: 2,
-                },
-            ),
-        ],
-    ]
-    "###);
     let texts = collect_field_values(&index, &txn, "text", &documents_ids);
     // TODO: this is incorrect, 1 should come before 0
     insta::assert_debug_snapshot!(texts, @r###"

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_fid__attribute_fid_ngrams.snap

@@ -1,244 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_fid.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        2,
-        [
-            Fid(
-                Rank {
-                    rank: 19,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 91,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 15,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 14,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 79,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Fid(
-                Rank {
-                    rank: 13,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 77,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Fid(
-                Rank {
-                    rank: 12,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 83,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 75,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 10,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 79,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 10,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 73,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Fid(
-                Rank {
-                    rank: 7,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 77,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        10,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 78,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        14,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 75,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Fid(
-                Rank {
-                    rank: 1,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 91,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_fid__attribute_fid_simple.snap

@@ -1,244 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_fid.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        2,
-        [
-            Fid(
-                Rank {
-                    rank: 19,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 91,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 15,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 14,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 79,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Fid(
-                Rank {
-                    rank: 13,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 77,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Fid(
-                Rank {
-                    rank: 12,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 83,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 75,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 10,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 79,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 10,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 73,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Fid(
-                Rank {
-                    rank: 7,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 77,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        10,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 81,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Fid(
-                Rank {
-                    rank: 6,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 78,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        14,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 75,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Fid(
-                Rank {
-                    rank: 1,
-                    max_rank: 19,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 91,
-                    max_rank: 91,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_position__attribute_position_different_fields.snap

@@ -1,244 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_position.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        10,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 18,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 13,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 5,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 1,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_position__attribute_position_ngrams.snap

@@ -1,244 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_position.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        10,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 18,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 13,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 5,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 1,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_position__attribute_position_repeated.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_position.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 11,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 51,
-                    max_rank: 51,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 11,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 51,
-                    max_rank: 51,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 11,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 51,
-                    max_rank: 51,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 11,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 51,
-                    max_rank: 51,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 11,
-                    max_rank: 11,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 50,
-                    max_rank: 51,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__attribute_position__attribute_position_simple-2.snap

@@ -1,244 +0,0 @@
----
-source: milli/src/search/new/tests/attribute_position.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        10,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 21,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 20,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 19,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 18,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 15,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 13,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 5,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 4,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Fid(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Position(
-                Rank {
-                    rank: 1,
-                    max_rank: 21,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_after_words.snap

@@ -1,366 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        19,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        18,
-        [
-            Words(
-                Words {
-                    matching_words: 8,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 9,
-                    max_rank: 9,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 8,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 9,
-                },
-            ),
-        ],
-    ),
-    (
-        17,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        16,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        15,
-        [
-            Words(
-                Words {
-                    matching_words: 5,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 5,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        14,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_all_candidates_with_typo.snap

@@ -1,106 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 1,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_attribute_starts_with_phrase-3.snap

@@ -1,126 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_attribute_starts_with_phrase.snap

@@ -1,86 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 7,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_attribute_starts_with_simple.snap

@@ -1,66 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 2,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 2,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 2,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_followed_by_typo_prefer_no_typo_prefix.snap

@@ -1,136 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 0,
-                    max_typo_count: 1,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 0,
-                    max_typo_count: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 1,
-                    max_typo_count: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 1,
-                    max_typo_count: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 5,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 2,
-                    max_typo_count: 3,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_simple_ordered.snap

@@ -1,186 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        9,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 8,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 9,
-                    max_rank: 9,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 5,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_simple_random.snap

@@ -1,126 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_simple_reversed-3.snap

@@ -1,146 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        9,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__exactness_simple_reversed.snap

@@ -1,146 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        9,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__proximity_after_exactness-4.snap

@@ -1,84 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        0,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 35,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 35,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 35,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__proximity_after_exactness.snap

@@ -1,240 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 57,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 56,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 35,
-                    max_rank: 57,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 22,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 22,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                MatchesStart,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 22,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 21,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 17,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-            Proximity(
-                Rank {
-                    rank: 17,
-                    max_rank: 22,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__typo_followed_by_exactness.snap

@@ -1,110 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 0,
-                    max_typo_count: 5,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        0,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 1,
-                    max_typo_count: 5,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 2,
-                    max_typo_count: 5,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 4,
-                },
-            ),
-            Typo(
-                Typo {
-                    typo_count: 2,
-                    max_typo_count: 5,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__exactness__words_after_exactness.snap

@@ -1,366 +0,0 @@
----
-source: milli/src/search/new/tests/exactness.rs
-expression: "format!(\"{document_ids_scores:#?}\")"
----
-[
-    (
-        19,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 10,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        9,
-        [
-            Words(
-                Words {
-                    matching_words: 9,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 7,
-                    max_rank: 10,
-                },
-            ),
-        ],
-    ),
-    (
-        18,
-        [
-            Words(
-                Words {
-                    matching_words: 8,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 9,
-                    max_rank: 9,
-                },
-            ),
-        ],
-    ),
-    (
-        8,
-        [
-            Words(
-                Words {
-                    matching_words: 8,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 9,
-                },
-            ),
-        ],
-    ),
-    (
-        17,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        16,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 8,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        6,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        7,
-        [
-            Words(
-                Words {
-                    matching_words: 7,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 8,
-                },
-            ),
-        ],
-    ),
-    (
-        15,
-        [
-            Words(
-                Words {
-                    matching_words: 5,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 6,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        5,
-        [
-            Words(
-                Words {
-                    matching_words: 5,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 6,
-                },
-            ),
-        ],
-    ),
-    (
-        14,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 5,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        4,
-        [
-            Words(
-                Words {
-                    matching_words: 4,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 5,
-                },
-            ),
-        ],
-    ),
-    (
-        13,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 4,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        3,
-        [
-            Words(
-                Words {
-                    matching_words: 3,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 4,
-                },
-            ),
-        ],
-    ),
-    (
-        12,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 3,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        2,
-        [
-            Words(
-                Words {
-                    matching_words: 2,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                NoExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 3,
-                },
-            ),
-        ],
-    ),
-    (
-        1,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-    (
-        11,
-        [
-            Words(
-                Words {
-                    matching_words: 1,
-                    max_matching_words: 9,
-                },
-            ),
-            ExactAttribute(
-                ExactMatch,
-            ),
-            Exactness(
-                Rank {
-                    rank: 2,
-                    max_rank: 2,
-                },
-            ),
-        ],
-    ),
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort-2.snap

@@ -1,168 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        1.0,
-                        1.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        2.0,
-                        -1.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -2.0,
-                        -2.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        3.0,
-                        5.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        6.0,
-                        -5.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort-4.snap

@@ -1,168 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        6.0,
-                        -5.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        3.0,
-                        5.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -2.0,
-                        -2.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        2.0,
-                        -1.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        1.0,
-                        1.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: None,
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: None,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-10.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-12.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-14.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-16.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-18.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-2.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-20.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    -175.0,
-                ],
-                ascending: false,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-4.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-6.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    -85.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_around_the_edge_of_the_flat_earth-8.snap

@@ -1,91 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        -179.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        88.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    175.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_mixed_with_words-2.snap

@@ -1,75 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        -89.0,
-                        0.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: Some(
-                    [
-                        0.0,
-                        178.0,
-                    ],
-                ),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__geo_sort__geo_sort_without_any_geo_faceted_documents-2.snap

@@ -1,60 +0,0 @@
----
-source: milli/src/search/new/tests/geo_sort.rs
-expression: "format!(\"{scores:#?}\")"
----
-[
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 1,
-                max_matching_words: 1,
-            },
-        ),
-        GeoSort(
-            GeoSort {
-                target_point: [
-                    0.0,
-                    0.0,
-                ],
-                ascending: true,
-                value: None,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_prefix_db-11.snap

@@ -1,70 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 7,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 4,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_prefix_db-14.snap

@@ -1,70 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 7,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_prefix_db-2.snap

@@ -1,78 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 7,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_prefix_db-5.snap

@@ -1,78 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 7,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 6,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 5,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 4,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_prefix_db-8.snap

@@ -1,70 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_split_word-2.snap

@@ -1,46 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_split_word-5.snap

@@ -1,30 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__proximity__proximity_split_word-8.snap

@@ -1,30 +0,0 @@
----
-source: milli/src/search/new/tests/proximity.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 8,
-                max_rank: 8,
-            },
-        ),
-    ],
-    [
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 8,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__sort__redacted-2.snap

@@ -1,206 +0,0 @@
----
-source: milli/src/search/new/tests/sort.rs
-expression: document_scores_json
----
-[
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 0.0
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.0
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.0
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.0
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.1367
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.2367
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": 1.5673
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "0"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "1"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "false"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "false"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "true"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": "true"
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  },
-  {
-    "vague:asc": {
-      "order": 0,
-      "value": null
-    },
-    "<hidden-rule-1>": {
-      "order": 1,
-      "value": "<hidden>"
-    }
-  }
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__sort__sort-11.snap

@@ -1,206 +0,0 @@
----
-source: milli/src/search/new/tests/sort.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(1.5673),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(1.2367),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(1.1367),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("true"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("true"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("false"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("false"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("1"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: String("0"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: false,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__sort__sort-2.snap

@@ -1,206 +0,0 @@
----
-source: milli/src/search/new/tests/sort.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("i"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("i"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("i"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("h"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("g"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("g"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("f"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("f"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("f"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("e"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("d"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("c"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("c"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("c"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "letter",
-                ascending: false,
-                redacted: false,
-                value: String("b"),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__sort__sort-5.snap

@@ -1,206 +0,0 @@
----
-source: milli/src/search/new/tests/sort.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(5.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(4.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(3.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(2.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "rank",
-                ascending: false,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__sort__sort-8.snap

@@ -1,206 +0,0 @@
----
-source: milli/src/search/new/tests/sort.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(0.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.0),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.1367),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.2367),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Number(1.5673),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("0"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("1"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("false"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("false"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("true"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: String("true"),
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-    [
-        Sort(
-            Sort {
-                field_name: "vague",
-                ascending: true,
-                redacted: false,
-                value: Null,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__stop_words__stop_words_in_phrase-6.snap

@@ -1,129 +0,0 @@
----
-source: milli/src/search/new/tests/stop_words.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Words(
-            Words {
-                matching_words: 3,
-                max_matching_words: 3,
-            },
-        ),
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 2,
-            },
-        ),
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Fid(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Position(
-            Rank {
-                rank: 31,
-                max_rank: 31,
-            },
-        ),
-        ExactAttribute(
-            NoExactMatch,
-        ),
-        Exactness(
-            Rank {
-                rank: 4,
-                max_rank: 4,
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 3,
-                max_matching_words: 3,
-            },
-        ),
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 2,
-            },
-        ),
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Fid(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Position(
-            Rank {
-                rank: 31,
-                max_rank: 31,
-            },
-        ),
-        ExactAttribute(
-            NoExactMatch,
-        ),
-        Exactness(
-            Rank {
-                rank: 4,
-                max_rank: 4,
-            },
-        ),
-    ],
-    [
-        Words(
-            Words {
-                matching_words: 3,
-                max_matching_words: 3,
-            },
-        ),
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 2,
-            },
-        ),
-        Proximity(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Fid(
-            Rank {
-                rank: 1,
-                max_rank: 1,
-            },
-        ),
-        Position(
-            Rank {
-                rank: 27,
-                max_rank: 31,
-            },
-        ),
-        ExactAttribute(
-            NoExactMatch,
-        ),
-        Exactness(
-            Rank {
-                rank: 4,
-                max_rank: 4,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__stop_words__stop_words_in_phrase-8.snap

@@ -1,13 +0,0 @@
----
-source: milli/src/search/new/tests/stop_words.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [],
-    [],
-    [],
-    [],
-    [],
-    [],
-    [],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__typo__typo_bucketing-2.snap

@@ -1,12 +0,0 @@
----
-source: milli/src/search/new/tests/typo.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [],
-    [],
-    [],
-    [],
-    [],
-    [],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__typo__typo_bucketing-5.snap

@@ -1,54 +0,0 @@
----
-source: milli/src/search/new/tests/typo.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 1,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 1,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 2,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 5,
-                max_typo_count: 5,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__typo__typo_bucketing-8.snap

@@ -1,54 +0,0 @@
----
-source: milli/src/search/new/tests/typo.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 0,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 2,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 2,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 3,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-    [
-        Typo(
-            Typo {
-                typo_count: 4,
-                max_typo_count: 6,
-            },
-        ),
-    ],
-]

milli/src/search/new/tests/snapshots/milli__search__new__tests__typo__typo_exact_attribute-4.snap

@@ -1,9 +0,0 @@
----
-source: milli/src/search/new/tests/typo.rs
-expression: "format!(\"{document_scores:#?}\")"
----
-[
-    [],
-    [],
-    [],
-]