search::federated::ranking_rules -> search::ranking_rules

4626: Edit Documents with Rhai r=ManyTheFish a=Kerollmops

This PR introduces a first version of [the _Update Documents with Function_ (internal)](https://www.notion.so/meilisearch/Update-Documents-by-Function-45f87b13e61c4435b73943768a490808). It uses [the Rhai programming language](https://rhai.rs/) to let users express the modifications they want apply.

You can read more about the way to use this functions on [the Usage PRD Page](https://meilisearch.notion.site/Edit-Documents-with-Rhai-0cff8fea7655436592e7c8a6de932062?pvs=25). The [prototype is available](https://github.com/meilisearch/meilisearch/actions/runs/9038384483) through Docker by using the following command:

```
docker run -p 7700:7700 -v $(pwd)/meili_data:/meili_data getmeili/meilisearch:prototype-edit-documents-with-rhai-3
```

## TODO
 - [x] Support the `DocumentEdition` task in dumps.
 - [x] Remove the unwraps and panics.
 - [x] Improve error codes for the `function` parameter.
 - [x] [Update Rhai to v1.19.0](https://github.com/rhaiscript/rhai/releases/tag/v1.19.0) 🚀
 - [x] Make it an experimental feature (only restrict the HTTP calls).
 - [x] It must be possible not to send a context.
 - [x] Rebase on main.
 - [x] Check that the script cannot do any io.
 - [x] ~Introduce a `Documents.edit` action or~ require the `Documents.all` action.
 - [x] Change the `editionCode` to the clearer `function` field name in the tasks.
 - [x] Support a user provided context and maybe more (but keep function execution isolated for reproducibility).
 - [x] Support deleting documents when the `doc` is `()` (nil, null).
 - [x] Support canceling document edition.
 - [x] Multithread document edition by using rayon (and [rayon-par-bridge](https://docs.rs/rayon-par-bridge/latest/rayon_par_bridge/)).
 - [x] Limit the number of instruction by function execution.
 - [ ] ~Expose the limit of instructions in the settings.~ Not sure, in fact.
 - [x] Ignore unmodified documents in the tasks count.
 - [x] Make the `filter` field optional (not forced to be `null`).

Co-authored-by: Clément Renault <clement@meilisearch.com>

.github/workflows/test-suite.yml

@@ -167,7 +167,7 @@ jobs:
       - uses: helix-editor/rust-toolchain@v1
         with:
           profile: minimal
-          toolchain: nightly-2024-06-25
+          toolchain: nightly-2024-07-09
           override: true
           components: rustfmt
       - name: Cache dependencies

CONTRIBUTING.md

@@ -52,6 +52,16 @@ cargo test
 
 This command will be triggered to each PR as a requirement for merging it.
 
+#### Faster build
+
+You can set the `LINDERA_CACHE` environment variable to speed up your successive builds by up to 2 minutes.
+It'll store some built artifacts in the directory of your choice.
+
+We recommend using the standard `$HOME/.cache/lindera` directory:
+```sh
+export LINDERA_CACHE=$HOME/.cache/lindera
+```
+
 #### Snapshot-based tests
 
 We are using [insta](https://insta.rs) to perform snapshot-based testing.
@@ -63,7 +73,7 @@ Furthermore, we provide some macros on top of insta, notably a way to use snapsh
 
 To effectively debug snapshot-based hashes, we recommend you export the `MEILI_TEST_FULL_SNAPS` environment variable so that snapshot are fully created locally:
 
-```
+```sh
 export MEILI_TEST_FULL_SNAPS=true # add this to your .bashrc, .zshrc, ...
 ```
 

Dockerfile

@@ -1,7 +1,7 @@
 # Compile
-FROM    rust:1.75.0-alpine3.18 AS compiler
+FROM    rust:1.79.0-alpine3.20 AS compiler
 
-RUN     apk add -q --update-cache --no-cache build-base openssl-dev
+RUN     apk add -q --no-cache build-base openssl-dev
 
 WORKDIR /
 
@@ -20,13 +20,12 @@ RUN     set -eux; \
         cargo build --release -p meilisearch -p meilitool
 
 # Run
-FROM    alpine:3.16
+FROM    alpine:3.20
 
 ENV     MEILI_HTTP_ADDR 0.0.0.0:7700
 ENV     MEILI_SERVER_PROVIDER docker
 
-RUN     apk update --quiet \
-        && apk add -q --no-cache libgcc tini curl
+RUN     apk add -q --no-cache libgcc tini curl
 
 # add meilisearch and meilitool to the `/bin` so you can run it from anywhere
 # and it's easy to find.

benchmarks/Cargo.toml

@@ -11,24 +11,24 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-anyhow = "1.0.79"
+anyhow = "1.0.86"
 csv = "1.3.0"
 milli = { path = "../milli" }
-mimalloc = { version = "0.1.39", default-features = false }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
+mimalloc = { version = "0.1.43", default-features = false }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }
 rand = "0.8.5"
 rand_chacha = "0.3.1"
-roaring = "0.10.2"
+roaring = "0.10.6"
 
 [build-dependencies]
-anyhow = "1.0.79"
-bytes = "1.5.0"
+anyhow = "1.0.86"
+bytes = "1.6.0"
 convert_case = "0.6.0"
-flate2 = "1.0.28"
-reqwest = { version = "0.11.23", features = ["blocking", "rustls-tls"], default-features = false }
+flate2 = "1.0.30"
+reqwest = { version = "0.12.5", features = ["blocking", "rustls-tls"], default-features = false }
 
 [features]
 default = ["milli/all-tokenizations"]

build-info/Cargo.toml

@@ -11,8 +11,8 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-time = { version = "0.3.34", features = ["parsing"] }
+time = { version = "0.3.36", features = ["parsing"] }
 
 [build-dependencies]
-anyhow = "1.0.80"
-vergen-git2 = "1.0.0-beta.2"
+anyhow = "1.0.86"
+vergen-git2 = "1.0.0"

dump/Cargo.toml

@@ -11,22 +11,21 @@ readme.workspace = true
 license.workspace = true
 
 [dependencies]
-anyhow = "1.0.79"
-flate2 = "1.0.28"
-http = "0.2.11"
-meilisearch-auth = { path = "../meilisearch-auth" }
+anyhow = "1.0.86"
+flate2 = "1.0.30"
+http = "1.1.0"
 meilisearch-types = { path = "../meilisearch-types" }
 once_cell = "1.19.0"
-regex = "1.10.2"
-roaring = { version = "0.10.2", features = ["serde"] }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
-tar = "0.4.40"
-tempfile = "3.9.0"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = ["serde-well-known", "formatting", "parsing", "macros"] }
+regex = "1.10.5"
+roaring = { version = "0.10.6", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
+tar = "0.4.41"
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = ["serde-well-known", "formatting", "parsing", "macros"] }
 tracing = "0.1.40"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
+uuid = { version = "1.10.0", features = ["serde", "v4"] }
 
 [dev-dependencies]
 big_s = "1.0.2"

dump/src/lib.rs

@@ -104,6 +104,11 @@ pub enum KindDump {
     DocumentDeletionByFilter {
         filter: serde_json::Value,
     },
+    DocumentEdition {
+        filter: Option<serde_json::Value>,
+        context: Option<serde_json::Map<String, serde_json::Value>>,
+        function: String,
+    },
     Settings {
         settings: Box<meilisearch_types::settings::Settings<Unchecked>>,
         is_deletion: bool,
@@ -172,6 +177,9 @@ impl From<KindWithContent> for KindDump {
             KindWithContent::DocumentDeletionByFilter { filter_expr, .. } => {
                 KindDump::DocumentDeletionByFilter { filter: filter_expr }
             }
+            KindWithContent::DocumentEdition { filter_expr, context, function, .. } => {
+                KindDump::DocumentEdition { filter: filter_expr, context, function }
+            }
             KindWithContent::DocumentClear { .. } => KindDump::DocumentClear,
             KindWithContent::SettingsUpdate {
                 new_settings,

dump/src/reader/compat/v2_to_v3.rs

@@ -425,7 +425,7 @@ pub(crate) mod test {
         let mut dump = v2::V2Reader::open(dir).unwrap().to_v3();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/compat/v3_to_v4.rs

@@ -358,7 +358,7 @@ pub(crate) mod test {
         let mut dump = v3::V3Reader::open(dir).unwrap().to_v4();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/compat/v4_to_v5.rs

@@ -394,8 +394,8 @@ pub(crate) mod test {
         let mut dump = v4::V4Reader::open(dir).unwrap().to_v5();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/compat/v5_to_v6.rs

@@ -442,8 +442,8 @@ pub(crate) mod test {
         let mut dump = v5::V5Reader::open(dir).unwrap().to_v6();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/mod.rs

@@ -216,7 +216,7 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2024-05-16 15:51:34.151044 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2024-05-16 15:51:34.151044 +00:00:00");
         insta::assert_debug_snapshot!(dump.instance_uid().unwrap(), @"None");
 
         // tasks
@@ -337,7 +337,7 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2023-07-06 7:10:27.21958 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2023-07-06 7:10:27.21958 +00:00:00");
         insta::assert_debug_snapshot!(dump.instance_uid().unwrap(), @"None");
 
         // tasks
@@ -383,8 +383,8 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
@@ -463,8 +463,8 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().unwrap().collect::<Result<Vec<_>>>().unwrap();
@@ -540,7 +540,7 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
         assert_eq!(dump.instance_uid().unwrap(), None);
 
         // tasks
@@ -633,7 +633,7 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
         assert_eq!(dump.instance_uid().unwrap(), None);
 
         // tasks
@@ -726,7 +726,7 @@ pub(crate) mod test {
         let mut dump = DumpReader::open(dump).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
         assert_eq!(dump.instance_uid().unwrap(), None);
 
         // tasks

dump/src/reader/v2/mod.rs

@@ -252,7 +252,7 @@ pub(crate) mod test {
         let mut dump = V2Reader::open(dir).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-09 20:27:59.904096267 +00:00:00");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();
@@ -349,7 +349,7 @@ pub(crate) mod test {
         let mut dump = V2Reader::open(dir).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2023-01-30 16:26:09.247261 +00:00:00");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/v3/mod.rs

@@ -267,7 +267,7 @@ pub(crate) mod test {
         let mut dump = V3Reader::open(dir).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-07 11:39:03.709153554 +00:00:00");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/v4/mod.rs

@@ -262,8 +262,8 @@ pub(crate) mod test {
         let mut dump = V4Reader::open(dir).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-06 12:53:49.131989609 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/reader/v5/mod.rs

@@ -299,8 +299,8 @@ pub(crate) mod test {
         let mut dump = V5Reader::open(dir).unwrap();
 
         // top level infos
-        insta::assert_display_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
-        insta::assert_display_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
+        insta::assert_snapshot!(dump.date().unwrap(), @"2022-10-04 15:55:10.344982459 +00:00:00");
+        insta::assert_snapshot!(dump.instance_uid().unwrap().unwrap(), @"9e15e977-f2ae-4761-943f-1eaf75fd736d");
 
         // tasks
         let tasks = dump.tasks().collect::<Result<Vec<_>>>().unwrap();

dump/src/writer.rs

@@ -281,7 +281,7 @@ pub(crate) mod test {
         let dump_path = dump.path();
 
         // ==== checking global file hierarchy (we want to be sure there isn't too many files or too few)
-        insta::assert_display_snapshot!(create_directory_hierarchy(dump_path), @r###"
+        insta::assert_snapshot!(create_directory_hierarchy(dump_path), @r###"
         .
         ├---- indexes/
         │    └---- doggos/

file-store/Cargo.toml

@@ -11,10 +11,7 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-tempfile = "3.9.0"
-thiserror = "1.0.56"
+tempfile = "3.10.1"
+thiserror = "1.0.61"
 tracing = "0.1.40"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
-
-[dev-dependencies]
-faux = "0.1.10"
+uuid = { version = "1.10.0", features = ["serde", "v4"] }

filter-parser/Cargo.toml

@@ -14,7 +14,7 @@ license.workspace = true
 [dependencies]
 nom = "7.1.3"
 nom_locate = "4.2.0"
-unescaper = "0.1.3"
+unescaper = "0.1.5"
 
 [dev-dependencies]
-insta = "1.34.0"
+insta = "1.39.0"

filter-parser/src/lib.rs

@@ -564,121 +564,121 @@ pub mod tests {
 
     #[test]
     fn parse_escaped() {
-        insta::assert_display_snapshot!(p(r"title = 'foo\\'"), @r#"{title} = {foo\}"#);
-        insta::assert_display_snapshot!(p(r"title = 'foo\\\\'"), @r#"{title} = {foo\\}"#);
-        insta::assert_display_snapshot!(p(r"title = 'foo\\\\\\'"), @r#"{title} = {foo\\\}"#);
-        insta::assert_display_snapshot!(p(r"title = 'foo\\\\\\\\'"), @r#"{title} = {foo\\\\}"#);
+        insta::assert_snapshot!(p(r"title = 'foo\\'"), @r#"{title} = {foo\}"#);
+        insta::assert_snapshot!(p(r"title = 'foo\\\\'"), @r#"{title} = {foo\\}"#);
+        insta::assert_snapshot!(p(r"title = 'foo\\\\\\'"), @r#"{title} = {foo\\\}"#);
+        insta::assert_snapshot!(p(r"title = 'foo\\\\\\\\'"), @r#"{title} = {foo\\\\}"#);
         // but it also works with other sequences
-        insta::assert_display_snapshot!(p(r#"title = 'foo\x20\n\t\"\'"'"#), @"{title} = {foo \n\t\"\'\"}");
+        insta::assert_snapshot!(p(r#"title = 'foo\x20\n\t\"\'"'"#), @"{title} = {foo \n\t\"\'\"}");
     }
 
     #[test]
     fn parse() {
         // Test equal
-        insta::assert_display_snapshot!(p("channel = Ponce"), @"{channel} = {Ponce}");
-        insta::assert_display_snapshot!(p("subscribers = 12"), @"{subscribers} = {12}");
-        insta::assert_display_snapshot!(p("channel = 'Mister Mv'"), @"{channel} = {Mister Mv}");
-        insta::assert_display_snapshot!(p("channel = \"Mister Mv\""), @"{channel} = {Mister Mv}");
-        insta::assert_display_snapshot!(p("'dog race' = Borzoi"), @"{dog race} = {Borzoi}");
-        insta::assert_display_snapshot!(p("\"dog race\" = Chusky"), @"{dog race} = {Chusky}");
-        insta::assert_display_snapshot!(p("\"dog race\" = \"Bernese Mountain\""), @"{dog race} = {Bernese Mountain}");
-        insta::assert_display_snapshot!(p("'dog race' = 'Bernese Mountain'"), @"{dog race} = {Bernese Mountain}");
-        insta::assert_display_snapshot!(p("\"dog race\" = 'Bernese Mountain'"), @"{dog race} = {Bernese Mountain}");
+        insta::assert_snapshot!(p("channel = Ponce"), @"{channel} = {Ponce}");
+        insta::assert_snapshot!(p("subscribers = 12"), @"{subscribers} = {12}");
+        insta::assert_snapshot!(p("channel = 'Mister Mv'"), @"{channel} = {Mister Mv}");
+        insta::assert_snapshot!(p("channel = \"Mister Mv\""), @"{channel} = {Mister Mv}");
+        insta::assert_snapshot!(p("'dog race' = Borzoi"), @"{dog race} = {Borzoi}");
+        insta::assert_snapshot!(p("\"dog race\" = Chusky"), @"{dog race} = {Chusky}");
+        insta::assert_snapshot!(p("\"dog race\" = \"Bernese Mountain\""), @"{dog race} = {Bernese Mountain}");
+        insta::assert_snapshot!(p("'dog race' = 'Bernese Mountain'"), @"{dog race} = {Bernese Mountain}");
+        insta::assert_snapshot!(p("\"dog race\" = 'Bernese Mountain'"), @"{dog race} = {Bernese Mountain}");
 
         // Test IN
-        insta::assert_display_snapshot!(p("colour IN[]"), @"{colour} IN[]");
-        insta::assert_display_snapshot!(p("colour IN[green]"), @"{colour} IN[{green}, ]");
-        insta::assert_display_snapshot!(p("colour IN[green,]"), @"{colour} IN[{green}, ]");
-        insta::assert_display_snapshot!(p("colour NOT IN[green,blue]"), @"NOT ({colour} IN[{green}, {blue}, ])");
-        insta::assert_display_snapshot!(p(" colour IN [  green , blue , ]"), @"{colour} IN[{green}, {blue}, ]");
+        insta::assert_snapshot!(p("colour IN[]"), @"{colour} IN[]");
+        insta::assert_snapshot!(p("colour IN[green]"), @"{colour} IN[{green}, ]");
+        insta::assert_snapshot!(p("colour IN[green,]"), @"{colour} IN[{green}, ]");
+        insta::assert_snapshot!(p("colour NOT IN[green,blue]"), @"NOT ({colour} IN[{green}, {blue}, ])");
+        insta::assert_snapshot!(p(" colour IN [  green , blue , ]"), @"{colour} IN[{green}, {blue}, ]");
 
         // Test IN + OR/AND/()
-        insta::assert_display_snapshot!(p(" colour IN [green, blue]  AND color = green "), @"AND[{colour} IN[{green}, {blue}, ], {color} = {green}, ]");
-        insta::assert_display_snapshot!(p("NOT (colour IN [green, blue])  AND color = green "), @"AND[NOT ({colour} IN[{green}, {blue}, ]), {color} = {green}, ]");
-        insta::assert_display_snapshot!(p("x = 1 OR NOT (colour IN [green, blue]  OR color = green) "), @"OR[{x} = {1}, NOT (OR[{colour} IN[{green}, {blue}, ], {color} = {green}, ]), ]");
+        insta::assert_snapshot!(p(" colour IN [green, blue]  AND color = green "), @"AND[{colour} IN[{green}, {blue}, ], {color} = {green}, ]");
+        insta::assert_snapshot!(p("NOT (colour IN [green, blue])  AND color = green "), @"AND[NOT ({colour} IN[{green}, {blue}, ]), {color} = {green}, ]");
+        insta::assert_snapshot!(p("x = 1 OR NOT (colour IN [green, blue]  OR color = green) "), @"OR[{x} = {1}, NOT (OR[{colour} IN[{green}, {blue}, ], {color} = {green}, ]), ]");
 
         // Test whitespace start/end
-        insta::assert_display_snapshot!(p(" colour = green "), @"{colour} = {green}");
-        insta::assert_display_snapshot!(p(" (colour = green OR colour = red) "), @"OR[{colour} = {green}, {colour} = {red}, ]");
-        insta::assert_display_snapshot!(p(" colour IN [green, blue]  AND color = green "), @"AND[{colour} IN[{green}, {blue}, ], {color} = {green}, ]");
-        insta::assert_display_snapshot!(p(" colour NOT  IN [green, blue] "), @"NOT ({colour} IN[{green}, {blue}, ])");
-        insta::assert_display_snapshot!(p(" colour IN [green, blue] "), @"{colour} IN[{green}, {blue}, ]");
+        insta::assert_snapshot!(p(" colour = green "), @"{colour} = {green}");
+        insta::assert_snapshot!(p(" (colour = green OR colour = red) "), @"OR[{colour} = {green}, {colour} = {red}, ]");
+        insta::assert_snapshot!(p(" colour IN [green, blue]  AND color = green "), @"AND[{colour} IN[{green}, {blue}, ], {color} = {green}, ]");
+        insta::assert_snapshot!(p(" colour NOT  IN [green, blue] "), @"NOT ({colour} IN[{green}, {blue}, ])");
+        insta::assert_snapshot!(p(" colour IN [green, blue] "), @"{colour} IN[{green}, {blue}, ]");
 
         // Test conditions
-        insta::assert_display_snapshot!(p("channel != ponce"), @"{channel} != {ponce}");
-        insta::assert_display_snapshot!(p("NOT channel = ponce"), @"NOT ({channel} = {ponce})");
-        insta::assert_display_snapshot!(p("subscribers < 1000"), @"{subscribers} < {1000}");
-        insta::assert_display_snapshot!(p("subscribers > 1000"), @"{subscribers} > {1000}");
-        insta::assert_display_snapshot!(p("subscribers <= 1000"), @"{subscribers} <= {1000}");
-        insta::assert_display_snapshot!(p("subscribers >= 1000"), @"{subscribers} >= {1000}");
-        insta::assert_display_snapshot!(p("subscribers <= 1000"), @"{subscribers} <= {1000}");
-        insta::assert_display_snapshot!(p("subscribers 100 TO 1000"), @"{subscribers} {100} TO {1000}");
+        insta::assert_snapshot!(p("channel != ponce"), @"{channel} != {ponce}");
+        insta::assert_snapshot!(p("NOT channel = ponce"), @"NOT ({channel} = {ponce})");
+        insta::assert_snapshot!(p("subscribers < 1000"), @"{subscribers} < {1000}");
+        insta::assert_snapshot!(p("subscribers > 1000"), @"{subscribers} > {1000}");
+        insta::assert_snapshot!(p("subscribers <= 1000"), @"{subscribers} <= {1000}");
+        insta::assert_snapshot!(p("subscribers >= 1000"), @"{subscribers} >= {1000}");
+        insta::assert_snapshot!(p("subscribers <= 1000"), @"{subscribers} <= {1000}");
+        insta::assert_snapshot!(p("subscribers 100 TO 1000"), @"{subscribers} {100} TO {1000}");
 
         // Test NOT
-        insta::assert_display_snapshot!(p("NOT subscribers < 1000"), @"NOT ({subscribers} < {1000})");
-        insta::assert_display_snapshot!(p("NOT subscribers 100 TO 1000"), @"NOT ({subscribers} {100} TO {1000})");
+        insta::assert_snapshot!(p("NOT subscribers < 1000"), @"NOT ({subscribers} < {1000})");
+        insta::assert_snapshot!(p("NOT subscribers 100 TO 1000"), @"NOT ({subscribers} {100} TO {1000})");
 
         // Test NULL + NOT NULL
-        insta::assert_display_snapshot!(p("subscribers IS NULL"), @"{subscribers} IS NULL");
-        insta::assert_display_snapshot!(p("NOT subscribers IS NULL"), @"NOT ({subscribers} IS NULL)");
-        insta::assert_display_snapshot!(p("subscribers IS NOT NULL"), @"NOT ({subscribers} IS NULL)");
-        insta::assert_display_snapshot!(p("NOT subscribers IS NOT NULL"), @"{subscribers} IS NULL");
-        insta::assert_display_snapshot!(p("subscribers  IS   NOT   NULL"), @"NOT ({subscribers} IS NULL)");
+        insta::assert_snapshot!(p("subscribers IS NULL"), @"{subscribers} IS NULL");
+        insta::assert_snapshot!(p("NOT subscribers IS NULL"), @"NOT ({subscribers} IS NULL)");
+        insta::assert_snapshot!(p("subscribers IS NOT NULL"), @"NOT ({subscribers} IS NULL)");
+        insta::assert_snapshot!(p("NOT subscribers IS NOT NULL"), @"{subscribers} IS NULL");
+        insta::assert_snapshot!(p("subscribers  IS   NOT   NULL"), @"NOT ({subscribers} IS NULL)");
 
         // Test EMPTY + NOT EMPTY
-        insta::assert_display_snapshot!(p("subscribers IS EMPTY"), @"{subscribers} IS EMPTY");
-        insta::assert_display_snapshot!(p("NOT subscribers IS EMPTY"), @"NOT ({subscribers} IS EMPTY)");
-        insta::assert_display_snapshot!(p("subscribers IS NOT EMPTY"), @"NOT ({subscribers} IS EMPTY)");
-        insta::assert_display_snapshot!(p("NOT subscribers IS NOT EMPTY"), @"{subscribers} IS EMPTY");
-        insta::assert_display_snapshot!(p("subscribers  IS   NOT   EMPTY"), @"NOT ({subscribers} IS EMPTY)");
+        insta::assert_snapshot!(p("subscribers IS EMPTY"), @"{subscribers} IS EMPTY");
+        insta::assert_snapshot!(p("NOT subscribers IS EMPTY"), @"NOT ({subscribers} IS EMPTY)");
+        insta::assert_snapshot!(p("subscribers IS NOT EMPTY"), @"NOT ({subscribers} IS EMPTY)");
+        insta::assert_snapshot!(p("NOT subscribers IS NOT EMPTY"), @"{subscribers} IS EMPTY");
+        insta::assert_snapshot!(p("subscribers  IS   NOT   EMPTY"), @"NOT ({subscribers} IS EMPTY)");
 
         // Test EXISTS + NOT EXITS
-        insta::assert_display_snapshot!(p("subscribers EXISTS"), @"{subscribers} EXISTS");
-        insta::assert_display_snapshot!(p("NOT subscribers EXISTS"), @"NOT ({subscribers} EXISTS)");
-        insta::assert_display_snapshot!(p("subscribers NOT EXISTS"), @"NOT ({subscribers} EXISTS)");
-        insta::assert_display_snapshot!(p("NOT subscribers NOT EXISTS"), @"{subscribers} EXISTS");
-        insta::assert_display_snapshot!(p("subscribers NOT   EXISTS"), @"NOT ({subscribers} EXISTS)");
+        insta::assert_snapshot!(p("subscribers EXISTS"), @"{subscribers} EXISTS");
+        insta::assert_snapshot!(p("NOT subscribers EXISTS"), @"NOT ({subscribers} EXISTS)");
+        insta::assert_snapshot!(p("subscribers NOT EXISTS"), @"NOT ({subscribers} EXISTS)");
+        insta::assert_snapshot!(p("NOT subscribers NOT EXISTS"), @"{subscribers} EXISTS");
+        insta::assert_snapshot!(p("subscribers NOT   EXISTS"), @"NOT ({subscribers} EXISTS)");
 
         // Test nested NOT
-        insta::assert_display_snapshot!(p("NOT NOT NOT NOT x = 5"), @"{x} = {5}");
-        insta::assert_display_snapshot!(p("NOT NOT (NOT NOT x = 5)"), @"{x} = {5}");
+        insta::assert_snapshot!(p("NOT NOT NOT NOT x = 5"), @"{x} = {5}");
+        insta::assert_snapshot!(p("NOT NOT (NOT NOT x = 5)"), @"{x} = {5}");
 
         // Test geo radius
-        insta::assert_display_snapshot!(p("_geoRadius(12, 13, 14)"), @"_geoRadius({12}, {13}, {14})");
-        insta::assert_display_snapshot!(p("NOT _geoRadius(12, 13, 14)"), @"NOT (_geoRadius({12}, {13}, {14}))");
-        insta::assert_display_snapshot!(p("_geoRadius(12,13,14)"), @"_geoRadius({12}, {13}, {14})");
+        insta::assert_snapshot!(p("_geoRadius(12, 13, 14)"), @"_geoRadius({12}, {13}, {14})");
+        insta::assert_snapshot!(p("NOT _geoRadius(12, 13, 14)"), @"NOT (_geoRadius({12}, {13}, {14}))");
+        insta::assert_snapshot!(p("_geoRadius(12,13,14)"), @"_geoRadius({12}, {13}, {14})");
 
         // Test geo bounding box
-        insta::assert_display_snapshot!(p("_geoBoundingBox([12, 13], [14, 15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
-        insta::assert_display_snapshot!(p("NOT _geoBoundingBox([12, 13], [14, 15])"), @"NOT (_geoBoundingBox([{12}, {13}], [{14}, {15}]))");
-        insta::assert_display_snapshot!(p("_geoBoundingBox([12,13],[14,15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
+        insta::assert_snapshot!(p("_geoBoundingBox([12, 13], [14, 15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
+        insta::assert_snapshot!(p("NOT _geoBoundingBox([12, 13], [14, 15])"), @"NOT (_geoBoundingBox([{12}, {13}], [{14}, {15}]))");
+        insta::assert_snapshot!(p("_geoBoundingBox([12,13],[14,15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
 
         // Test OR + AND
-        insta::assert_display_snapshot!(p("channel = ponce AND 'dog race' != 'bernese mountain'"), @"AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
-        insta::assert_display_snapshot!(p("channel = ponce OR 'dog race' != 'bernese mountain'"), @"OR[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
-        insta::assert_display_snapshot!(p("channel = ponce AND 'dog race' != 'bernese mountain' OR subscribers > 1000"), @"OR[AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ], {subscribers} > {1000}, ]");
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(p("channel = ponce AND 'dog race' != 'bernese mountain'"), @"AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
+        insta::assert_snapshot!(p("channel = ponce OR 'dog race' != 'bernese mountain'"), @"OR[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
+        insta::assert_snapshot!(p("channel = ponce AND 'dog race' != 'bernese mountain' OR subscribers > 1000"), @"OR[AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ], {subscribers} > {1000}, ]");
+        insta::assert_snapshot!(
         p("channel = ponce AND 'dog race' != 'bernese mountain' OR subscribers > 1000 OR colour = red OR colour = blue AND size = 7"),
         @"OR[AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ], {subscribers} > {1000}, {colour} = {red}, AND[{colour} = {blue}, {size} = {7}, ], ]"
         );
 
         // Test parentheses
-        insta::assert_display_snapshot!(p("channel = ponce AND ( 'dog race' != 'bernese mountain' OR subscribers > 1000 )"), @"AND[{channel} = {ponce}, OR[{dog race} != {bernese mountain}, {subscribers} > {1000}, ], ]");
-        insta::assert_display_snapshot!(p("(channel = ponce AND 'dog race' != 'bernese mountain' OR subscribers > 1000) AND _geoRadius(12, 13, 14)"), @"AND[OR[AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ], {subscribers} > {1000}, ], _geoRadius({12}, {13}, {14}), ]");
+        insta::assert_snapshot!(p("channel = ponce AND ( 'dog race' != 'bernese mountain' OR subscribers > 1000 )"), @"AND[{channel} = {ponce}, OR[{dog race} != {bernese mountain}, {subscribers} > {1000}, ], ]");
+        insta::assert_snapshot!(p("(channel = ponce AND 'dog race' != 'bernese mountain' OR subscribers > 1000) AND _geoRadius(12, 13, 14)"), @"AND[OR[AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ], {subscribers} > {1000}, ], _geoRadius({12}, {13}, {14}), ]");
 
         // Test recursion
         // This is the most that is allowed
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(
             p("(((((((((((((((((((((((((((((((((((((((((((((((((x = 1)))))))))))))))))))))))))))))))))))))))))))))))))"),
             @"{x} = {1}"
         );
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(
             p("NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT x = 1"),
             @"NOT ({x} = {1})"
         );
 
         // Confusing keywords
-        insta::assert_display_snapshot!(p(r#"NOT "OR" EXISTS AND "EXISTS" NOT EXISTS"#), @"AND[NOT ({OR} EXISTS), NOT ({EXISTS} EXISTS), ]");
+        insta::assert_snapshot!(p(r#"NOT "OR" EXISTS AND "EXISTS" NOT EXISTS"#), @"AND[NOT ({OR} EXISTS), NOT ({EXISTS} EXISTS), ]");
     }
 
     #[test]
@@ -689,182 +689,182 @@ pub mod tests {
             Fc::parse(s).unwrap_err().to_string()
         }
 
-        insta::assert_display_snapshot!(p("channel = Ponce = 12"), @r###"
+        insta::assert_snapshot!(p("channel = Ponce = 12"), @r###"
         Found unexpected characters at the end of the filter: `= 12`. You probably forgot an `OR` or an `AND` rule.
         17:21 channel = Ponce = 12
         "###);
 
-        insta::assert_display_snapshot!(p("channel =    "), @r###"
+        insta::assert_snapshot!(p("channel =    "), @r###"
         Was expecting a value but instead got nothing.
         14:14 channel =
         "###);
 
-        insta::assert_display_snapshot!(p("channel = 🐻"), @r###"
+        insta::assert_snapshot!(p("channel = 🐻"), @r###"
         Was expecting a value but instead got `🐻`.
         11:12 channel = 🐻
         "###);
 
-        insta::assert_display_snapshot!(p("channel = 🐻 AND followers < 100"), @r###"
+        insta::assert_snapshot!(p("channel = 🐻 AND followers < 100"), @r###"
         Was expecting a value but instead got `🐻`.
         11:12 channel = 🐻 AND followers < 100
         "###);
 
-        insta::assert_display_snapshot!(p("'OR'"), @r###"
+        insta::assert_snapshot!(p("'OR'"), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `\'OR\'`.
         1:5 'OR'
         "###);
 
-        insta::assert_display_snapshot!(p("OR"), @r###"
+        insta::assert_snapshot!(p("OR"), @r###"
         Was expecting a value but instead got `OR`, which is a reserved keyword. To use `OR` as a field name or a value, surround it by quotes.
         1:3 OR
         "###);
 
-        insta::assert_display_snapshot!(p("channel Ponce"), @r###"
+        insta::assert_snapshot!(p("channel Ponce"), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `channel Ponce`.
         1:14 channel Ponce
         "###);
 
-        insta::assert_display_snapshot!(p("channel = Ponce OR"), @r###"
+        insta::assert_snapshot!(p("channel = Ponce OR"), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` but instead got nothing.
         19:19 channel = Ponce OR
         "###);
 
-        insta::assert_display_snapshot!(p("_geoRadius"), @r###"
+        insta::assert_snapshot!(p("_geoRadius"), @r###"
         The `_geoRadius` filter expects three arguments: `_geoRadius(latitude, longitude, radius)`.
         1:11 _geoRadius
         "###);
 
-        insta::assert_display_snapshot!(p("_geoRadius = 12"), @r###"
+        insta::assert_snapshot!(p("_geoRadius = 12"), @r###"
         The `_geoRadius` filter expects three arguments: `_geoRadius(latitude, longitude, radius)`.
         1:16 _geoRadius = 12
         "###);
 
-        insta::assert_display_snapshot!(p("_geoBoundingBox"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox"), @r###"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
         1:16 _geoBoundingBox
         "###);
 
-        insta::assert_display_snapshot!(p("_geoBoundingBox = 12"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox = 12"), @r###"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
         1:21 _geoBoundingBox = 12
         "###);
 
-        insta::assert_display_snapshot!(p("_geoBoundingBox(1.0, 1.0)"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox(1.0, 1.0)"), @r###"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
         1:26 _geoBoundingBox(1.0, 1.0)
         "###);
 
-        insta::assert_display_snapshot!(p("_geoPoint(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("_geoPoint(12, 13, 14)"), @r###"
         `_geoPoint` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         1:22 _geoPoint(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("position <= _geoPoint(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("position <= _geoPoint(12, 13, 14)"), @r###"
         `_geoPoint` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         13:34 position <= _geoPoint(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("_geoDistance(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("_geoDistance(12, 13, 14)"), @r###"
         `_geoDistance` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         1:25 _geoDistance(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("position <= _geoDistance(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("position <= _geoDistance(12, 13, 14)"), @r###"
         `_geoDistance` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         13:37 position <= _geoDistance(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("_geo(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("_geo(12, 13, 14)"), @r###"
         `_geo` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         1:17 _geo(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("position <= _geo(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("position <= _geo(12, 13, 14)"), @r###"
         `_geo` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
         13:29 position <= _geo(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("position <= _geoRadius(12, 13, 14)"), @r###"
+        insta::assert_snapshot!(p("position <= _geoRadius(12, 13, 14)"), @r###"
         The `_geoRadius` filter is an operation and can't be used as a value.
         13:35 position <= _geoRadius(12, 13, 14)
         "###);
 
-        insta::assert_display_snapshot!(p("channel = 'ponce"), @r###"
+        insta::assert_snapshot!(p("channel = 'ponce"), @r###"
         Expression `\'ponce` is missing the following closing delimiter: `'`.
         11:17 channel = 'ponce
         "###);
 
-        insta::assert_display_snapshot!(p("channel = \"ponce"), @r###"
+        insta::assert_snapshot!(p("channel = \"ponce"), @r###"
         Expression `\"ponce` is missing the following closing delimiter: `"`.
         11:17 channel = "ponce
         "###);
 
-        insta::assert_display_snapshot!(p("channel = mv OR (followers >= 1000"), @r###"
+        insta::assert_snapshot!(p("channel = mv OR (followers >= 1000"), @r###"
         Expression `(followers >= 1000` is missing the following closing delimiter: `)`.
         17:35 channel = mv OR (followers >= 1000
         "###);
 
-        insta::assert_display_snapshot!(p("channel = mv OR followers >= 1000)"), @r###"
+        insta::assert_snapshot!(p("channel = mv OR followers >= 1000)"), @r###"
         Found unexpected characters at the end of the filter: `)`. You probably forgot an `OR` or an `AND` rule.
         34:35 channel = mv OR followers >= 1000)
         "###);
 
-        insta::assert_display_snapshot!(p("colour NOT EXIST"), @r###"
+        insta::assert_snapshot!(p("colour NOT EXIST"), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `colour NOT EXIST`.
         1:17 colour NOT EXIST
         "###);
 
-        insta::assert_display_snapshot!(p("subscribers 100 TO1000"), @r###"
+        insta::assert_snapshot!(p("subscribers 100 TO1000"), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `subscribers 100 TO1000`.
         1:23 subscribers 100 TO1000
         "###);
 
-        insta::assert_display_snapshot!(p("channel = ponce ORdog != 'bernese mountain'"), @r###"
+        insta::assert_snapshot!(p("channel = ponce ORdog != 'bernese mountain'"), @r###"
         Found unexpected characters at the end of the filter: `ORdog != \'bernese mountain\'`. You probably forgot an `OR` or an `AND` rule.
         17:44 channel = ponce ORdog != 'bernese mountain'
         "###);
 
-        insta::assert_display_snapshot!(p("colour IN blue, green]"), @r###"
+        insta::assert_snapshot!(p("colour IN blue, green]"), @r###"
         Expected `[` after `IN` keyword.
         11:23 colour IN blue, green]
         "###);
 
-        insta::assert_display_snapshot!(p("colour IN [blue, green, 'blue' > 2]"), @r###"
+        insta::assert_snapshot!(p("colour IN [blue, green, 'blue' > 2]"), @r###"
         Expected only comma-separated field names inside `IN[..]` but instead found `> 2]`.
         32:36 colour IN [blue, green, 'blue' > 2]
         "###);
 
-        insta::assert_display_snapshot!(p("colour IN [blue, green, AND]"), @r###"
+        insta::assert_snapshot!(p("colour IN [blue, green, AND]"), @r###"
         Expected only comma-separated field names inside `IN[..]` but instead found `AND]`.
         25:29 colour IN [blue, green, AND]
         "###);
 
-        insta::assert_display_snapshot!(p("colour IN [blue, green"), @r###"
+        insta::assert_snapshot!(p("colour IN [blue, green"), @r###"
         Expected matching `]` after the list of field names given to `IN[`
         23:23 colour IN [blue, green
         "###);
 
-        insta::assert_display_snapshot!(p("colour IN ['blue, green"), @r###"
+        insta::assert_snapshot!(p("colour IN ['blue, green"), @r###"
         Expression `\'blue, green` is missing the following closing delimiter: `'`.
         12:24 colour IN ['blue, green
         "###);
 
-        insta::assert_display_snapshot!(p("x = EXISTS"), @r###"
+        insta::assert_snapshot!(p("x = EXISTS"), @r###"
         Was expecting a value but instead got `EXISTS`, which is a reserved keyword. To use `EXISTS` as a field name or a value, surround it by quotes.
         5:11 x = EXISTS
         "###);
 
-        insta::assert_display_snapshot!(p("AND = 8"), @r###"
+        insta::assert_snapshot!(p("AND = 8"), @r###"
         Was expecting a value but instead got `AND`, which is a reserved keyword. To use `AND` as a field name or a value, surround it by quotes.
         1:4 AND = 8
         "###);
 
-        insta::assert_display_snapshot!(p("((((((((((((((((((((((((((((((((((((((((((((((((((x = 1))))))))))))))))))))))))))))))))))))))))))))))))))"), @r###"
+        insta::assert_snapshot!(p("((((((((((((((((((((((((((((((((((((((((((((((((((x = 1))))))))))))))))))))))))))))))))))))))))))))))))))"), @r###"
         The filter exceeded the maximum depth limit. Try rewriting the filter so that it contains fewer nested conditions.
         51:106 ((((((((((((((((((((((((((((((((((((((((((((((((((x = 1))))))))))))))))))))))))))))))))))))))))))))))))))
         "###);
 
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(
             p("NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT NOT x = 1"),
             @r###"
         The filter exceeded the maximum depth limit. Try rewriting the filter so that it contains fewer nested conditions.
@@ -872,40 +872,40 @@ pub mod tests {
         "###
         );
 
-        insta::assert_display_snapshot!(p(r#"NOT OR EXISTS AND EXISTS NOT EXISTS"#), @r###"
+        insta::assert_snapshot!(p(r#"NOT OR EXISTS AND EXISTS NOT EXISTS"#), @r###"
         Was expecting a value but instead got `OR`, which is a reserved keyword. To use `OR` as a field name or a value, surround it by quotes.
         5:7 NOT OR EXISTS AND EXISTS NOT EXISTS
         "###);
 
-        insta::assert_display_snapshot!(p(r#"value NULL"#), @r###"
+        insta::assert_snapshot!(p(r#"value NULL"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value NULL`.
         1:11 value NULL
         "###);
-        insta::assert_display_snapshot!(p(r#"value NOT NULL"#), @r###"
+        insta::assert_snapshot!(p(r#"value NOT NULL"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value NOT NULL`.
         1:15 value NOT NULL
         "###);
-        insta::assert_display_snapshot!(p(r#"value EMPTY"#), @r###"
+        insta::assert_snapshot!(p(r#"value EMPTY"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value EMPTY`.
         1:12 value EMPTY
         "###);
-        insta::assert_display_snapshot!(p(r#"value NOT EMPTY"#), @r###"
+        insta::assert_snapshot!(p(r#"value NOT EMPTY"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value NOT EMPTY`.
         1:16 value NOT EMPTY
         "###);
-        insta::assert_display_snapshot!(p(r#"value IS"#), @r###"
+        insta::assert_snapshot!(p(r#"value IS"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value IS`.
         1:9 value IS
         "###);
-        insta::assert_display_snapshot!(p(r#"value IS NOT"#), @r###"
+        insta::assert_snapshot!(p(r#"value IS NOT"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value IS NOT`.
         1:13 value IS NOT
         "###);
-        insta::assert_display_snapshot!(p(r#"value IS EXISTS"#), @r###"
+        insta::assert_snapshot!(p(r#"value IS EXISTS"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value IS EXISTS`.
         1:16 value IS EXISTS
         "###);
-        insta::assert_display_snapshot!(p(r#"value IS NOT EXISTS"#), @r###"
+        insta::assert_snapshot!(p(r#"value IS NOT EXISTS"#), @r###"
         Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `_geoRadius`, or `_geoBoundingBox` at `value IS NOT EXISTS`.
         1:20 value IS NOT EXISTS
         "###);

fuzzers/Cargo.toml

@@ -12,9 +12,9 @@ license.workspace = true
 
 [dependencies]
 arbitrary = { version = "1.3.2", features = ["derive"] }
-clap = { version = "4.4.17", features = ["derive"] }
-fastrand = "2.0.1"
+clap = { version = "4.5.9", features = ["derive"] }
+fastrand = "2.1.0"
 milli = { path = "../milli" }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
-tempfile = "3.9.0"
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
+tempfile = "3.10.1"

index-scheduler/Cargo.toml

@@ -11,38 +11,38 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-anyhow = "1.0.79"
+anyhow = "1.0.86"
 bincode = "1.3.3"
 csv = "1.3.0"
-derive_builder = "0.12.0"
+derive_builder = "0.20.0"
 dump = { path = "../dump" }
-enum-iterator = "1.5.0"
+enum-iterator = "2.1.0"
 file-store = { path = "../file-store" }
-flate2 = "1.0.28"
+flate2 = "1.0.30"
 meilisearch-auth = { path = "../meilisearch-auth" }
 meilisearch-types = { path = "../meilisearch-types" }
-page_size = "0.5.0"
-rayon = "1.8.1"
-roaring = { version = "0.10.2", features = ["serde"] }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
+page_size = "0.6.0"
+rayon = "1.10.0"
+roaring = { version = "0.10.6", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
 synchronoise = "1.0.1"
-tempfile = "3.9.0"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = [
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = [
     "serde-well-known",
     "formatting",
     "parsing",
     "macros",
 ] }
 tracing = "0.1.40"
-ureq = "2.9.7"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
+ureq = "2.10.0"
+uuid = { version = "1.10.0", features = ["serde", "v4"] }
 
 [dev-dependencies]
 arroy = "0.4.0"
 big_s = "1.0.2"
 crossbeam = "0.8.4"
-insta = { version = "1.34.0", features = ["json", "redactions"] }
+insta = { version = "1.39.0", features = ["json", "redactions"] }
 maplit = "1.0.2"
 meili-snap = { path = "../meili-snap" }

index-scheduler/src/autobatcher.rs

@@ -24,6 +24,7 @@ enum AutobatchKind {
         allow_index_creation: bool,
         primary_key: Option<String>,
     },
+    DocumentEdition,
     DocumentDeletion,
     DocumentDeletionByFilter,
     DocumentClear,
@@ -63,6 +64,7 @@ impl From<KindWithContent> for AutobatchKind {
                 primary_key,
                 ..
             } => AutobatchKind::DocumentImport { method, allow_index_creation, primary_key },
+            KindWithContent::DocumentEdition { .. } => AutobatchKind::DocumentEdition,
             KindWithContent::DocumentDeletion { .. } => AutobatchKind::DocumentDeletion,
             KindWithContent::DocumentClear { .. } => AutobatchKind::DocumentClear,
             KindWithContent::DocumentDeletionByFilter { .. } => {
@@ -98,6 +100,9 @@ pub enum BatchKind {
         primary_key: Option<String>,
         operation_ids: Vec<TaskId>,
     },
+    DocumentEdition {
+        id: TaskId,
+    },
     DocumentDeletion {
         deletion_ids: Vec<TaskId>,
     },
@@ -199,6 +204,7 @@ impl BatchKind {
                 }),
                 allow_index_creation,
             ),
+            K::DocumentEdition => (Break(BatchKind::DocumentEdition { id: task_id }), false),
             K::DocumentDeletion => {
                 (Continue(BatchKind::DocumentDeletion { deletion_ids: vec![task_id] }), false)
             }
@@ -222,7 +228,7 @@ impl BatchKind {
 
         match (self, kind) {
             // We don't batch any of these operations
-            (this, K::IndexCreation | K::IndexUpdate | K::IndexSwap | K::DocumentDeletionByFilter) => Break(this),
+            (this, K::IndexCreation | K::IndexUpdate | K::IndexSwap | K::DocumentEdition | K::DocumentDeletionByFilter) => Break(this),
             // We must not batch tasks that don't have the same index creation rights if the index doesn't already exists.
             (this, kind) if !index_already_exists && this.allow_index_creation() == Some(false) && kind.allow_index_creation() == Some(true) => {
                 Break(this)
@@ -519,6 +525,7 @@ impl BatchKind {
                 | BatchKind::IndexDeletion { .. }
                 | BatchKind::IndexUpdate { .. }
                 | BatchKind::IndexSwap { .. }
+                | BatchKind::DocumentEdition { .. }
                 | BatchKind::DocumentDeletionByFilter { .. },
                 _,
             ) => {

index-scheduler/src/batch.rs

@@ -34,7 +34,7 @@ use meilisearch_types::milli::update::{
 use meilisearch_types::milli::vector::parsed_vectors::{
     ExplicitVectors, VectorOrArrayOfVectors, RESERVED_VECTORS_FIELD_NAME,
 };
-use meilisearch_types::milli::{self, Filter};
+use meilisearch_types::milli::{self, Filter, Object};
 use meilisearch_types::settings::{apply_settings_to_builder, Settings, Unchecked};
 use meilisearch_types::tasks::{Details, IndexSwap, Kind, KindWithContent, Status, Task};
 use meilisearch_types::{compression, Index, VERSION_FILE_NAME};
@@ -106,6 +106,10 @@ pub(crate) enum IndexOperation {
         operations: Vec<DocumentOperation>,
         tasks: Vec<Task>,
     },
+    DocumentEdition {
+        index_uid: String,
+        task: Task,
+    },
     IndexDocumentDeletionByFilter {
         index_uid: String,
         task: Task,
@@ -164,7 +168,8 @@ impl Batch {
                 | IndexOperation::DocumentClear { tasks, .. } => {
                     RoaringBitmap::from_iter(tasks.iter().map(|task| task.uid))
                 }
-                IndexOperation::IndexDocumentDeletionByFilter { task, .. } => {
+                IndexOperation::DocumentEdition { task, .. }
+                | IndexOperation::IndexDocumentDeletionByFilter { task, .. } => {
                     RoaringBitmap::from_sorted_iter(std::iter::once(task.uid)).unwrap()
                 }
                 IndexOperation::SettingsAndDocumentOperation {
@@ -228,6 +233,7 @@ impl IndexOperation {
     pub fn index_uid(&self) -> &str {
         match self {
             IndexOperation::DocumentOperation { index_uid, .. }
+            | IndexOperation::DocumentEdition { index_uid, .. }
             | IndexOperation::IndexDocumentDeletionByFilter { index_uid, .. }
             | IndexOperation::DocumentClear { index_uid, .. }
             | IndexOperation::Settings { index_uid, .. }
@@ -243,6 +249,9 @@ impl fmt::Display for IndexOperation {
             IndexOperation::DocumentOperation { .. } => {
                 f.write_str("IndexOperation::DocumentOperation")
             }
+            IndexOperation::DocumentEdition { .. } => {
+                f.write_str("IndexOperation::DocumentEdition")
+            }
             IndexOperation::IndexDocumentDeletionByFilter { .. } => {
                 f.write_str("IndexOperation::IndexDocumentDeletionByFilter")
             }
@@ -295,6 +304,21 @@ impl IndexScheduler {
                     _ => unreachable!(),
                 }
             }
+            BatchKind::DocumentEdition { id } => {
+                let task = self.get_task(rtxn, id)?.ok_or(Error::CorruptedTaskQueue)?;
+                match &task.kind {
+                    KindWithContent::DocumentEdition { index_uid, .. } => {
+                        Ok(Some(Batch::IndexOperation {
+                            op: IndexOperation::DocumentEdition {
+                                index_uid: index_uid.clone(),
+                                task,
+                            },
+                            must_create_index: false,
+                        }))
+                    }
+                    _ => unreachable!(),
+                }
+            }
             BatchKind::DocumentOperation { method, operation_ids, .. } => {
                 let tasks = self.get_existing_tasks(rtxn, operation_ids)?;
                 let primary_key = tasks
@@ -1386,6 +1410,64 @@ impl IndexScheduler {
 
                 Ok(tasks)
             }
+            IndexOperation::DocumentEdition { mut task, .. } => {
+                let (filter, context, function) =
+                    if let KindWithContent::DocumentEdition {
+                        filter_expr, context, function, ..
+                    } = &task.kind
+                    {
+                        (filter_expr, context, function)
+                    } else {
+                        unreachable!()
+                    };
+                let result_count = edit_documents_by_function(
+                    index_wtxn,
+                    filter,
+                    context.clone(),
+                    function,
+                    self.index_mapper.indexer_config(),
+                    self.must_stop_processing.clone(),
+                    index,
+                );
+                let (original_filter, context, function) = if let Some(Details::DocumentEdition {
+                    original_filter,
+                    context,
+                    function,
+                    ..
+                }) = task.details
+                {
+                    (original_filter, context, function)
+                } else {
+                    // In the case of a `documentDeleteByFilter` the details MUST be set
+                    unreachable!();
+                };
+
+                match result_count {
+                    Ok((deleted_documents, edited_documents)) => {
+                        task.status = Status::Succeeded;
+                        task.details = Some(Details::DocumentEdition {
+                            original_filter,
+                            context,
+                            function,
+                            deleted_documents: Some(deleted_documents),
+                            edited_documents: Some(edited_documents),
+                        });
+                    }
+                    Err(e) => {
+                        task.status = Status::Failed;
+                        task.details = Some(Details::DocumentEdition {
+                            original_filter,
+                            context,
+                            function,
+                            deleted_documents: Some(0),
+                            edited_documents: Some(0),
+                        });
+                        task.error = Some(e.into());
+                    }
+                }
+
+                Ok(vec![task])
+            }
             IndexOperation::IndexDocumentDeletionByFilter { mut task, index_uid: _ } => {
                 let filter =
                     if let KindWithContent::DocumentDeletionByFilter { filter_expr, .. } =
@@ -1674,3 +1756,44 @@ fn delete_document_by_filter<'a>(
         0
     })
 }
+
+fn edit_documents_by_function<'a>(
+    wtxn: &mut RwTxn<'a>,
+    filter: &Option<serde_json::Value>,
+    context: Option<Object>,
+    code: &str,
+    indexer_config: &IndexerConfig,
+    must_stop_processing: MustStopProcessing,
+    index: &'a Index,
+) -> Result<(u64, u64)> {
+    let candidates = match filter.as_ref().map(Filter::from_json) {
+        Some(Ok(Some(filter))) => filter.evaluate(wtxn, index).map_err(|err| match err {
+            milli::Error::UserError(milli::UserError::InvalidFilter(_)) => {
+                Error::from(err).with_custom_error_code(Code::InvalidDocumentFilter)
+            }
+            e => e.into(),
+        })?,
+        None | Some(Ok(None)) => index.documents_ids(wtxn)?,
+        Some(Err(e)) => return Err(e.into()),
+    };
+
+    let config = IndexDocumentsConfig {
+        update_method: IndexDocumentsMethod::ReplaceDocuments,
+        ..Default::default()
+    };
+
+    let mut builder = milli::update::IndexDocuments::new(
+        wtxn,
+        index,
+        indexer_config,
+        config,
+        |indexing_step| tracing::debug!(update = ?indexing_step),
+        || must_stop_processing.get(),
+    )?;
+
+    let (new_builder, count) = builder.edit_documents(&candidates, context, code)?;
+    builder = new_builder;
+
+    let _ = builder.execute()?;
+    Ok(count.unwrap())
+}

index-scheduler/src/features.rs

@@ -68,6 +68,19 @@ impl RoFeatures {
             .into())
         }
     }
+
+    pub fn check_edit_documents_by_function(&self, disabled_action: &'static str) -> Result<()> {
+        if self.runtime.edit_documents_by_function {
+            Ok(())
+        } else {
+            Err(FeatureNotEnabledError {
+                disabled_action,
+                feature: "edit documents by function",
+                issue_link: "https://github.com/orgs/meilisearch/discussions/762",
+            }
+            .into())
+        }
+    }
 }
 
 impl FeatureData {

index-scheduler/src/insta_snapshot.rs

@@ -177,6 +177,17 @@ fn snapshot_details(d: &Details) -> String {
         } => {
             format!("{{ received_documents: {received_documents}, indexed_documents: {indexed_documents:?} }}")
         }
+        Details::DocumentEdition {
+            deleted_documents,
+            edited_documents,
+            original_filter,
+            context,
+            function,
+        } => {
+            format!(
+                "{{ deleted_documents: {deleted_documents:?}, edited_documents: {edited_documents:?}, context: {context:?}, function: {function:?}, original_filter: {original_filter:?} }}"
+            )
+        }
         Details::SettingsUpdate { settings } => {
             format!("{{ settings: {settings:?} }}")
         }

index-scheduler/src/lib.rs

@@ -1603,6 +1603,14 @@ impl<'a> Dump<'a> {
                         index_uid: task.index_uid.ok_or(Error::CorruptedDump)?,
                     }
                 }
+                KindDump::DocumentEdition { filter, context, function } => {
+                    KindWithContent::DocumentEdition {
+                        index_uid: task.index_uid.ok_or(Error::CorruptedDump)?,
+                        filter_expr: filter,
+                        context,
+                        function,
+                    }
+                }
                 KindDump::DocumentClear => KindWithContent::DocumentClear {
                     index_uid: task.index_uid.ok_or(Error::CorruptedDump)?,
                 },
@@ -4744,6 +4752,7 @@ mod tests {
           "types": {
             "documentAdditionOrUpdate": 0,
             "documentDeletion": 0,
+            "documentEdition": 0,
             "dumpCreation": 0,
             "indexCreation": 3,
             "indexDeletion": 0,
@@ -4775,6 +4784,7 @@ mod tests {
           "types": {
             "documentAdditionOrUpdate": 0,
             "documentDeletion": 0,
+            "documentEdition": 0,
             "dumpCreation": 0,
             "indexCreation": 3,
             "indexDeletion": 0,
@@ -4813,6 +4823,7 @@ mod tests {
           "types": {
             "documentAdditionOrUpdate": 0,
             "documentDeletion": 0,
+            "documentEdition": 0,
             "dumpCreation": 0,
             "indexCreation": 3,
             "indexDeletion": 0,
@@ -4852,6 +4863,7 @@ mod tests {
           "types": {
             "documentAdditionOrUpdate": 0,
             "documentDeletion": 0,
+            "documentEdition": 0,
             "dumpCreation": 0,
             "indexCreation": 3,
             "indexDeletion": 0,

index-scheduler/src/utils.rs

@@ -238,6 +238,7 @@ pub fn swap_index_uid_in_task(task: &mut Task, swap: (&str, &str)) {
     let mut index_uids = vec![];
     match &mut task.kind {
         K::DocumentAdditionOrUpdate { index_uid, .. } => index_uids.push(index_uid),
+        K::DocumentEdition { index_uid, .. } => index_uids.push(index_uid),
         K::DocumentDeletion { index_uid, .. } => index_uids.push(index_uid),
         K::DocumentDeletionByFilter { index_uid, .. } => index_uids.push(index_uid),
         K::DocumentClear { index_uid } => index_uids.push(index_uid),
@@ -408,7 +409,26 @@ impl IndexScheduler {
                                 match status {
                                     Status::Succeeded => assert!(indexed_documents <= received_documents),
                                     Status::Failed | Status::Canceled => assert_eq!(indexed_documents, 0),
-                                    status => panic!("DocumentAddition can't have an indexed_document set if it's {}", status),
+                                    status => panic!("DocumentAddition can't have an indexed_documents set if it's {}", status),
+                                }
+                            }
+                            None => {
+                                assert!(matches!(status, Status::Enqueued | Status::Processing))
+                            }
+                        }
+                    }
+                    Details::DocumentEdition { edited_documents, .. } => {
+                        assert_eq!(kind.as_kind(), Kind::DocumentEdition);
+                        match edited_documents {
+                            Some(edited_documents) => {
+                                assert!(matches!(
+                                    status,
+                                    Status::Succeeded | Status::Failed | Status::Canceled
+                                ));
+                                match status {
+                                    Status::Succeeded => (),
+                                    Status::Failed | Status::Canceled => assert_eq!(edited_documents, 0),
+                                    status => panic!("DocumentEdition can't have an edited_documents set if it's {}", status),
                                 }
                             }
                             None => {

meili-snap/Cargo.toml

@@ -11,6 +11,6 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-insta = { version = "^1.34.0", features = ["json", "redactions"] }
+insta = { version = "^1.39.0", features = ["json", "redactions"] }
 md5 = "0.7.0"
 once_cell = "1.19"

meilisearch-auth/Cargo.toml

@@ -11,16 +11,16 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-base64 = "0.21.7"
-enum-iterator = "1.5.0"
+base64 = "0.22.1"
+enum-iterator = "2.1.0"
 hmac = "0.12.1"
 maplit = "1.0.2"
 meilisearch-types = { path = "../meilisearch-types" }
 rand = "0.8.5"
-roaring = { version = "0.10.2", features = ["serde"] }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
+roaring = { version = "0.10.6", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
 sha2 = "0.10.8"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = ["serde-well-known", "formatting", "parsing", "macros"] }
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = ["serde-well-known", "formatting", "parsing", "macros"] }
+uuid = { version = "1.10.0", features = ["serde", "v4"] }

meilisearch-types/Cargo.toml

@@ -11,36 +11,36 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-actix-web = { version = "4.6.0", default-features = false }
-anyhow = "1.0.79"
+actix-web = { version = "4.8.0", default-features = false }
+anyhow = "1.0.86"
 convert_case = "0.6.0"
 csv = "1.3.0"
-deserr = { version = "0.6.1", features = ["actix-web"] }
-either = { version = "1.9.0", features = ["serde"] }
-enum-iterator = "1.5.0"
+deserr = { version = "0.6.2", features = ["actix-web"] }
+either = { version = "1.13.0", features = ["serde"] }
+enum-iterator = "2.1.0"
 file-store = { path = "../file-store" }
-flate2 = "1.0.28"
+flate2 = "1.0.30"
 fst = "0.4.7"
-memmap2 = "0.7.1"
+memmap2 = "0.9.4"
 milli = { path = "../milli" }
-roaring = { version = "0.10.2", features = ["serde"] }
-serde = { version = "1.0.195", features = ["derive"] }
+roaring = { version = "0.10.6", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
 serde-cs = "0.2.4"
-serde_json = "1.0.111"
-tar = "0.4.40"
-tempfile = "3.9.0"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = [
+serde_json = "1.0.120"
+tar = "0.4.41"
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = [
     "serde-well-known",
     "formatting",
     "parsing",
     "macros",
 ] }
-tokio = "1.35"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
+tokio = "1.38"
+uuid = { version = "1.10.0", features = ["serde", "v4"] }
 
 [dev-dependencies]
-insta = "1.34.0"
+insta = "1.39.0"
 meili-snap = { path = "../meili-snap" }
 
 [features]

meilisearch-types/src/deserr/mod.rs

@@ -155,6 +155,10 @@ make_missing_field_convenience_builder!(
     MissingFacetSearchFacetName,
     missing_facet_search_facet_name
 );
+make_missing_field_convenience_builder!(
+    MissingDocumentEditionFunction,
+    missing_document_edition_function
+);
 
 // Integrate a sub-error into a [`DeserrError`] by taking its error message but using
 // the default error code (C) from `Self`
@@ -188,6 +192,7 @@ merge_with_error_impl_take_error_message!(ParseOffsetDateTimeError);
 merge_with_error_impl_take_error_message!(ParseTaskKindError);
 merge_with_error_impl_take_error_message!(ParseTaskStatusError);
 merge_with_error_impl_take_error_message!(IndexUidFormatError);
+merge_with_error_impl_take_error_message!(InvalidMultiSearchWeight);
 merge_with_error_impl_take_error_message!(InvalidSearchSemanticRatio);
 merge_with_error_impl_take_error_message!(InvalidSearchRankingScoreThreshold);
 merge_with_error_impl_take_error_message!(InvalidSimilarRankingScoreThreshold);

meilisearch-types/src/error.rs

@@ -224,6 +224,7 @@ InvalidDocumentCsvDelimiter           , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentFields                 , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentRetrieveVectors        , InvalidRequest       , BAD_REQUEST ;
 MissingDocumentFilter                 , InvalidRequest       , BAD_REQUEST ;
+MissingDocumentEditionFunction        , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentFilter                 , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentGeoField               , InvalidRequest       , BAD_REQUEST ;
 InvalidVectorDimensions               , InvalidRequest       , BAD_REQUEST ;
@@ -237,6 +238,11 @@ InvalidIndexLimit                     , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexOffset                    , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexPrimaryKey                , InvalidRequest       , BAD_REQUEST ;
 InvalidIndexUid                       , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFederated           , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchFederationOptions   , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchQueryPagination     , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchQueryRankingRules   , InvalidRequest       , BAD_REQUEST ;
+InvalidMultiSearchWeight              , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToSearchOn     , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToCrop         , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchAttributesToHighlight    , InvalidRequest       , BAD_REQUEST ;
@@ -336,7 +342,10 @@ UnsupportedMediaType                  , InvalidRequest       , UNSUPPORTED_MEDIA
 
 // Experimental features
 VectorEmbeddingError                  , InvalidRequest       , BAD_REQUEST ;
-NotFoundSimilarId                     , InvalidRequest       , BAD_REQUEST
+NotFoundSimilarId                     , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentEditionContext         , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentEditionFunctionFilter  , InvalidRequest       , BAD_REQUEST ;
+EditDocumentsByFunctionError          , InvalidRequest       , BAD_REQUEST
 }
 
 impl ErrorCode for JoinError {
@@ -407,6 +416,12 @@ impl ErrorCode for milli::Error {
                     }
                     UserError::InvalidEmbedder(_) => Code::InvalidEmbedder,
                     UserError::VectorEmbeddingError(_) => Code::VectorEmbeddingError,
+                    UserError::DocumentEditionCannotModifyPrimaryKey
+                    | UserError::DocumentEditionDocumentMustBeObject
+                    | UserError::DocumentEditionRuntimeError(_)
+                    | UserError::DocumentEditionCompilationError(_) => {
+                        Code::EditDocumentsByFunctionError
+                    }
                 }
             }
         }
@@ -502,6 +517,12 @@ impl fmt::Display for deserr_codes::InvalidSearchSemanticRatio {
     }
 }
 
+impl fmt::Display for deserr_codes::InvalidMultiSearchWeight {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "the value of `weight` is invalid, expected a positive float (>= 0.0).")
+    }
+}
+
 impl fmt::Display for deserr_codes::InvalidSimilarId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(

meilisearch-types/src/features.rs

@@ -6,6 +6,7 @@ pub struct RuntimeTogglableFeatures {
     pub vector_store: bool,
     pub metrics: bool,
     pub logs_route: bool,
+    pub edit_documents_by_function: bool,
 }
 
 #[derive(Default, Debug, Clone, Copy)]

meilisearch-types/src/task_view.rs

@@ -1,3 +1,4 @@
+use milli::Object;
 use serde::Serialize;
 use time::{Duration, OffsetDateTime};
 
@@ -54,6 +55,8 @@ pub struct DetailsView {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub indexed_documents: Option<Option<u64>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub edited_documents: Option<Option<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub primary_key: Option<Option<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub provided_ids: Option<usize>,
@@ -70,6 +73,10 @@ pub struct DetailsView {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub dump_uid: Option<Option<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub context: Option<Option<Object>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub function: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(flatten)]
     pub settings: Option<Box<Settings<Unchecked>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -86,6 +93,20 @@ impl From<Details> for DetailsView {
                     ..DetailsView::default()
                 }
             }
+            Details::DocumentEdition {
+                deleted_documents,
+                edited_documents,
+                original_filter,
+                context,
+                function,
+            } => DetailsView {
+                deleted_documents: Some(deleted_documents),
+                edited_documents: Some(edited_documents),
+                original_filter: Some(original_filter),
+                context: Some(context),
+                function: Some(function),
+                ..DetailsView::default()
+            },
             Details::SettingsUpdate { mut settings } => {
                 settings.hide_secrets();
                 DetailsView { settings: Some(settings), ..DetailsView::default() }

meilisearch-types/src/tasks.rs

@@ -5,6 +5,7 @@ use std::str::FromStr;
 
 use enum_iterator::Sequence;
 use milli::update::IndexDocumentsMethod;
+use milli::Object;
 use roaring::RoaringBitmap;
 use serde::{Deserialize, Serialize, Serializer};
 use time::{Duration, OffsetDateTime};
@@ -48,6 +49,7 @@ impl Task {
             | TaskDeletion { .. }
             | IndexSwap { .. } => None,
             DocumentAdditionOrUpdate { index_uid, .. }
+            | DocumentEdition { index_uid, .. }
             | DocumentDeletion { index_uid, .. }
             | DocumentDeletionByFilter { index_uid, .. }
             | DocumentClear { index_uid }
@@ -67,7 +69,8 @@ impl Task {
     pub fn content_uuid(&self) -> Option<Uuid> {
         match self.kind {
             KindWithContent::DocumentAdditionOrUpdate { content_file, .. } => Some(content_file),
-            KindWithContent::DocumentDeletion { .. }
+            KindWithContent::DocumentEdition { .. }
+            | KindWithContent::DocumentDeletion { .. }
             | KindWithContent::DocumentDeletionByFilter { .. }
             | KindWithContent::DocumentClear { .. }
             | KindWithContent::SettingsUpdate { .. }
@@ -102,6 +105,12 @@ pub enum KindWithContent {
         index_uid: String,
         filter_expr: serde_json::Value,
     },
+    DocumentEdition {
+        index_uid: String,
+        filter_expr: Option<serde_json::Value>,
+        context: Option<milli::Object>,
+        function: String,
+    },
     DocumentClear {
         index_uid: String,
     },
@@ -150,6 +159,7 @@ impl KindWithContent {
     pub fn as_kind(&self) -> Kind {
         match self {
             KindWithContent::DocumentAdditionOrUpdate { .. } => Kind::DocumentAdditionOrUpdate,
+            KindWithContent::DocumentEdition { .. } => Kind::DocumentEdition,
             KindWithContent::DocumentDeletion { .. } => Kind::DocumentDeletion,
             KindWithContent::DocumentDeletionByFilter { .. } => Kind::DocumentDeletion,
             KindWithContent::DocumentClear { .. } => Kind::DocumentDeletion,
@@ -174,6 +184,7 @@ impl KindWithContent {
             | TaskCancelation { .. }
             | TaskDeletion { .. } => vec![],
             DocumentAdditionOrUpdate { index_uid, .. }
+            | DocumentEdition { index_uid, .. }
             | DocumentDeletion { index_uid, .. }
             | DocumentDeletionByFilter { index_uid, .. }
             | DocumentClear { index_uid }
@@ -202,6 +213,15 @@ impl KindWithContent {
                     indexed_documents: None,
                 })
             }
+            KindWithContent::DocumentEdition { index_uid: _, filter_expr, context, function } => {
+                Some(Details::DocumentEdition {
+                    deleted_documents: None,
+                    edited_documents: None,
+                    original_filter: filter_expr.as_ref().map(|v| v.to_string()),
+                    context: context.clone(),
+                    function: function.clone(),
+                })
+            }
             KindWithContent::DocumentDeletion { index_uid: _, documents_ids } => {
                 Some(Details::DocumentDeletion {
                     provided_ids: documents_ids.len(),
@@ -250,6 +270,15 @@ impl KindWithContent {
                     indexed_documents: Some(0),
                 })
             }
+            KindWithContent::DocumentEdition { index_uid: _, filter_expr, context, function } => {
+                Some(Details::DocumentEdition {
+                    deleted_documents: Some(0),
+                    edited_documents: Some(0),
+                    original_filter: filter_expr.as_ref().map(|v| v.to_string()),
+                    context: context.clone(),
+                    function: function.clone(),
+                })
+            }
             KindWithContent::DocumentDeletion { index_uid: _, documents_ids } => {
                 Some(Details::DocumentDeletion {
                     provided_ids: documents_ids.len(),
@@ -301,6 +330,7 @@ impl From<&KindWithContent> for Option<Details> {
                     indexed_documents: None,
                 })
             }
+            KindWithContent::DocumentEdition { .. } => None,
             KindWithContent::DocumentDeletion { .. } => None,
             KindWithContent::DocumentDeletionByFilter { .. } => None,
             KindWithContent::DocumentClear { .. } => None,
@@ -394,6 +424,7 @@ impl std::error::Error for ParseTaskStatusError {}
 #[serde(rename_all = "camelCase")]
 pub enum Kind {
     DocumentAdditionOrUpdate,
+    DocumentEdition,
     DocumentDeletion,
     SettingsUpdate,
     IndexCreation,
@@ -410,6 +441,7 @@ impl Kind {
     pub fn related_to_one_index(&self) -> bool {
         match self {
             Kind::DocumentAdditionOrUpdate
+            | Kind::DocumentEdition
             | Kind::DocumentDeletion
             | Kind::SettingsUpdate
             | Kind::IndexCreation
@@ -427,6 +459,7 @@ impl Display for Kind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Kind::DocumentAdditionOrUpdate => write!(f, "documentAdditionOrUpdate"),
+            Kind::DocumentEdition => write!(f, "documentEdition"),
             Kind::DocumentDeletion => write!(f, "documentDeletion"),
             Kind::SettingsUpdate => write!(f, "settingsUpdate"),
             Kind::IndexCreation => write!(f, "indexCreation"),
@@ -454,6 +487,8 @@ impl FromStr for Kind {
             Ok(Kind::IndexDeletion)
         } else if kind.eq_ignore_ascii_case("documentAdditionOrUpdate") {
             Ok(Kind::DocumentAdditionOrUpdate)
+        } else if kind.eq_ignore_ascii_case("documentEdition") {
+            Ok(Kind::DocumentEdition)
         } else if kind.eq_ignore_ascii_case("documentDeletion") {
             Ok(Kind::DocumentDeletion)
         } else if kind.eq_ignore_ascii_case("settingsUpdate") {
@@ -495,16 +530,50 @@ impl std::error::Error for ParseTaskKindError {}
 
 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub enum Details {
-    DocumentAdditionOrUpdate { received_documents: u64, indexed_documents: Option<u64> },
-    SettingsUpdate { settings: Box<Settings<Unchecked>> },
-    IndexInfo { primary_key: Option<String> },
-    DocumentDeletion { provided_ids: usize, deleted_documents: Option<u64> },
-    DocumentDeletionByFilter { original_filter: String, deleted_documents: Option<u64> },
-    ClearAll { deleted_documents: Option<u64> },
-    TaskCancelation { matched_tasks: u64, canceled_tasks: Option<u64>, original_filter: String },
-    TaskDeletion { matched_tasks: u64, deleted_tasks: Option<u64>, original_filter: String },
-    Dump { dump_uid: Option<String> },
-    IndexSwap { swaps: Vec<IndexSwap> },
+    DocumentAdditionOrUpdate {
+        received_documents: u64,
+        indexed_documents: Option<u64>,
+    },
+    SettingsUpdate {
+        settings: Box<Settings<Unchecked>>,
+    },
+    IndexInfo {
+        primary_key: Option<String>,
+    },
+    DocumentDeletion {
+        provided_ids: usize,
+        deleted_documents: Option<u64>,
+    },
+    DocumentDeletionByFilter {
+        original_filter: String,
+        deleted_documents: Option<u64>,
+    },
+    DocumentEdition {
+        deleted_documents: Option<u64>,
+        edited_documents: Option<u64>,
+        original_filter: Option<String>,
+        context: Option<Object>,
+        function: String,
+    },
+    ClearAll {
+        deleted_documents: Option<u64>,
+    },
+    TaskCancelation {
+        matched_tasks: u64,
+        canceled_tasks: Option<u64>,
+        original_filter: String,
+    },
+    TaskDeletion {
+        matched_tasks: u64,
+        deleted_tasks: Option<u64>,
+        original_filter: String,
+    },
+    Dump {
+        dump_uid: Option<String>,
+    },
+    IndexSwap {
+        swaps: Vec<IndexSwap>,
+    },
 }
 
 impl Details {
@@ -514,6 +583,7 @@ impl Details {
             Self::DocumentAdditionOrUpdate { indexed_documents, .. } => {
                 *indexed_documents = Some(0)
             }
+            Self::DocumentEdition { edited_documents, .. } => *edited_documents = Some(0),
             Self::DocumentDeletion { deleted_documents, .. } => *deleted_documents = Some(0),
             Self::DocumentDeletionByFilter { deleted_documents, .. } => {
                 *deleted_documents = Some(0)

meilisearch/Cargo.toml

@@ -14,104 +14,100 @@ default-run = "meilisearch"
 
 [dependencies]
 actix-cors = "0.7.0"
-actix-http = { version = "3.7.0", default-features = false, features = [
+actix-http = { version = "3.8.0", default-features = false, features = [
     "compress-brotli",
     "compress-gzip",
     "rustls-0_21",
 ] }
 actix-utils = "3.0.1"
-actix-web = { version = "4.6.0", default-features = false, features = [
+actix-web = { version = "4.8.0", default-features = false, features = [
     "macros",
     "compress-brotli",
     "compress-gzip",
     "cookies",
     "rustls-0_21",
 ] }
-actix-web-static-files = { version = "4.0.1", optional = true }
-anyhow = { version = "1.0.79", features = ["backtrace"] }
-async-stream = "0.3.5"
-async-trait = "0.1.77"
-bstr = "1.9.0"
-byte-unit = { version = "4.0.19", default-features = false, features = [
+anyhow = { version = "1.0.86", features = ["backtrace"] }
+async-trait = "0.1.81"
+bstr = "1.9.1"
+byte-unit = { version = "5.1.4", default-features = false, features = [
     "std",
+    "byte",
     "serde",
 ] }
-bytes = "1.5.0"
-clap = { version = "4.4.17", features = ["derive", "env"] }
-crossbeam-channel = "0.5.11"
-deserr = { version = "0.6.1", features = ["actix-web"] }
+bytes = "1.6.0"
+clap = { version = "4.5.9", features = ["derive", "env"] }
+crossbeam-channel = "0.5.13"
+deserr = { version = "0.6.2", features = ["actix-web"] }
 dump = { path = "../dump" }
-either = "1.9.0"
+either = "1.13.0"
 file-store = { path = "../file-store" }
-flate2 = "1.0.28"
+flate2 = "1.0.30"
 fst = "0.4.7"
 futures = "0.3.30"
 futures-util = "0.3.30"
-http = "0.2.11"
 index-scheduler = { path = "../index-scheduler" }
-indexmap = { version = "2.1.0", features = ["serde"] }
-is-terminal = "0.4.10"
-itertools = "0.11.0"
-jsonwebtoken = "9.2.0"
-lazy_static = "1.4.0"
+indexmap = { version = "2.2.6", features = ["serde"] }
+is-terminal = "0.4.12"
+itertools = "0.13.0"
+jsonwebtoken = "9.3.0"
+lazy_static = "1.5.0"
 meilisearch-auth = { path = "../meilisearch-auth" }
 meilisearch-types = { path = "../meilisearch-types" }
-mimalloc = { version = "0.1.39", default-features = false }
+mimalloc = { version = "0.1.43", default-features = false }
 mime = "0.3.17"
 num_cpus = "1.16.0"
-obkv = "0.2.1"
+obkv = "0.2.2"
 once_cell = "1.19.0"
-ordered-float = "4.2.0"
-parking_lot = "0.12.1"
+ordered-float = "4.2.1"
+parking_lot = "0.12.3"
 permissive-json-pointer = { path = "../permissive-json-pointer" }
-pin-project-lite = "0.2.13"
+pin-project-lite = "0.2.14"
 platform-dirs = "0.3.0"
-prometheus = { version = "0.13.3", features = ["process"] }
+prometheus = { version = "0.13.4", features = ["process"] }
 rand = "0.8.5"
-rayon = "1.8.0"
-regex = "1.10.2"
-reqwest = { version = "0.11.23", features = [
+rayon = "1.10.0"
+regex = "1.10.5"
+reqwest = { version = "0.12.5", features = [
     "rustls-tls",
     "json",
 ], default-features = false }
 rustls = "0.21.12"
-rustls-pemfile = "1.0.2"
-segment = { version = "0.2.3", optional = true }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
+rustls-pemfile = "1.0.4"
+segment = { version = "0.2.4", optional = true }
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
 sha2 = "0.10.8"
-siphasher = "1.0.0"
+siphasher = "1.0.1"
 slice-group-by = "0.3.1"
-static-files = { version = "0.2.3", optional = true }
-sysinfo = "0.30.5"
-tar = "0.4.40"
-tempfile = "3.9.0"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = [
+static-files = { version = "0.2.4", optional = true }
+sysinfo = "0.30.13"
+tar = "0.4.41"
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = [
     "serde-well-known",
     "formatting",
     "parsing",
     "macros",
 ] }
-tokio = { version = "1.35.1", features = ["full"] }
-tokio-stream = "0.1.14"
-toml = "0.8.8"
-uuid = { version = "1.6.1", features = ["serde", "v4"] }
-walkdir = "2.4.0"
+tokio = { version = "1.38.0", features = ["full"] }
+toml = "0.8.14"
+uuid = { version = "1.10.0", features = ["serde", "v4"] }
 serde_urlencoded = "0.7.1"
 termcolor = "1.4.1"
-url = { version = "2.5.0", features = ["serde"] }
+url = { version = "2.5.2", features = ["serde"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["json"] }
 tracing-trace = { version = "0.1.0", path = "../tracing-trace" }
-tracing-actix-web = "0.7.10"
+tracing-actix-web = "0.7.11"
 build-info = { version = "1.7.0", path = "../build-info" }
+roaring = "0.10.2"
 
 [dev-dependencies]
-actix-rt = "2.9.0"
-assert-json-diff = "2.0.2"
+actix-rt = "2.10.0"
 brotli = "6.0.0"
-insta = "1.34.0"
+insta = "1.39.0"
 manifest-dir-macros = "0.1.18"
 maplit = "1.0.2"
 meili-snap = { path = "../meili-snap" }
@@ -120,23 +116,22 @@ urlencoding = "2.1.3"
 yaup = "0.3.1"
 
 [build-dependencies]
-anyhow = { version = "1.0.79", optional = true }
-cargo_toml = { version = "0.18.0", optional = true }
+anyhow = { version = "1.0.86", optional = true }
+cargo_toml = { version = "0.20.3", optional = true }
 hex = { version = "0.4.3", optional = true }
-reqwest = { version = "0.11.23", features = [
+reqwest = { version = "0.12.5", features = [
     "blocking",
     "rustls-tls",
 ], default-features = false, optional = true }
 sha-1 = { version = "0.10.1", optional = true }
-static-files = { version = "0.2.3", optional = true }
-tempfile = { version = "3.9.0", optional = true }
-zip = { version = "0.6.6", optional = true }
+static-files = { version = "0.2.4", optional = true }
+tempfile = { version = "3.10.1", optional = true }
+zip = { version = "2.1.3", optional = true }
 
 [features]
 default = ["analytics", "meilisearch-types/all-tokenizations", "mini-dashboard"]
 analytics = ["segment"]
 mini-dashboard = [
-    "actix-web-static-files",
     "static-files",
     "anyhow",
     "cargo_toml",

meilisearch/src/analytics/mock_analytics.rs

@@ -6,7 +6,7 @@ use meilisearch_types::InstanceUid;
 use serde_json::Value;
 
 use super::{find_user_id, Analytics, DocumentDeletionKind, DocumentFetchKind};
-use crate::routes::indexes::documents::UpdateDocumentsQuery;
+use crate::routes::indexes::documents::{DocumentEditionByFunction, UpdateDocumentsQuery};
 use crate::Opt;
 
 pub struct MockAnalytics {
@@ -42,7 +42,7 @@ pub struct MultiSearchAggregator;
 
 #[allow(dead_code)]
 impl MultiSearchAggregator {
-    pub fn from_queries(_: &dyn Any, _: &dyn Any) -> Self {
+    pub fn from_federated_search(_: &dyn Any, _: &dyn Any) -> Self {
         Self
     }
 
@@ -97,6 +97,13 @@ impl Analytics for MockAnalytics {
         _request: &HttpRequest,
     ) {
     }
+    fn update_documents_by_function(
+        &self,
+        _documents_query: &DocumentEditionByFunction,
+        _index_creation: bool,
+        _request: &HttpRequest,
+    ) {
+    }
     fn get_fetch_documents(&self, _documents_query: &DocumentFetchKind, _request: &HttpRequest) {}
     fn post_fetch_documents(&self, _documents_query: &DocumentFetchKind, _request: &HttpRequest) {}
 }

meilisearch/src/analytics/mod.rs

@@ -13,7 +13,7 @@ use once_cell::sync::Lazy;
 use platform_dirs::AppDirs;
 use serde_json::Value;
 
-use crate::routes::indexes::documents::UpdateDocumentsQuery;
+use crate::routes::indexes::documents::{DocumentEditionByFunction, UpdateDocumentsQuery};
 
 // if the analytics feature is disabled
 // the `SegmentAnalytics` point to the mock instead of the real analytics
@@ -119,11 +119,19 @@ pub trait Analytics: Sync + Send {
     // this method should be called to aggregate a add documents request
     fn delete_documents(&self, kind: DocumentDeletionKind, request: &HttpRequest);
 
-    // this method should be called to batch a update documents request
+    // this method should be called to batch an update documents request
     fn update_documents(
         &self,
         documents_query: &UpdateDocumentsQuery,
         index_creation: bool,
         request: &HttpRequest,
     );
+
+    // this method should be called to batch an update documents by function request
+    fn update_documents_by_function(
+        &self,
+        documents_query: &DocumentEditionByFunction,
+        index_creation: bool,
+        request: &HttpRequest,
+    );
 }

meilisearch/src/analytics/segment_analytics.rs

@@ -5,10 +5,9 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
-use actix_web::http::header::USER_AGENT;
+use actix_web::http::header::{CONTENT_TYPE, USER_AGENT};
 use actix_web::HttpRequest;
 use byte_unit::Byte;
-use http::header::CONTENT_TYPE;
 use index_scheduler::IndexScheduler;
 use meilisearch_auth::{AuthController, AuthFilter};
 use meilisearch_types::InstanceUid;
@@ -31,12 +30,12 @@ use crate::analytics::Analytics;
 use crate::option::{
     default_http_addr, IndexerOpts, LogMode, MaxMemory, MaxThreads, ScheduleSnapshot,
 };
-use crate::routes::indexes::documents::UpdateDocumentsQuery;
+use crate::routes::indexes::documents::{DocumentEditionByFunction, UpdateDocumentsQuery};
 use crate::routes::indexes::facet_search::FacetSearchQuery;
 use crate::routes::{create_all_stats, Stats};
 use crate::search::{
-    FacetSearchResult, MatchingStrategy, SearchQuery, SearchQueryWithIndex, SearchResult,
-    SimilarQuery, SimilarResult, DEFAULT_CROP_LENGTH, DEFAULT_CROP_MARKER,
+    FacetSearchResult, FederatedSearch, MatchingStrategy, SearchQuery, SearchQueryWithIndex,
+    SearchResult, SimilarQuery, SimilarResult, DEFAULT_CROP_LENGTH, DEFAULT_CROP_MARKER,
     DEFAULT_HIGHLIGHT_POST_TAG, DEFAULT_HIGHLIGHT_PRE_TAG, DEFAULT_SEARCH_LIMIT,
     DEFAULT_SEMANTIC_RATIO,
 };
@@ -81,6 +80,7 @@ pub enum AnalyticsMsg {
     AggregateAddDocuments(DocumentsAggregator),
     AggregateDeleteDocuments(DocumentsDeletionAggregator),
     AggregateUpdateDocuments(DocumentsAggregator),
+    AggregateEditDocumentsByFunction(EditDocumentsByFunctionAggregator),
     AggregateGetFetchDocuments(DocumentsFetchAggregator),
     AggregatePostFetchDocuments(DocumentsFetchAggregator),
 }
@@ -150,6 +150,7 @@ impl SegmentAnalytics {
             add_documents_aggregator: DocumentsAggregator::default(),
             delete_documents_aggregator: DocumentsDeletionAggregator::default(),
             update_documents_aggregator: DocumentsAggregator::default(),
+            edit_documents_by_function_aggregator: EditDocumentsByFunctionAggregator::default(),
             get_fetch_documents_aggregator: DocumentsFetchAggregator::default(),
             post_fetch_documents_aggregator: DocumentsFetchAggregator::default(),
             get_similar_aggregator: SimilarAggregator::default(),
@@ -230,6 +231,17 @@ impl super::Analytics for SegmentAnalytics {
         let _ = self.sender.try_send(AnalyticsMsg::AggregateUpdateDocuments(aggregate));
     }
 
+    fn update_documents_by_function(
+        &self,
+        documents_query: &DocumentEditionByFunction,
+        index_creation: bool,
+        request: &HttpRequest,
+    ) {
+        let aggregate =
+            EditDocumentsByFunctionAggregator::from_query(documents_query, index_creation, request);
+        let _ = self.sender.try_send(AnalyticsMsg::AggregateEditDocumentsByFunction(aggregate));
+    }
+
     fn get_fetch_documents(&self, documents_query: &DocumentFetchKind, request: &HttpRequest) {
         let aggregate = DocumentsFetchAggregator::from_query(documents_query, request);
         let _ = self.sender.try_send(AnalyticsMsg::AggregateGetFetchDocuments(aggregate));
@@ -390,6 +402,7 @@ pub struct Segment {
     add_documents_aggregator: DocumentsAggregator,
     delete_documents_aggregator: DocumentsDeletionAggregator,
     update_documents_aggregator: DocumentsAggregator,
+    edit_documents_by_function_aggregator: EditDocumentsByFunctionAggregator,
     get_fetch_documents_aggregator: DocumentsFetchAggregator,
     post_fetch_documents_aggregator: DocumentsFetchAggregator,
     get_similar_aggregator: SimilarAggregator,
@@ -454,6 +467,7 @@ impl Segment {
                         Some(AnalyticsMsg::AggregateAddDocuments(agreg)) => self.add_documents_aggregator.aggregate(agreg),
                         Some(AnalyticsMsg::AggregateDeleteDocuments(agreg)) => self.delete_documents_aggregator.aggregate(agreg),
                         Some(AnalyticsMsg::AggregateUpdateDocuments(agreg)) => self.update_documents_aggregator.aggregate(agreg),
+                        Some(AnalyticsMsg::AggregateEditDocumentsByFunction(agreg)) => self.edit_documents_by_function_aggregator.aggregate(agreg),
                         Some(AnalyticsMsg::AggregateGetFetchDocuments(agreg)) => self.get_fetch_documents_aggregator.aggregate(agreg),
                         Some(AnalyticsMsg::AggregatePostFetchDocuments(agreg)) => self.post_fetch_documents_aggregator.aggregate(agreg),
                         Some(AnalyticsMsg::AggregateGetSimilar(agreg)) => self.get_similar_aggregator.aggregate(agreg),
@@ -509,6 +523,7 @@ impl Segment {
             add_documents_aggregator,
             delete_documents_aggregator,
             update_documents_aggregator,
+            edit_documents_by_function_aggregator,
             get_fetch_documents_aggregator,
             post_fetch_documents_aggregator,
             get_similar_aggregator,
@@ -550,6 +565,11 @@ impl Segment {
         {
             let _ = self.batcher.push(update_documents).await;
         }
+        if let Some(edit_documents_by_function) = take(edit_documents_by_function_aggregator)
+            .into_event(user, "Documents Edited By Function")
+        {
+            let _ = self.batcher.push(edit_documents_by_function).await;
+        }
         if let Some(get_fetch_documents) =
             take(get_fetch_documents_aggregator).into_event(user, "Documents Fetched GET")
         {
@@ -1075,22 +1095,33 @@ pub struct MultiSearchAggregator {
     show_ranking_score: bool,
     show_ranking_score_details: bool,
 
+    // federation
+    use_federation: bool,
+
     // context
     user_agents: HashSet<String>,
 }
 
 impl MultiSearchAggregator {
-    pub fn from_queries(query: &[SearchQueryWithIndex], request: &HttpRequest) -> Self {
+    pub fn from_federated_search(
+        federated_search: &FederatedSearch,
+        request: &HttpRequest,
+    ) -> Self {
         let timestamp = Some(OffsetDateTime::now_utc());
 
         let user_agents = extract_user_agents(request).into_iter().collect();
 
-        let distinct_indexes: HashSet<_> = query
+        let use_federation = federated_search.federation.is_some();
+
+        let distinct_indexes: HashSet<_> = federated_search
+            .queries
             .iter()
             .map(|query| {
+                let query = &query;
                 // make sure we get a compilation error if a field gets added to / removed from SearchQueryWithIndex
                 let SearchQueryWithIndex {
                     index_uid,
+                    federation_options: _,
                     q: _,
                     vector: _,
                     offset: _,
@@ -1122,8 +1153,10 @@ impl MultiSearchAggregator {
             })
             .collect();
 
-        let show_ranking_score = query.iter().any(|query| query.show_ranking_score);
-        let show_ranking_score_details = query.iter().any(|query| query.show_ranking_score_details);
+        let show_ranking_score =
+            federated_search.queries.iter().any(|query| query.show_ranking_score);
+        let show_ranking_score_details =
+            federated_search.queries.iter().any(|query| query.show_ranking_score_details);
 
         Self {
             timestamp,
@@ -1131,10 +1164,11 @@ impl MultiSearchAggregator {
             total_succeeded: 0,
             total_distinct_index_count: distinct_indexes.len(),
             total_single_index: if distinct_indexes.len() == 1 { 1 } else { 0 },
-            total_search_count: query.len(),
+            total_search_count: federated_search.queries.len(),
             show_ranking_score,
             show_ranking_score_details,
             user_agents,
+            use_federation,
         }
     }
 
@@ -1160,6 +1194,7 @@ impl MultiSearchAggregator {
         let show_ranking_score_details =
             this.show_ranking_score_details || other.show_ranking_score_details;
         let mut user_agents = this.user_agents;
+        let use_federation = this.use_federation || other.use_federation;
 
         for user_agent in other.user_agents.into_iter() {
             user_agents.insert(user_agent);
@@ -1176,6 +1211,7 @@ impl MultiSearchAggregator {
             user_agents,
             show_ranking_score,
             show_ranking_score_details,
+            use_federation,
             // do not add _ or ..Default::default() here
         };
 
@@ -1194,6 +1230,7 @@ impl MultiSearchAggregator {
             user_agents,
             show_ranking_score,
             show_ranking_score_details,
+            use_federation,
         } = self;
 
         if total_received == 0 {
@@ -1218,6 +1255,9 @@ impl MultiSearchAggregator {
                 "scoring": {
                     "show_ranking_score": show_ranking_score,
                     "show_ranking_score_details": show_ranking_score_details,
+                },
+                "federation": {
+                    "use_federation": use_federation,
                 }
             });
 
@@ -1466,6 +1506,75 @@ impl DocumentsAggregator {
     }
 }
 
+#[derive(Default)]
+pub struct EditDocumentsByFunctionAggregator {
+    timestamp: Option<OffsetDateTime>,
+
+    // Set to true if at least one request was filtered
+    filtered: bool,
+    // Set to true if at least one request contained a context
+    with_context: bool,
+
+    // context
+    user_agents: HashSet<String>,
+
+    index_creation: bool,
+}
+
+impl EditDocumentsByFunctionAggregator {
+    pub fn from_query(
+        documents_query: &DocumentEditionByFunction,
+        index_creation: bool,
+        request: &HttpRequest,
+    ) -> Self {
+        let DocumentEditionByFunction { filter, context, function: _ } = documents_query;
+
+        Self {
+            timestamp: Some(OffsetDateTime::now_utc()),
+            user_agents: extract_user_agents(request).into_iter().collect(),
+            filtered: filter.is_some(),
+            with_context: context.is_some(),
+            index_creation,
+        }
+    }
+
+    /// Aggregate one [DocumentsAggregator] into another.
+    pub fn aggregate(&mut self, other: Self) {
+        let Self { timestamp, user_agents, index_creation, filtered, with_context } = other;
+
+        if self.timestamp.is_none() {
+            self.timestamp = timestamp;
+        }
+
+        // we can't create a union because there is no `into_union` method
+        for user_agent in user_agents {
+            self.user_agents.insert(user_agent);
+        }
+        self.index_creation |= index_creation;
+        self.filtered |= filtered;
+        self.with_context |= with_context;
+    }
+
+    pub fn into_event(self, user: &User, event_name: &str) -> Option<Track> {
+        let Self { timestamp, user_agents, index_creation, filtered, with_context } = self;
+
+        let properties = json!({
+            "user-agent": user_agents,
+            "filtered": filtered,
+            "with_context": with_context,
+            "index_creation": index_creation,
+        });
+
+        Some(Track {
+            timestamp,
+            user: user.clone(),
+            event: event_name.to_string(),
+            properties,
+            ..Default::default()
+        })
+    }
+}
+
 #[derive(Default, Serialize)]
 pub struct DocumentsDeletionAggregator {
     #[serde(skip)]

meilisearch/src/error.rs

@@ -1,6 +1,6 @@
 use actix_web as aweb;
 use aweb::error::{JsonPayloadError, QueryPayloadError};
-use byte_unit::Byte;
+use byte_unit::{Byte, UnitType};
 use meilisearch_types::document_formats::{DocumentFormatError, PayloadType};
 use meilisearch_types::error::{Code, ErrorCode, ResponseError};
 use meilisearch_types::index_uid::{IndexUid, IndexUidFormatError};
@@ -25,6 +25,10 @@ pub enum MeilisearchHttpError {
     DocumentNotFound(String),
     #[error("Sending an empty filter is forbidden.")]
     EmptyFilter,
+    #[error("Using `federationOptions` is not allowed in a non-federated search.\n Hint: remove `federationOptions` from query #{0} or add `federation: {{}}` to the request.")]
+    FederationOptionsInNonFederatedRequest(usize),
+    #[error("Inside `.queries[{0}]`: Using pagination options is not allowed in federated queries.\n Hint: remove `{1}` from query #{0} or remove `federation: {{}}` from the request")]
+    PaginationInFederatedQuery(usize, &'static str),
     #[error("Invalid syntax for the filter parameter: `expected {}, found: {1}`.", .0.join(", "))]
     InvalidExpression(&'static [&'static str], Value),
     #[error("A {0} payload is missing.")]
@@ -33,7 +37,7 @@ pub enum MeilisearchHttpError {
     TooManySearchRequests(usize),
     #[error("Internal error: Search limiter is down.")]
     SearchLimiterIsDown,
-    #[error("The provided payload reached the size limit. The maximum accepted payload size is {}.",  Byte::from_bytes(*.0 as u64).get_appropriate_unit(true))]
+    #[error("The provided payload reached the size limit. The maximum accepted payload size is {}.",  Byte::from_u64(*.0 as u64).get_appropriate_unit(UnitType::Binary))]
     PayloadTooLarge(usize),
     #[error("Two indexes must be given for each swap. The list `[{}]` contains {} indexes.",
         .0.iter().map(|uid| format!("\"{uid}\"")).collect::<Vec<_>>().join(", "), .0.len()
@@ -86,6 +90,12 @@ impl ErrorCode for MeilisearchHttpError {
             MeilisearchHttpError::DocumentFormat(e) => e.error_code(),
             MeilisearchHttpError::Join(_) => Code::Internal,
             MeilisearchHttpError::MissingSearchHybrid => Code::MissingSearchHybrid,
+            MeilisearchHttpError::FederationOptionsInNonFederatedRequest(_) => {
+                Code::InvalidMultiSearchFederationOptions
+            }
+            MeilisearchHttpError::PaginationInFederatedQuery(_, _) => {
+                Code::InvalidMultiSearchQueryPagination
+            }
         }
     }
 }

meilisearch/src/lib.rs

@@ -15,6 +15,7 @@ use std::fs::File;
 use std::io::{BufReader, BufWriter};
 use std::num::NonZeroUsize;
 use std::path::Path;
+use std::str::FromStr;
 use std::sync::Arc;
 use std::thread::{self, available_parallelism};
 use std::time::Duration;
@@ -23,13 +24,13 @@ use actix_cors::Cors;
 use actix_http::body::MessageBody;
 use actix_web::dev::{ServiceFactory, ServiceResponse};
 use actix_web::error::JsonPayloadError;
+use actix_web::http::header::{CONTENT_TYPE, USER_AGENT};
 use actix_web::web::Data;
 use actix_web::{web, HttpRequest};
 use analytics::Analytics;
 use anyhow::bail;
 use error::PayloadError;
 use extractors::payload::PayloadConfig;
-use http::header::CONTENT_TYPE;
 use index_scheduler::{IndexScheduler, IndexSchedulerOptions};
 use meilisearch_auth::AuthController;
 use meilisearch_types::milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader};
@@ -167,7 +168,7 @@ impl tracing_actix_web::RootSpanBuilder for AwebTracingLogger {
         let conn_info = request.connection_info();
         let headers = request.headers();
         let user_agent = headers
-            .get(http::header::USER_AGENT)
+            .get(USER_AGENT)
             .map(|value| String::from_utf8_lossy(value.as_bytes()).into_owned())
             .unwrap_or_default();
         info_span!("HTTP request", method = %request.method(), host = conn_info.host(), route = %request.path(), query_parameters = %request.query_string(), %user_agent, status_code = Empty, error = Empty)
@@ -300,15 +301,15 @@ fn open_or_create_database_unchecked(
             dumps_path: opt.dump_dir.clone(),
             webhook_url: opt.task_webhook_url.as_ref().map(|url| url.to_string()),
             webhook_authorization_header: opt.task_webhook_authorization_header.clone(),
-            task_db_size: opt.max_task_db_size.get_bytes() as usize,
-            index_base_map_size: opt.max_index_size.get_bytes() as usize,
+            task_db_size: opt.max_task_db_size.as_u64() as usize,
+            index_base_map_size: opt.max_index_size.as_u64() as usize,
             enable_mdb_writemap: opt.experimental_reduce_indexing_memory_usage,
             indexer_config: (&opt.indexer_options).try_into()?,
             autobatching_enabled: true,
             cleanup_enabled: !opt.experimental_replication_parameters,
             max_number_of_tasks: 1_000_000,
             max_number_of_batched_tasks: opt.experimental_max_number_of_batched_tasks,
-            index_growth_amount: byte_unit::Byte::from_str("10GiB").unwrap().get_bytes() as usize,
+            index_growth_amount: byte_unit::Byte::from_str("10GiB").unwrap().as_u64() as usize,
             index_count: DEFAULT_INDEX_COUNT,
             instance_features,
         })?)
@@ -476,7 +477,7 @@ pub fn configure_data(
         opt.experimental_search_queue_size,
         available_parallelism().unwrap_or(NonZeroUsize::new(2).unwrap()),
     );
-    let http_payload_size_limit = opt.http_payload_size_limit.get_bytes() as usize;
+    let http_payload_size_limit = opt.http_payload_size_limit.as_u64() as usize;
     config
         .app_data(index_scheduler)
         .app_data(auth)

meilisearch/src/option.rs

@@ -9,7 +9,7 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::{env, fmt, fs};
 
-use byte_unit::{Byte, ByteError};
+use byte_unit::{Byte, ParseError, UnitType};
 use clap::Parser;
 use meilisearch_types::features::InstanceTogglableFeatures;
 use meilisearch_types::milli::update::IndexerConfig;
@@ -674,7 +674,7 @@ impl TryFrom<&IndexerOpts> for IndexerConfig {
 
         Ok(Self {
             log_every_n: Some(DEFAULT_LOG_EVERY_N),
-            max_memory: other.max_indexing_memory.map(|b| b.get_bytes() as usize),
+            max_memory: other.max_indexing_memory.map(|b| b.as_u64() as usize),
             thread_pool: Some(thread_pool),
             max_positions_per_attributes: None,
             skip_index_budget: other.skip_index_budget,
@@ -688,23 +688,25 @@ impl TryFrom<&IndexerOpts> for IndexerConfig {
 pub struct MaxMemory(Option<Byte>);
 
 impl FromStr for MaxMemory {
-    type Err = ByteError;
+    type Err = ParseError;
 
-    fn from_str(s: &str) -> Result<MaxMemory, ByteError> {
+    fn from_str(s: &str) -> Result<MaxMemory, Self::Err> {
         Byte::from_str(s).map(Some).map(MaxMemory)
     }
 }
 
 impl Default for MaxMemory {
     fn default() -> MaxMemory {
-        MaxMemory(total_memory_bytes().map(|bytes| bytes * 2 / 3).map(Byte::from_bytes))
+        MaxMemory(total_memory_bytes().map(|bytes| bytes * 2 / 3).map(Byte::from_u64))
     }
 }
 
 impl fmt::Display for MaxMemory {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.0 {
-            Some(memory) => write!(f, "{}", memory.get_appropriate_unit(true)),
+            Some(memory) => {
+                write!(f, "{}", memory.get_appropriate_unit(UnitType::Binary))
+            }
             None => f.write_str("unknown"),
         }
     }
@@ -844,11 +846,11 @@ fn default_env() -> String {
 }
 
 fn default_max_index_size() -> Byte {
-    Byte::from_bytes(INDEX_SIZE)
+    Byte::from_u64(INDEX_SIZE)
 }
 
 fn default_max_task_db_size() -> Byte {
-    Byte::from_bytes(TASK_DB_SIZE)
+    Byte::from_u64(TASK_DB_SIZE)
 }
 
 fn default_http_payload_size_limit() -> Byte {

meilisearch/src/routes/features.rs

@@ -47,6 +47,8 @@ pub struct RuntimeTogglableFeatures {
     pub metrics: Option<bool>,
     #[deserr(default)]
     pub logs_route: Option<bool>,
+    #[deserr(default)]
+    pub edit_documents_by_function: Option<bool>,
 }
 
 async fn patch_features(
@@ -66,13 +68,21 @@ async fn patch_features(
         vector_store: new_features.0.vector_store.unwrap_or(old_features.vector_store),
         metrics: new_features.0.metrics.unwrap_or(old_features.metrics),
         logs_route: new_features.0.logs_route.unwrap_or(old_features.logs_route),
+        edit_documents_by_function: new_features
+            .0
+            .edit_documents_by_function
+            .unwrap_or(old_features.edit_documents_by_function),
     };
 
     // explicitly destructure for analytics rather than using the `Serialize` implementation, because
     // the it renames to camelCase, which we don't want for analytics.
     // **Do not** ignore fields with `..` or `_` here, because we want to add them in the future.
-    let meilisearch_types::features::RuntimeTogglableFeatures { vector_store, metrics, logs_route } =
-        new_features;
+    let meilisearch_types::features::RuntimeTogglableFeatures {
+        vector_store,
+        metrics,
+        logs_route,
+        edit_documents_by_function,
+    } = new_features;
 
     analytics.publish(
         "Experimental features Updated".to_string(),
@@ -80,6 +90,7 @@ async fn patch_features(
             "vector_store": vector_store,
             "metrics": metrics,
             "logs_route": logs_route,
+            "edit_documents_by_function": edit_documents_by_function,
         }),
         Some(&req),
     );

meilisearch/src/routes/indexes/documents.rs

@@ -82,6 +82,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
         web::resource("/delete-batch").route(web::post().to(SeqHandler(delete_documents_batch))),
     )
     .service(web::resource("/delete").route(web::post().to(SeqHandler(delete_documents_by_filter))))
+    .service(web::resource("/edit").route(web::post().to(SeqHandler(edit_documents_by_function))))
     .service(web::resource("/fetch").route(web::post().to(SeqHandler(documents_by_query_post))))
     .service(
         web::resource("/{document_id}")
@@ -574,6 +575,82 @@ pub async fn delete_documents_by_filter(
     Ok(HttpResponse::Accepted().json(task))
 }
 
+#[derive(Debug, Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct DocumentEditionByFunction {
+    #[deserr(default, error = DeserrJsonError<InvalidDocumentFilter>)]
+    pub filter: Option<Value>,
+    #[deserr(default, error = DeserrJsonError<InvalidDocumentEditionContext>)]
+    pub context: Option<Value>,
+    #[deserr(error = DeserrJsonError<InvalidDocumentEditionFunctionFilter>, missing_field_error = DeserrJsonError::missing_document_edition_function)]
+    pub function: String,
+}
+
+pub async fn edit_documents_by_function(
+    index_scheduler: GuardedData<ActionPolicy<{ actions::DOCUMENTS_ALL }>, Data<IndexScheduler>>,
+    index_uid: web::Path<String>,
+    params: AwebJson<DocumentEditionByFunction, DeserrJsonError>,
+    req: HttpRequest,
+    opt: web::Data<Opt>,
+    analytics: web::Data<dyn Analytics>,
+) -> Result<HttpResponse, ResponseError> {
+    debug!(parameters = ?params, "Edit documents by function");
+
+    index_scheduler
+        .features()
+        .check_edit_documents_by_function("Using the documents edit route")?;
+
+    let index_uid = IndexUid::try_from(index_uid.into_inner())?;
+    let index_uid = index_uid.into_inner();
+    let params = params.into_inner();
+
+    analytics.update_documents_by_function(
+        &params,
+        index_scheduler.index(&index_uid).is_err(),
+        &req,
+    );
+
+    let DocumentEditionByFunction { filter, context, function } = params;
+    let engine = milli::rhai::Engine::new();
+    if let Err(e) = engine.compile(&function) {
+        return Err(ResponseError::from_msg(e.to_string(), Code::BadRequest));
+    }
+
+    if let Some(ref filter) = filter {
+        // we ensure the filter is well formed before enqueuing it
+        || -> Result<_, ResponseError> {
+            Ok(crate::search::parse_filter(filter)?.ok_or(MeilisearchHttpError::EmptyFilter)?)
+        }()
+        // and whatever was the error, the error code should always be an InvalidDocumentFilter
+        .map_err(|err| ResponseError::from_msg(err.message, Code::InvalidDocumentFilter))?;
+    }
+    let task = KindWithContent::DocumentEdition {
+        index_uid,
+        filter_expr: filter,
+        context: match context {
+            Some(Value::Object(m)) => Some(m),
+            None => None,
+            _ => {
+                return Err(ResponseError::from_msg(
+                    "The context must be an object".to_string(),
+                    Code::InvalidDocumentEditionContext,
+                ))
+            }
+        },
+        function,
+    };
+
+    let uid = get_task_id(&req, &opt)?;
+    let dry_run = is_dry_run(&req, &opt)?;
+    let task: SummarizedTaskView =
+        tokio::task::spawn_blocking(move || index_scheduler.register(task, uid, dry_run))
+            .await??
+            .into();
+
+    debug!(returns = ?task, "Edit documents by function");
+    Ok(HttpResponse::Accepted().json(task))
+}
+
 pub async fn clear_all_documents(
     index_scheduler: GuardedData<ActionPolicy<{ actions::DOCUMENTS_DELETE }>, Data<IndexScheduler>>,
     index_uid: web::Path<String>,
@@ -615,6 +692,8 @@ fn some_documents<'a, 't: 'a>(
                     document.remove("_vectors");
                 }
                 RetrieveVectors::Retrieve => {
+                    // Clippy is simply wrong
+                    #[allow(clippy::manual_unwrap_or_default)]
                     let mut vectors = match document.remove("_vectors") {
                         Some(Value::Object(map)) => map,
                         _ => Default::default(),

meilisearch/src/routes/multi_search.rs

@@ -10,12 +10,14 @@ use serde::Serialize;
 use tracing::debug;
 
 use crate::analytics::{Analytics, MultiSearchAggregator};
+use crate::error::MeilisearchHttpError;
 use crate::extractors::authentication::policies::ActionPolicy;
 use crate::extractors::authentication::{AuthenticationError, GuardedData};
 use crate::extractors::sequential_extractor::SeqHandler;
 use crate::routes::indexes::search::search_kind;
 use crate::search::{
-    add_search_rules, perform_search, RetrieveVectors, SearchQueryWithIndex, SearchResultWithIndex,
+    add_search_rules, perform_federated_search, perform_search, FederatedSearch, RetrieveVectors,
+    SearchQueryWithIndex, SearchResultWithIndex,
 };
 use crate::search_queue::SearchQueue;
 
@@ -28,85 +30,44 @@ struct SearchResults {
     results: Vec<SearchResultWithIndex>,
 }
 
-#[derive(Debug, deserr::Deserr)]
-#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
-pub struct SearchQueries {
-    queries: Vec<SearchQueryWithIndex>,
-}
-
 pub async fn multi_search_with_post(
     index_scheduler: GuardedData<ActionPolicy<{ actions::SEARCH }>, Data<IndexScheduler>>,
     search_queue: Data<SearchQueue>,
-    params: AwebJson<SearchQueries, DeserrJsonError>,
+    params: AwebJson<FederatedSearch, DeserrJsonError>,
     req: HttpRequest,
     analytics: web::Data<dyn Analytics>,
 ) -> Result<HttpResponse, ResponseError> {
-    let queries = params.into_inner().queries;
-
-    let mut multi_aggregate = MultiSearchAggregator::from_queries(&queries, &req);
-    let features = index_scheduler.features();
-
     // Since we don't want to process half of the search requests and then get a permit refused
     // we're going to get one permit for the whole duration of the multi-search request.
     let _permit = search_queue.try_get_search_permit().await?;
 
-    // Explicitly expect a `(ResponseError, usize)` for the error type rather than `ResponseError` only,
-    // so that `?` doesn't work if it doesn't use `with_index`, ensuring that it is not forgotten in case of code
-    // changes.
-    let search_results: Result<_, (ResponseError, usize)> = async {
-        let mut search_results = Vec::with_capacity(queries.len());
-        for (query_index, (index_uid, mut query)) in
-            queries.into_iter().map(SearchQueryWithIndex::into_index_query).enumerate()
-        {
-            debug!(on_index = query_index, parameters = ?query, "Multi-search");
+    let federated_search = params.into_inner();
 
+    let mut multi_aggregate = MultiSearchAggregator::from_federated_search(&federated_search, &req);
+
+    let FederatedSearch { mut queries, federation } = federated_search;
+
+    let features = index_scheduler.features();
+
+    // regardless of federation, check authorization and apply search rules
+    let auth = 'check_authorization: {
+        for (query_index, federated_query) in queries.iter_mut().enumerate() {
+            let index_uid = federated_query.index_uid.as_str();
             // Check index from API key
-            if !index_scheduler.filters().is_index_authorized(&index_uid) {
-                return Err(AuthenticationError::InvalidToken).with_index(query_index);
+            if !index_scheduler.filters().is_index_authorized(index_uid) {
+                break 'check_authorization Err(AuthenticationError::InvalidToken)
+                    .with_index(query_index);
             }
             // Apply search rules from tenant token
-            if let Some(search_rules) = index_scheduler.filters().get_index_search_rules(&index_uid)
+            if let Some(search_rules) = index_scheduler.filters().get_index_search_rules(index_uid)
             {
-                add_search_rules(&mut query.filter, search_rules);
+                add_search_rules(&mut federated_query.filter, search_rules);
             }
-
-            let index = index_scheduler
-                .index(&index_uid)
-                .map_err(|err| {
-                    let mut err = ResponseError::from(err);
-                    // Patch the HTTP status code to 400 as it defaults to 404 for `index_not_found`, but
-                    // here the resource not found is not part of the URL.
-                    err.code = StatusCode::BAD_REQUEST;
-                    err
-                })
-                .with_index(query_index)?;
-
-            let search_kind = search_kind(&query, index_scheduler.get_ref(), &index, features)
-                .with_index(query_index)?;
-            let retrieve_vector =
-                RetrieveVectors::new(query.retrieve_vectors, features).with_index(query_index)?;
-
-            let search_result = tokio::task::spawn_blocking(move || {
-                perform_search(&index, query, search_kind, retrieve_vector)
-            })
-            .await
-            .with_index(query_index)?;
-
-            search_results.push(SearchResultWithIndex {
-                index_uid: index_uid.into_inner(),
-                result: search_result.with_index(query_index)?,
-            });
         }
-        Ok(search_results)
-    }
-    .await;
+        Ok(())
+    };
 
-    if search_results.is_ok() {
-        multi_aggregate.succeed();
-    }
-    analytics.post_multi_search(multi_aggregate);
-
-    let search_results = search_results.map_err(|(mut err, query_index)| {
+    auth.map_err(|(mut err, query_index)| {
         // Add the query index that failed as context for the error message.
         // We're doing it only here and not directly in the `WithIndex` trait so that the `with_index` function returns a different type
         // of result and we can benefit from static typing.
@@ -114,9 +75,95 @@ pub async fn multi_search_with_post(
         err
     })?;
 
-    debug!(returns = ?search_results, "Multi-search");
+    let response = match federation {
+        Some(federation) => {
+            let search_result = tokio::task::spawn_blocking(move || {
+                perform_federated_search(&index_scheduler, queries, federation, features)
+            })
+            .await;
 
-    Ok(HttpResponse::Ok().json(SearchResults { results: search_results }))
+            if let Ok(Ok(_)) = search_result {
+                multi_aggregate.succeed();
+            }
+
+            analytics.post_multi_search(multi_aggregate);
+            HttpResponse::Ok().json(search_result??)
+        }
+        None => {
+            // Explicitly expect a `(ResponseError, usize)` for the error type rather than `ResponseError` only,
+            // so that `?` doesn't work if it doesn't use `with_index`, ensuring that it is not forgotten in case of code
+            // changes.
+            let search_results: Result<_, (ResponseError, usize)> = async {
+                let mut search_results = Vec::with_capacity(queries.len());
+                for (query_index, (index_uid, query, federation_options)) in queries
+                    .into_iter()
+                    .map(SearchQueryWithIndex::into_index_query_federation)
+                    .enumerate()
+                {
+                    debug!(on_index = query_index, parameters = ?query, "Multi-search");
+
+                    if federation_options.is_some() {
+                        return Err((
+                            MeilisearchHttpError::FederationOptionsInNonFederatedRequest(
+                                query_index,
+                            )
+                            .into(),
+                            query_index,
+                        ));
+                    }
+
+                    let index = index_scheduler
+                        .index(&index_uid)
+                        .map_err(|err| {
+                            let mut err = ResponseError::from(err);
+                            // Patch the HTTP status code to 400 as it defaults to 404 for `index_not_found`, but
+                            // here the resource not found is not part of the URL.
+                            err.code = StatusCode::BAD_REQUEST;
+                            err
+                        })
+                        .with_index(query_index)?;
+
+                    let search_kind =
+                        search_kind(&query, index_scheduler.get_ref(), &index, features)
+                            .with_index(query_index)?;
+                    let retrieve_vector = RetrieveVectors::new(query.retrieve_vectors, features)
+                        .with_index(query_index)?;
+
+                    let search_result = tokio::task::spawn_blocking(move || {
+                        perform_search(&index, query, search_kind, retrieve_vector)
+                    })
+                    .await
+                    .with_index(query_index)?;
+
+                    search_results.push(SearchResultWithIndex {
+                        index_uid: index_uid.into_inner(),
+                        result: search_result.with_index(query_index)?,
+                    });
+                }
+                Ok(search_results)
+            }
+            .await;
+
+            if search_results.is_ok() {
+                multi_aggregate.succeed();
+            }
+            analytics.post_multi_search(multi_aggregate);
+
+            let search_results = search_results.map_err(|(mut err, query_index)| {
+                // Add the query index that failed as context for the error message.
+                // We're doing it only here and not directly in the `WithIndex` trait so that the `with_index` function returns a different type
+                // of result and we can benefit from static typing.
+                err.message = format!("Inside `.queries[{query_index}]`: {}", err.message);
+                err
+            })?;
+
+            debug!(returns = ?search_results, "Multi-search");
+
+            HttpResponse::Ok().json(SearchResults { results: search_results })
+        }
+    };
+
+    Ok(response)
 }
 
 /// Local `Result` extension trait to avoid `map_err` boilerplate.

meilisearch/src/routes/tasks.rs

@@ -591,7 +591,7 @@ mod tests {
             let err = deserr_query_params::<TaskDeletionOrCancelationQuery>(params).unwrap_err();
             snapshot!(meili_snap::json_string!(err), @r###"
             {
-              "message": "Invalid value in parameter `types`: `createIndex` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
+              "message": "Invalid value in parameter `types`: `createIndex` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
               "code": "invalid_task_types",
               "type": "invalid_request",
               "link": "https://docs.meilisearch.com/errors#invalid_task_types"

meilisearch/src/search/federated.rs

@@ -0,0 +1,624 @@
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+use std::fmt;
+use std::iter::Zip;
+use std::rc::Rc;
+use std::str::FromStr as _;
+use std::time::Duration;
+use std::vec::{IntoIter, Vec};
+
+use actix_http::StatusCode;
+use index_scheduler::{IndexScheduler, RoFeatures};
+use meilisearch_types::deserr::DeserrJsonError;
+use meilisearch_types::error::deserr_codes::{
+    InvalidMultiSearchWeight, InvalidSearchLimit, InvalidSearchOffset,
+};
+use meilisearch_types::error::ResponseError;
+use meilisearch_types::milli::score_details::{ScoreDetails, ScoreValue};
+use meilisearch_types::milli::{self, DocumentId, TimeBudget};
+use roaring::RoaringBitmap;
+use serde::Serialize;
+
+use super::ranking_rules::{self, RankingRules};
+use super::{
+    prepare_search, AttributesFormat, HitMaker, HitsInfo, RetrieveVectors, SearchHit, SearchKind,
+    SearchQuery, SearchQueryWithIndex,
+};
+use crate::error::MeilisearchHttpError;
+use crate::routes::indexes::search::search_kind;
+
+pub const DEFAULT_FEDERATED_WEIGHT: fn() -> f64 = || 1.0;
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, deserr::Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct FederationOptions {
+    #[deserr(default, error = DeserrJsonError<InvalidMultiSearchWeight>)]
+    pub weight: Weight,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, deserr::Deserr)]
+#[deserr(try_from(f64) = TryFrom::try_from -> InvalidMultiSearchWeight)]
+pub struct Weight(f64);
+
+impl Default for Weight {
+    fn default() -> Self {
+        Weight(DEFAULT_FEDERATED_WEIGHT())
+    }
+}
+
+impl std::convert::TryFrom<f64> for Weight {
+    type Error = InvalidMultiSearchWeight;
+
+    fn try_from(f: f64) -> Result<Self, Self::Error> {
+        // the suggested "fix" is: `!(0.0..=1.0).contains(&f)`` which is allegedly less readable
+        #[allow(clippy::manual_range_contains)]
+        if f < 0.0 {
+            Err(InvalidMultiSearchWeight)
+        } else {
+            Ok(Weight(f))
+        }
+    }
+}
+
+impl std::ops::Deref for Weight {
+    type Target = f64;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, deserr::Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct Federation {
+    #[deserr(default = super::DEFAULT_SEARCH_LIMIT(), error = DeserrJsonError<InvalidSearchLimit>)]
+    pub limit: usize,
+    #[deserr(default = super::DEFAULT_SEARCH_OFFSET(), error = DeserrJsonError<InvalidSearchOffset>)]
+    pub offset: usize,
+}
+
+#[derive(Debug, deserr::Deserr)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct FederatedSearch {
+    pub queries: Vec<SearchQueryWithIndex>,
+    #[deserr(default)]
+    pub federation: Option<Federation>,
+}
+#[derive(Serialize, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct FederatedSearchResult {
+    pub hits: Vec<SearchHit>,
+    pub processing_time_ms: u128,
+    #[serde(flatten)]
+    pub hits_info: HitsInfo,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub semantic_hit_count: Option<u32>,
+
+    // These fields are only used for analytics purposes
+    #[serde(skip)]
+    pub degraded: bool,
+    #[serde(skip)]
+    pub used_negative_operator: bool,
+}
+
+impl fmt::Debug for FederatedSearchResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let FederatedSearchResult {
+            hits,
+            processing_time_ms,
+            hits_info,
+            semantic_hit_count,
+            degraded,
+            used_negative_operator,
+        } = self;
+
+        let mut debug = f.debug_struct("SearchResult");
+        // The most important thing when looking at a search result is the time it took to process
+        debug.field("processing_time_ms", &processing_time_ms);
+        debug.field("hits", &format!("[{} hits returned]", hits.len()));
+        debug.field("hits_info", &hits_info);
+        if *used_negative_operator {
+            debug.field("used_negative_operator", used_negative_operator);
+        }
+        if *degraded {
+            debug.field("degraded", degraded);
+        }
+        if let Some(semantic_hit_count) = semantic_hit_count {
+            debug.field("semantic_hit_count", &semantic_hit_count);
+        }
+
+        debug.finish()
+    }
+}
+
+struct WeightedScore<'a> {
+    details: &'a [ScoreDetails],
+    weight: f64,
+}
+
+impl<'a> WeightedScore<'a> {
+    pub fn new(details: &'a [ScoreDetails], weight: f64) -> Self {
+        Self { details, weight }
+    }
+
+    pub fn weighted_global_score(&self) -> f64 {
+        ScoreDetails::global_score(self.details.iter()) * self.weight
+    }
+
+    pub fn compare_weighted_global_scores(&self, other: &Self) -> Ordering {
+        self.weighted_global_score()
+            .partial_cmp(&other.weighted_global_score())
+            // both are numbers, possibly infinite
+            .unwrap()
+    }
+
+    pub fn compare(&self, other: &Self) -> Ordering {
+        let mut left_it = ScoreDetails::score_values(self.details.iter());
+        let mut right_it = ScoreDetails::score_values(other.details.iter());
+
+        loop {
+            let left = left_it.next();
+            let right = right_it.next();
+
+            match (left, right) {
+                (None, None) => return Ordering::Equal,
+                (None, Some(_)) => return Ordering::Less,
+                (Some(_), None) => return Ordering::Greater,
+                (Some(ScoreValue::Score(left)), Some(ScoreValue::Score(right))) => {
+                    let left = left * self.weight;
+                    let right = right * other.weight;
+                    if (left - right).abs() <= f64::EPSILON {
+                        continue;
+                    }
+                    return left.partial_cmp(&right).unwrap();
+                }
+                (Some(ScoreValue::Sort(left)), Some(ScoreValue::Sort(right))) => {
+                    match left.partial_cmp(right) {
+                        Some(Ordering::Equal) => continue,
+                        Some(order) => return order,
+                        None => return self.compare_weighted_global_scores(other),
+                    }
+                }
+                (Some(ScoreValue::GeoSort(left)), Some(ScoreValue::GeoSort(right))) => {
+                    match left.partial_cmp(right) {
+                        Some(Ordering::Equal) => continue,
+                        Some(order) => return order,
+                        None => {
+                            return self.compare_weighted_global_scores(other);
+                        }
+                    }
+                }
+                // not comparable details, use global
+                (Some(ScoreValue::Score(_)), Some(_))
+                | (Some(_), Some(ScoreValue::Score(_)))
+                | (Some(ScoreValue::GeoSort(_)), Some(ScoreValue::Sort(_)))
+                | (Some(ScoreValue::Sort(_)), Some(ScoreValue::GeoSort(_))) => {
+                    return self.compare_weighted_global_scores(other);
+                }
+            }
+        }
+    }
+}
+
+struct QueryByIndex {
+    query: SearchQuery,
+    federation_options: FederationOptions,
+    query_index: usize,
+}
+
+struct SearchResultByQuery<'a> {
+    documents_ids: Vec<DocumentId>,
+    document_scores: Vec<Vec<ScoreDetails>>,
+    federation_options: FederationOptions,
+    hit_maker: HitMaker<'a>,
+    query_index: usize,
+}
+
+struct SearchResultByQueryIter<'a> {
+    it: Zip<IntoIter<DocumentId>, IntoIter<Vec<ScoreDetails>>>,
+    federation_options: FederationOptions,
+    hit_maker: Rc<HitMaker<'a>>,
+    query_index: usize,
+}
+
+impl<'a> SearchResultByQueryIter<'a> {
+    fn new(
+        SearchResultByQuery {
+            documents_ids,
+            document_scores,
+            federation_options,
+            hit_maker,
+            query_index,
+        }: SearchResultByQuery<'a>,
+    ) -> Self {
+        let it = documents_ids.into_iter().zip(document_scores);
+        Self { it, federation_options, hit_maker: Rc::new(hit_maker), query_index }
+    }
+}
+
+struct SearchResultByQueryIterItem<'a> {
+    docid: DocumentId,
+    score: Vec<ScoreDetails>,
+    federation_options: FederationOptions,
+    hit_maker: Rc<HitMaker<'a>>,
+    query_index: usize,
+}
+
+fn merge_index_local_results(
+    results_by_query: Vec<SearchResultByQuery<'_>>,
+) -> impl Iterator<Item = SearchResultByQueryIterItem> + '_ {
+    itertools::kmerge_by(
+        results_by_query.into_iter().map(SearchResultByQueryIter::new),
+        |left: &SearchResultByQueryIterItem, right: &SearchResultByQueryIterItem| {
+            let left_score = WeightedScore::new(&left.score, *left.federation_options.weight);
+            let right_score = WeightedScore::new(&right.score, *right.federation_options.weight);
+
+            match left_score.compare(&right_score) {
+                // the biggest score goes first
+                Ordering::Greater => true,
+                // break ties using query index
+                Ordering::Equal => left.query_index < right.query_index,
+                Ordering::Less => false,
+            }
+        },
+    )
+}
+
+fn merge_index_global_results(
+    results_by_index: Vec<SearchResultByIndex>,
+) -> impl Iterator<Item = SearchHitByIndex> {
+    itertools::kmerge_by(
+        results_by_index.into_iter().map(|result_by_index| result_by_index.hits.into_iter()),
+        |left: &SearchHitByIndex, right: &SearchHitByIndex| {
+            let left_score = WeightedScore::new(&left.score, *left.federation_options.weight);
+            let right_score = WeightedScore::new(&right.score, *right.federation_options.weight);
+
+            match left_score.compare(&right_score) {
+                // the biggest score goes first
+                Ordering::Greater => true,
+                // break ties using query index
+                Ordering::Equal => left.query_index < right.query_index,
+                Ordering::Less => false,
+            }
+        },
+    )
+}
+
+impl<'a> Iterator for SearchResultByQueryIter<'a> {
+    type Item = SearchResultByQueryIterItem<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (docid, score) = self.it.next()?;
+        Some(SearchResultByQueryIterItem {
+            docid,
+            score,
+            federation_options: self.federation_options,
+            hit_maker: Rc::clone(&self.hit_maker),
+            query_index: self.query_index,
+        })
+    }
+}
+
+struct SearchHitByIndex {
+    hit: SearchHit,
+    score: Vec<ScoreDetails>,
+    federation_options: FederationOptions,
+    query_index: usize,
+}
+
+struct SearchResultByIndex {
+    hits: Vec<SearchHitByIndex>,
+    candidates: RoaringBitmap,
+    degraded: bool,
+    used_negative_operator: bool,
+}
+
+pub fn perform_federated_search(
+    index_scheduler: &IndexScheduler,
+    queries: Vec<SearchQueryWithIndex>,
+    federation: Federation,
+    features: RoFeatures,
+) -> Result<FederatedSearchResult, ResponseError> {
+    let before_search = std::time::Instant::now();
+
+    // this implementation partition the queries by index to guarantee an important property:
+    // - all the queries to a particular index use the same read transaction.
+    // This is an important property, otherwise we cannot guarantee the self-consistency of the results.
+
+    // 1. partition queries by index
+    let mut queries_by_index: BTreeMap<String, Vec<QueryByIndex>> = Default::default();
+    for (query_index, federated_query) in queries.into_iter().enumerate() {
+        if let Some(pagination_field) = federated_query.has_pagination() {
+            return Err(MeilisearchHttpError::PaginationInFederatedQuery(
+                query_index,
+                pagination_field,
+            )
+            .into());
+        }
+
+        let (index_uid, query, federation_options) = federated_query.into_index_query_federation();
+
+        queries_by_index.entry(index_uid.into_inner()).or_default().push(QueryByIndex {
+            query,
+            federation_options: federation_options.unwrap_or_default(),
+            query_index,
+        })
+    }
+
+    // 2. perform queries, merge and make hits index by index
+    let required_hit_count = federation.limit + federation.offset;
+    // In step (2), semantic_hit_count will be set to Some(0) if any search kind uses semantic
+    // Then in step (3), we'll update its value if there is any semantic search
+    let mut semantic_hit_count = None;
+    let mut results_by_index = Vec::with_capacity(queries_by_index.len());
+    let mut previous_query_data: Option<(RankingRules, usize, String)> = None;
+
+    for (index_uid, queries) in queries_by_index {
+        let index = match index_scheduler.index(&index_uid) {
+            Ok(index) => index,
+            Err(err) => {
+                let mut err = ResponseError::from(err);
+                // Patch the HTTP status code to 400 as it defaults to 404 for `index_not_found`, but
+                // here the resource not found is not part of the URL.
+                err.code = StatusCode::BAD_REQUEST;
+                if let Some(query) = queries.first() {
+                    err.message =
+                        format!("Inside `.queries[{}]`: {}", query.query_index, err.message);
+                }
+                return Err(err);
+            }
+        };
+
+        // Important: this is the only transaction we'll use for this index during this federated search
+        let rtxn = index.read_txn()?;
+
+        let criteria = index.criteria(&rtxn)?;
+
+        // stuff we need for the hitmaker
+        let script_lang_map = index.script_language(&rtxn)?;
+
+        let dictionary = index.dictionary(&rtxn)?;
+        let dictionary: Option<Vec<_>> =
+            dictionary.as_ref().map(|x| x.iter().map(String::as_str).collect());
+        let separators = index.allowed_separators(&rtxn)?;
+        let separators: Option<Vec<_>> =
+            separators.as_ref().map(|x| x.iter().map(String::as_str).collect());
+
+        // each query gets its individual cutoff
+        let cutoff = index.search_cutoff(&rtxn)?;
+
+        let mut degraded = false;
+        let mut used_negative_operator = false;
+        let mut candidates = RoaringBitmap::new();
+
+        // 2.1. Compute all candidates for each query in the index
+        let mut results_by_query = Vec::with_capacity(queries.len());
+
+        for QueryByIndex { query, federation_options, query_index } in queries {
+            // use an immediately invoked lambda to capture the result without returning from the function
+
+            let res: Result<(), ResponseError> = (|| {
+                let search_kind = search_kind(&query, index_scheduler, &index, features)?;
+
+                let canonicalization_kind = match (&search_kind, &query.q) {
+                    (SearchKind::SemanticOnly { .. }, _) => {
+                        ranking_rules::CanonicalizationKind::Vector
+                    }
+                    (_, Some(q)) if !q.is_empty() => ranking_rules::CanonicalizationKind::Keyword,
+                    _ => ranking_rules::CanonicalizationKind::Placeholder,
+                };
+
+                let sort = if let Some(sort) = &query.sort {
+                    let sorts: Vec<_> =
+                        match sort.iter().map(|s| milli::AscDesc::from_str(s)).collect() {
+                            Ok(sorts) => sorts,
+                            Err(asc_desc_error) => {
+                                return Err(milli::Error::from(milli::SortError::from(
+                                    asc_desc_error,
+                                ))
+                                .into())
+                            }
+                        };
+                    Some(sorts)
+                } else {
+                    None
+                };
+
+                let ranking_rules = ranking_rules::RankingRules::new(
+                    criteria.clone(),
+                    sort,
+                    query.matching_strategy.into(),
+                    canonicalization_kind,
+                );
+
+                if let Some((previous_ranking_rules, previous_query_index, previous_index_uid)) =
+                    previous_query_data.take()
+                {
+                    if let Err(error) = ranking_rules.is_compatible_with(&previous_ranking_rules) {
+                        return Err(error.to_response_error(
+                            &ranking_rules,
+                            &previous_ranking_rules,
+                            query_index,
+                            previous_query_index,
+                            &index_uid,
+                            &previous_index_uid,
+                        ));
+                    }
+                    previous_query_data = if previous_ranking_rules.constraint_count()
+                        > ranking_rules.constraint_count()
+                    {
+                        Some((previous_ranking_rules, previous_query_index, previous_index_uid))
+                    } else {
+                        Some((ranking_rules, query_index, index_uid.clone()))
+                    };
+                } else {
+                    previous_query_data = Some((ranking_rules, query_index, index_uid.clone()));
+                }
+
+                match search_kind {
+                    SearchKind::KeywordOnly => {}
+                    _ => semantic_hit_count = Some(0),
+                }
+
+                let retrieve_vectors = RetrieveVectors::new(query.retrieve_vectors, features)?;
+
+                let time_budget = match cutoff {
+                    Some(cutoff) => TimeBudget::new(Duration::from_millis(cutoff)),
+                    None => TimeBudget::default(),
+                };
+
+                let (mut search, _is_finite_pagination, _max_total_hits, _offset) =
+                    prepare_search(&index, &rtxn, &query, &search_kind, time_budget)?;
+
+                search.scoring_strategy(milli::score_details::ScoringStrategy::Detailed);
+                search.offset(0);
+                search.limit(required_hit_count);
+
+                let (result, _semantic_hit_count) = super::search_from_kind(search_kind, search)?;
+                let format = AttributesFormat {
+                    attributes_to_retrieve: query.attributes_to_retrieve,
+                    retrieve_vectors,
+                    attributes_to_highlight: query.attributes_to_highlight,
+                    attributes_to_crop: query.attributes_to_crop,
+                    crop_length: query.crop_length,
+                    crop_marker: query.crop_marker,
+                    highlight_pre_tag: query.highlight_pre_tag,
+                    highlight_post_tag: query.highlight_post_tag,
+                    show_matches_position: query.show_matches_position,
+                    sort: query.sort,
+                    show_ranking_score: query.show_ranking_score,
+                    show_ranking_score_details: query.show_ranking_score_details,
+                };
+
+                let milli::SearchResult {
+                    matching_words,
+                    candidates: query_candidates,
+                    documents_ids,
+                    document_scores,
+                    degraded: query_degraded,
+                    used_negative_operator: query_used_negative_operator,
+                } = result;
+
+                candidates |= query_candidates;
+                degraded |= query_degraded;
+                used_negative_operator |= query_used_negative_operator;
+
+                let tokenizer = HitMaker::tokenizer(
+                    &script_lang_map,
+                    dictionary.as_deref(),
+                    separators.as_deref(),
+                );
+
+                let formatter_builder = HitMaker::formatter_builder(matching_words, tokenizer);
+
+                let hit_maker = HitMaker::new(&index, &rtxn, format, formatter_builder)?;
+
+                results_by_query.push(SearchResultByQuery {
+                    federation_options,
+                    hit_maker,
+                    query_index,
+                    documents_ids,
+                    document_scores,
+                });
+                Ok(())
+            })();
+
+            if let Err(mut error) = res {
+                error.message = format!("Inside `.queries[{query_index}]`: {}", error.message);
+                return Err(error);
+            }
+        }
+        // 2.2. merge inside index
+        let mut documents_seen = RoaringBitmap::new();
+        let merged_result: Result<Vec<_>, ResponseError> =
+            merge_index_local_results(results_by_query)
+                // skip documents we've already seen & mark that we saw the current document
+                .filter(|SearchResultByQueryIterItem { docid, .. }| documents_seen.insert(*docid))
+                .take(required_hit_count)
+                // 2.3 make hits
+                .map(
+                    |SearchResultByQueryIterItem {
+                         docid,
+                         score,
+                         federation_options,
+                         hit_maker,
+                         query_index,
+                     }| {
+                        let mut hit = hit_maker.make_hit(docid, &score)?;
+                        let weighted_score =
+                            ScoreDetails::global_score(score.iter()) * (*federation_options.weight);
+
+                        let _federation = serde_json::json!(
+                            {
+                                "indexUid": index_uid,
+                                "queriesPosition": query_index,
+                                "weightedRankingScore": weighted_score,
+                            }
+                        );
+                        hit.document.insert("_federation".to_string(), _federation);
+                        Ok(SearchHitByIndex { hit, score, federation_options, query_index })
+                    },
+                )
+                .collect();
+
+        let merged_result = merged_result?;
+        results_by_index.push(SearchResultByIndex {
+            hits: merged_result,
+            candidates,
+            degraded,
+            used_negative_operator,
+        });
+    }
+
+    // 3. merge hits and metadata across indexes
+    // 3.1 merge metadata
+    let (estimated_total_hits, degraded, used_negative_operator) = {
+        let mut estimated_total_hits = 0;
+        let mut degraded = false;
+        let mut used_negative_operator = false;
+
+        for SearchResultByIndex {
+            hits: _,
+            candidates,
+            degraded: degraded_by_index,
+            used_negative_operator: used_negative_operator_by_index,
+        } in &results_by_index
+        {
+            estimated_total_hits += candidates.len() as usize;
+            degraded |= *degraded_by_index;
+            used_negative_operator |= *used_negative_operator_by_index;
+        }
+
+        (estimated_total_hits, degraded, used_negative_operator)
+    };
+
+    // 3.2 merge hits
+    let merged_hits: Vec<_> = merge_index_global_results(results_by_index)
+        .skip(federation.offset)
+        .take(federation.limit)
+        .inspect(|hit| {
+            if let Some(semantic_hit_count) = &mut semantic_hit_count {
+                if hit.score.iter().any(|score| matches!(&score, ScoreDetails::Vector(_))) {
+                    *semantic_hit_count += 1;
+                }
+            }
+        })
+        .map(|hit| hit.hit)
+        .collect();
+
+    let search_result = FederatedSearchResult {
+        hits: merged_hits,
+        processing_time_ms: before_search.elapsed().as_millis(),
+        hits_info: HitsInfo::OffsetLimit {
+            limit: federation.limit,
+            offset: federation.offset,
+            estimated_total_hits,
+        },
+        semantic_hit_count,
+        degraded,
+        used_negative_operator,
+    };
+
+    Ok(search_result)
+}

meilisearch/src/search/mod.rs

@@ -1,6 +1,6 @@
 use core::fmt;
 use std::cmp::min;
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -31,6 +31,11 @@ use serde_json::{json, Value};
 
 use crate::error::MeilisearchHttpError;
 
+mod federated;
+pub use federated::{perform_federated_search, FederatedSearch, Federation, FederationOptions};
+
+mod ranking_rules;
+
 type MatchesPosition = BTreeMap<String, Vec<MatchBounds>>;
 
 pub const DEFAULT_SEARCH_OFFSET: fn() -> usize = || 0;
@@ -257,11 +262,13 @@ pub struct HybridQuery {
     pub embedder: Option<String>,
 }
 
+#[derive(Clone)]
 pub enum SearchKind {
     KeywordOnly,
     SemanticOnly { embedder_name: String, embedder: Arc<Embedder> },
     Hybrid { embedder_name: String, embedder: Arc<Embedder>, semantic_ratio: f32 },
 }
+
 impl SearchKind {
     pub(crate) fn semantic(
         index_scheduler: &index_scheduler::IndexScheduler,
@@ -358,7 +365,7 @@ impl SearchQuery {
     }
 }
 
-/// A `SearchQuery` + an index UID.
+/// A `SearchQuery` + an index UID and optional FederationOptions.
 // This struct contains the fields of `SearchQuery` inline.
 // This is because neither deserr nor serde support `flatten` when using `deny_unknown_fields.
 // The `From<SearchQueryWithIndex>` implementation ensures both structs remain up to date.
@@ -373,10 +380,10 @@ pub struct SearchQueryWithIndex {
     pub vector: Option<Vec<f32>>,
     #[deserr(default, error = DeserrJsonError<InvalidHybridQuery>)]
     pub hybrid: Option<HybridQuery>,
-    #[deserr(default = DEFAULT_SEARCH_OFFSET(), error = DeserrJsonError<InvalidSearchOffset>)]
-    pub offset: usize,
-    #[deserr(default = DEFAULT_SEARCH_LIMIT(), error = DeserrJsonError<InvalidSearchLimit>)]
-    pub limit: usize,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchOffset>)]
+    pub offset: Option<usize>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchLimit>)]
+    pub limit: Option<usize>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchPage>)]
     pub page: Option<usize>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchHitsPerPage>)]
@@ -417,12 +424,33 @@ pub struct SearchQueryWithIndex {
     pub attributes_to_search_on: Option<Vec<String>>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchRankingScoreThreshold>, default)]
     pub ranking_score_threshold: Option<RankingScoreThreshold>,
+
+    #[deserr(default)]
+    pub federation_options: Option<FederationOptions>,
 }
 
 impl SearchQueryWithIndex {
-    pub fn into_index_query(self) -> (IndexUid, SearchQuery) {
+    pub fn has_federation_options(&self) -> bool {
+        self.federation_options.is_some()
+    }
+    pub fn has_pagination(&self) -> Option<&'static str> {
+        if self.offset.is_some() {
+            Some("offset")
+        } else if self.limit.is_some() {
+            Some("limit")
+        } else if self.page.is_some() {
+            Some("page")
+        } else if self.hits_per_page.is_some() {
+            Some("hitsPerPage")
+        } else {
+            None
+        }
+    }
+
+    pub fn into_index_query_federation(self) -> (IndexUid, SearchQuery, Option<FederationOptions>) {
         let SearchQueryWithIndex {
             index_uid,
+            federation_options,
             q,
             vector,
             offset,
@@ -454,8 +482,8 @@ impl SearchQueryWithIndex {
             SearchQuery {
                 q,
                 vector,
-                offset,
-                limit,
+                offset: offset.unwrap_or(DEFAULT_SEARCH_OFFSET()),
+                limit: limit.unwrap_or(DEFAULT_SEARCH_LIMIT()),
                 page,
                 hits_per_page,
                 attributes_to_retrieve,
@@ -480,6 +508,7 @@ impl SearchQueryWithIndex {
                 // do not use ..Default::default() here,
                 // rather add any missing field from `SearchQuery` to `SearchQueryWithIndex`
             },
+            federation_options,
         )
     }
 }
@@ -864,15 +893,7 @@ pub fn perform_search(
             used_negative_operator,
         },
         semantic_hit_count,
-    ) = match &search_kind {
-        SearchKind::KeywordOnly => (search.execute()?, None),
-        SearchKind::SemanticOnly { .. } => {
-            let results = search.execute()?;
-            let semantic_hit_count = results.document_scores.len() as u32;
-            (results, Some(semantic_hit_count))
-        }
-        SearchKind::Hybrid { semantic_ratio, .. } => search.execute_hybrid(*semantic_ratio)?,
-    };
+    ) = search_from_kind(search_kind, search)?;
 
     let SearchQuery {
         q,
@@ -919,8 +940,13 @@ pub fn perform_search(
         show_ranking_score_details,
     };
 
-    let documents =
-        make_hits(index, &rtxn, format, matching_words, documents_ids, document_scores)?;
+    let documents = make_hits(
+        index,
+        &rtxn,
+        format,
+        matching_words,
+        documents_ids.iter().copied().zip(document_scores.iter()),
+    )?;
 
     let number_of_hits = min(candidates.len() as usize, max_total_hits);
     let hits_info = if is_finite_pagination {
@@ -988,6 +1014,22 @@ pub fn perform_search(
     Ok(result)
 }
 
+pub fn search_from_kind(
+    search_kind: SearchKind,
+    search: milli::Search<'_>,
+) -> Result<(milli::SearchResult, Option<u32>), MeilisearchHttpError> {
+    let (milli_result, semantic_hit_count) = match &search_kind {
+        SearchKind::KeywordOnly => (search.execute()?, None),
+        SearchKind::SemanticOnly { .. } => {
+            let results = search.execute()?;
+            let semantic_hit_count = results.document_scores.len() as u32;
+            (results, Some(semantic_hit_count))
+        }
+        SearchKind::Hybrid { semantic_ratio, .. } => search.execute_hybrid(*semantic_ratio)?,
+    };
+    Ok((milli_result, semantic_hit_count))
+}
+
 struct AttributesFormat {
     attributes_to_retrieve: Option<BTreeSet<String>>,
     retrieve_vectors: RetrieveVectors,
@@ -1033,129 +1075,191 @@ impl RetrieveVectors {
     }
 }
 
-fn make_hits(
-    index: &Index,
-    rtxn: &RoTxn<'_>,
-    format: AttributesFormat,
-    matching_words: milli::MatchingWords,
-    documents_ids: Vec<u32>,
-    document_scores: Vec<Vec<ScoreDetails>>,
-) -> Result<Vec<SearchHit>, MeilisearchHttpError> {
-    let fields_ids_map = index.fields_ids_map(rtxn).unwrap();
-    let displayed_ids =
-        index.displayed_fields_ids(rtxn)?.map(|fields| fields.into_iter().collect::<BTreeSet<_>>());
+struct HitMaker<'a> {
+    index: &'a Index,
+    rtxn: &'a RoTxn<'a>,
+    fields_ids_map: FieldsIdsMap,
+    displayed_ids: BTreeSet<FieldId>,
+    vectors_fid: Option<FieldId>,
+    retrieve_vectors: RetrieveVectors,
+    to_retrieve_ids: BTreeSet<FieldId>,
+    embedding_configs: Vec<milli::index::IndexEmbeddingConfig>,
+    formatter_builder: MatcherBuilder<'a>,
+    formatted_options: BTreeMap<FieldId, FormatOptions>,
+    show_ranking_score: bool,
+    show_ranking_score_details: bool,
+    sort: Option<Vec<String>>,
+    show_matches_position: bool,
+}
 
-    let vectors_fid = fields_ids_map.id(milli::vector::parsed_vectors::RESERVED_VECTORS_FIELD_NAME);
+impl<'a> HitMaker<'a> {
+    pub fn tokenizer<'b>(
+        script_lang_map: &'b HashMap<milli::tokenizer::Script, Vec<milli::tokenizer::Language>>,
+        dictionary: Option<&'b [&'b str]>,
+        separators: Option<&'b [&'b str]>,
+    ) -> milli::tokenizer::Tokenizer<'b> {
+        let mut tokenizer_builder = TokenizerBuilder::default();
+        tokenizer_builder.create_char_map(true);
+        if !script_lang_map.is_empty() {
+            tokenizer_builder.allow_list(script_lang_map);
+        }
 
-    let vectors_is_hidden = match (&displayed_ids, vectors_fid) {
-        // displayed_ids is a wildcard, so `_vectors` can be displayed regardless of its fid
-        (None, _) => false,
-        // displayed_ids is a finite list, and `_vectors` cannot be part of it because it is not an existing field
-        (Some(_), None) => true,
-        // displayed_ids is a finit list, so hide if `_vectors` is not part of it
-        (Some(map), Some(vectors_fid)) => map.contains(&vectors_fid),
-    };
+        if let Some(separators) = separators {
+            tokenizer_builder.separators(separators);
+        }
 
-    let retrieve_vectors = if let RetrieveVectors::Retrieve = format.retrieve_vectors {
-        if vectors_is_hidden {
-            RetrieveVectors::Hide
+        if let Some(dictionary) = dictionary {
+            tokenizer_builder.words_dict(dictionary);
+        }
+
+        tokenizer_builder.into_tokenizer()
+    }
+
+    pub fn formatter_builder(
+        matching_words: milli::MatchingWords,
+        tokenizer: milli::tokenizer::Tokenizer<'_>,
+    ) -> MatcherBuilder<'_> {
+        let formatter_builder = MatcherBuilder::new(matching_words, tokenizer);
+
+        formatter_builder
+    }
+
+    pub fn new(
+        index: &'a Index,
+        rtxn: &'a RoTxn<'a>,
+        format: AttributesFormat,
+        mut formatter_builder: MatcherBuilder<'a>,
+    ) -> Result<Self, MeilisearchHttpError> {
+        formatter_builder.crop_marker(format.crop_marker);
+        formatter_builder.highlight_prefix(format.highlight_pre_tag);
+        formatter_builder.highlight_suffix(format.highlight_post_tag);
+
+        let fields_ids_map = index.fields_ids_map(rtxn)?;
+        let displayed_ids = index
+            .displayed_fields_ids(rtxn)?
+            .map(|fields| fields.into_iter().collect::<BTreeSet<_>>());
+
+        let vectors_fid =
+            fields_ids_map.id(milli::vector::parsed_vectors::RESERVED_VECTORS_FIELD_NAME);
+
+        let vectors_is_hidden = match (&displayed_ids, vectors_fid) {
+            // displayed_ids is a wildcard, so `_vectors` can be displayed regardless of its fid
+            (None, _) => false,
+            // displayed_ids is a finite list, and `_vectors` cannot be part of it because it is not an existing field
+            (Some(_), None) => true,
+            // displayed_ids is a finit list, so hide if `_vectors` is not part of it
+            (Some(map), Some(vectors_fid)) => map.contains(&vectors_fid),
+        };
+
+        let displayed_ids =
+            displayed_ids.unwrap_or_else(|| fields_ids_map.iter().map(|(id, _)| id).collect());
+
+        let retrieve_vectors = if let RetrieveVectors::Retrieve = format.retrieve_vectors {
+            if vectors_is_hidden {
+                RetrieveVectors::Hide
+            } else {
+                RetrieveVectors::Retrieve
+            }
         } else {
-            RetrieveVectors::Retrieve
-        }
-    } else {
-        format.retrieve_vectors
-    };
+            format.retrieve_vectors
+        };
 
-    let displayed_ids =
-        displayed_ids.unwrap_or_else(|| fields_ids_map.iter().map(|(id, _)| id).collect());
-    let fids = |attrs: &BTreeSet<String>| {
-        let mut ids = BTreeSet::new();
-        for attr in attrs {
-            if attr == "*" {
-                ids.clone_from(&displayed_ids);
-                break;
+        let fids = |attrs: &BTreeSet<String>| {
+            let mut ids = BTreeSet::new();
+            for attr in attrs {
+                if attr == "*" {
+                    ids.clone_from(&displayed_ids);
+                    break;
+                }
+
+                if let Some(id) = fields_ids_map.id(attr) {
+                    ids.insert(id);
+                }
             }
+            ids
+        };
+        let to_retrieve_ids: BTreeSet<_> = format
+            .attributes_to_retrieve
+            .as_ref()
+            .map(fids)
+            .unwrap_or_else(|| displayed_ids.clone())
+            .intersection(&displayed_ids)
+            .cloned()
+            .collect();
 
-            if let Some(id) = fields_ids_map.id(attr) {
-                ids.insert(id);
-            }
-        }
-        ids
-    };
-    let to_retrieve_ids: BTreeSet<_> = format
-        .attributes_to_retrieve
-        .as_ref()
-        .map(fids)
-        .unwrap_or_else(|| displayed_ids.clone())
-        .intersection(&displayed_ids)
-        .cloned()
-        .collect();
+        let attr_to_highlight = format.attributes_to_highlight.unwrap_or_default();
+        let attr_to_crop = format.attributes_to_crop.unwrap_or_default();
+        let formatted_options = compute_formatted_options(
+            &attr_to_highlight,
+            &attr_to_crop,
+            format.crop_length,
+            &to_retrieve_ids,
+            &fields_ids_map,
+            &displayed_ids,
+        );
 
-    let attr_to_highlight = format.attributes_to_highlight.unwrap_or_default();
-    let attr_to_crop = format.attributes_to_crop.unwrap_or_default();
-    let formatted_options = compute_formatted_options(
-        &attr_to_highlight,
-        &attr_to_crop,
-        format.crop_length,
-        &to_retrieve_ids,
-        &fields_ids_map,
-        &displayed_ids,
-    );
-    let mut tokenizer_builder = TokenizerBuilder::default();
-    tokenizer_builder.create_char_map(true);
-    let script_lang_map = index.script_language(rtxn)?;
-    if !script_lang_map.is_empty() {
-        tokenizer_builder.allow_list(&script_lang_map);
+        let embedding_configs = index.embedding_configs(rtxn)?;
+
+        Ok(Self {
+            index,
+            rtxn,
+            fields_ids_map,
+            displayed_ids,
+            vectors_fid,
+            retrieve_vectors,
+            to_retrieve_ids,
+            embedding_configs,
+            formatter_builder,
+            formatted_options,
+            show_ranking_score: format.show_ranking_score,
+            show_ranking_score_details: format.show_ranking_score_details,
+            show_matches_position: format.show_matches_position,
+            sort: format.sort,
+        })
     }
-    let separators = index.allowed_separators(rtxn)?;
-    let separators: Option<Vec<_>> =
-        separators.as_ref().map(|x| x.iter().map(String::as_str).collect());
-    if let Some(ref separators) = separators {
-        tokenizer_builder.separators(separators);
-    }
-    let dictionary = index.dictionary(rtxn)?;
-    let dictionary: Option<Vec<_>> =
-        dictionary.as_ref().map(|x| x.iter().map(String::as_str).collect());
-    if let Some(ref dictionary) = dictionary {
-        tokenizer_builder.words_dict(dictionary);
-    }
-    let mut formatter_builder = MatcherBuilder::new(matching_words, tokenizer_builder.build());
-    formatter_builder.crop_marker(format.crop_marker);
-    formatter_builder.highlight_prefix(format.highlight_pre_tag);
-    formatter_builder.highlight_suffix(format.highlight_post_tag);
-    let mut documents = Vec::new();
-    let embedding_configs = index.embedding_configs(rtxn)?;
-    let documents_iter = index.documents(rtxn, documents_ids)?;
-    for ((id, obkv), score) in documents_iter.into_iter().zip(document_scores.into_iter()) {
+
+    pub fn make_hit(
+        &self,
+        id: u32,
+        score: &[ScoreDetails],
+    ) -> Result<SearchHit, MeilisearchHttpError> {
+        let (_, obkv) =
+            self.index.iter_documents(self.rtxn, std::iter::once(id))?.next().unwrap()?;
+
         // First generate a document with all the displayed fields
-        let displayed_document = make_document(&displayed_ids, &fields_ids_map, obkv)?;
+        let displayed_document = make_document(&self.displayed_ids, &self.fields_ids_map, obkv)?;
 
         let add_vectors_fid =
-            vectors_fid.filter(|_fid| retrieve_vectors == RetrieveVectors::Retrieve);
+            self.vectors_fid.filter(|_fid| self.retrieve_vectors == RetrieveVectors::Retrieve);
 
         // select the attributes to retrieve
-        let attributes_to_retrieve = to_retrieve_ids
+        let attributes_to_retrieve = self
+            .to_retrieve_ids
             .iter()
             // skip the vectors_fid if RetrieveVectors::Hide
-            .filter(|fid| match vectors_fid {
+            .filter(|fid| match self.vectors_fid {
                 Some(vectors_fid) => {
-                    !(retrieve_vectors == RetrieveVectors::Hide && **fid == vectors_fid)
+                    !(self.retrieve_vectors == RetrieveVectors::Hide && **fid == vectors_fid)
                 }
                 None => true,
             })
             // need to retrieve the existing `_vectors` field if the `RetrieveVectors::Retrieve`
             .chain(add_vectors_fid.iter())
-            .map(|&fid| fields_ids_map.name(fid).expect("Missing field name"));
+            .map(|&fid| self.fields_ids_map.name(fid).expect("Missing field name"));
+
         let mut document =
             permissive_json_pointer::select_values(&displayed_document, attributes_to_retrieve);
 
-        if retrieve_vectors == RetrieveVectors::Retrieve {
+        if self.retrieve_vectors == RetrieveVectors::Retrieve {
+            // Clippy is wrong
+            #[allow(clippy::manual_unwrap_or_default)]
             let mut vectors = match document.remove("_vectors") {
                 Some(Value::Object(map)) => map,
                 _ => Default::default(),
             };
-            for (name, vector) in index.embeddings(rtxn, id)? {
-                let user_provided = embedding_configs
+            for (name, vector) in self.index.embeddings(self.rtxn, id)? {
+                let user_provided = self
+                    .embedding_configs
                     .iter()
                     .find(|conf| conf.name == name)
                     .is_some_and(|conf| conf.user_provided.contains(id));
@@ -1168,21 +1272,21 @@ fn make_hits(
 
         let (matches_position, formatted) = format_fields(
             &displayed_document,
-            &fields_ids_map,
-            &formatter_builder,
-            &formatted_options,
-            format.show_matches_position,
-            &displayed_ids,
+            &self.fields_ids_map,
+            &self.formatter_builder,
+            &self.formatted_options,
+            self.show_matches_position,
+            &self.displayed_ids,
         )?;
 
-        if let Some(sort) = format.sort.as_ref() {
+        if let Some(sort) = self.sort.as_ref() {
             insert_geo_distance(sort, &mut document);
         }
 
         let ranking_score =
-            format.show_ranking_score.then(|| ScoreDetails::global_score(score.iter()));
+            self.show_ranking_score.then(|| ScoreDetails::global_score(score.iter()));
         let ranking_score_details =
-            format.show_ranking_score_details.then(|| ScoreDetails::to_json_map(score.iter()));
+            self.show_ranking_score_details.then(|| ScoreDetails::to_json_map(score.iter()));
 
         let hit = SearchHit {
             document,
@@ -1191,7 +1295,38 @@ fn make_hits(
             ranking_score_details,
             ranking_score,
         };
-        documents.push(hit);
+
+        Ok(hit)
+    }
+}
+
+fn make_hits<'a>(
+    index: &Index,
+    rtxn: &RoTxn<'_>,
+    format: AttributesFormat,
+    matching_words: milli::MatchingWords,
+    documents_ids_scores: impl Iterator<Item = (u32, &'a Vec<ScoreDetails>)> + 'a,
+) -> Result<Vec<SearchHit>, MeilisearchHttpError> {
+    let mut documents = Vec::new();
+
+    let script_lang_map = index.script_language(rtxn)?;
+
+    let dictionary = index.dictionary(rtxn)?;
+    let dictionary: Option<Vec<_>> =
+        dictionary.as_ref().map(|x| x.iter().map(String::as_str).collect());
+    let separators = index.allowed_separators(rtxn)?;
+    let separators: Option<Vec<_>> =
+        separators.as_ref().map(|x| x.iter().map(String::as_str).collect());
+
+    let tokenizer =
+        HitMaker::tokenizer(&script_lang_map, dictionary.as_deref(), separators.as_deref());
+
+    let formatter_builder = HitMaker::formatter_builder(matching_words, tokenizer);
+
+    let hit_maker = HitMaker::new(index, rtxn, format, formatter_builder)?;
+
+    for (id, score) in documents_ids_scores {
+        documents.push(hit_maker.make_hit(id, score)?);
     }
     Ok(documents)
 }
@@ -1307,7 +1442,13 @@ pub fn perform_similar(
         show_ranking_score_details,
     };
 
-    let hits = make_hits(index, &rtxn, format, Default::default(), documents_ids, document_scores)?;
+    let hits = make_hits(
+        index,
+        &rtxn,
+        format,
+        Default::default(),
+        documents_ids.iter().copied().zip(document_scores.iter()),
+    )?;
 
     let max_total_hits = index
         .pagination_max_total_hits(&rtxn)
@@ -1480,10 +1621,10 @@ fn make_document(
     Ok(document)
 }
 
-fn format_fields<'a>(
+fn format_fields(
     document: &Document,
     field_ids_map: &FieldsIdsMap,
-    builder: &'a MatcherBuilder<'a>,
+    builder: &MatcherBuilder<'_>,
     formatted_options: &BTreeMap<FieldId, FormatOptions>,
     compute_matches: bool,
     displayable_ids: &BTreeSet<FieldId>,
@@ -1538,9 +1679,9 @@ fn format_fields<'a>(
     Ok((matches_position, document))
 }
 
-fn format_value<'a>(
+fn format_value(
     value: Value,
-    builder: &'a MatcherBuilder<'a>,
+    builder: &MatcherBuilder<'_>,
     format_options: Option<FormatOptions>,
     infos: &mut Vec<MatchBounds>,
     compute_matches: bool,

meilisearch/src/search/ranking_rules.rs

@@ -0,0 +1,823 @@
+use std::collections::HashMap;
+use std::fmt::Write;
+
+use itertools::Itertools as _;
+use meilisearch_types::error::{Code, ResponseError};
+use meilisearch_types::milli::{AscDesc, Criterion, Member, TermsMatchingStrategy};
+
+pub struct RankingRules {
+    canonical_criteria: Vec<Criterion>,
+    canonical_sort: Option<Vec<AscDesc>>,
+    canonicalization_actions: Vec<CanonicalizationAction>,
+    source_criteria: Vec<Criterion>,
+    source_sort: Option<Vec<AscDesc>>,
+}
+
+pub enum CanonicalizationAction {
+    PrependedWords {
+        prepended_index: RankingRuleSource,
+    },
+    RemovedDuplicate {
+        earlier_occurrence: RankingRuleSource,
+        removed_occurrence: RankingRuleSource,
+    },
+    RemovedWords {
+        reason: RemoveWords,
+        removed_occurrence: RankingRuleSource,
+    },
+    RemovedPlaceholder {
+        removed_occurrence: RankingRuleSource,
+    },
+    TruncatedVector {
+        vector_rule: RankingRuleSource,
+        truncated_from: RankingRuleSource,
+    },
+    RemovedVector {
+        vector_rule: RankingRuleSource,
+        removed_occurrence: RankingRuleSource,
+    },
+    RemovedSort {
+        removed_occurrence: RankingRuleSource,
+    },
+}
+
+pub enum RemoveWords {
+    WasPrepended,
+    MatchingStrategyAll,
+}
+
+impl std::fmt::Display for RemoveWords {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            RemoveWords::WasPrepended => "it was previously prepended",
+            RemoveWords::MatchingStrategyAll => "`query.matchingWords` is set to `all`",
+        };
+        f.write_str(reason)
+    }
+}
+
+pub enum CanonicalizationKind {
+    Placeholder,
+    Keyword,
+    Vector,
+}
+
+pub struct CompatibilityError {
+    previous: RankingRule,
+    current: RankingRule,
+}
+impl CompatibilityError {
+    pub(crate) fn to_response_error(
+        &self,
+        ranking_rules: &RankingRules,
+        previous_ranking_rules: &RankingRules,
+        query_index: usize,
+        previous_query_index: usize,
+        index_uid: &str,
+        previous_index_uid: &str,
+    ) -> meilisearch_types::error::ResponseError {
+        let rule = self.current.as_string(
+            &ranking_rules.canonical_criteria,
+            &ranking_rules.canonical_sort,
+            query_index,
+            index_uid,
+        );
+        let previous_rule = self.previous.as_string(
+            &previous_ranking_rules.canonical_criteria,
+            &previous_ranking_rules.canonical_sort,
+            previous_query_index,
+            previous_index_uid,
+        );
+
+        let canonicalization_actions = ranking_rules.canonicalization_notes();
+        let previous_canonicalization_actions = previous_ranking_rules.canonicalization_notes();
+
+        let mut msg = String::new();
+        let reason = self.reason();
+        let _ = writeln!(
+            &mut msg,
+            "The results of queries #{previous_query_index} and #{query_index} are incompatible: "
+        );
+        let _ = writeln!(&mut msg, "  1. {previous_rule}");
+        let _ = writeln!(&mut msg, "  2. {rule}");
+        let _ = writeln!(&mut msg, "  - {reason}");
+
+        if !previous_canonicalization_actions.is_empty() {
+            let _ = write!(&mut msg, "  - note: The ranking rules of query #{previous_query_index} were modified during canonicalization:\n{previous_canonicalization_actions}");
+        }
+
+        if !canonicalization_actions.is_empty() {
+            let _ = write!(&mut msg, "  - note: The ranking rules of query #{query_index} were modified during canonicalization:\n{canonicalization_actions}");
+        }
+
+        ResponseError::from_msg(msg, Code::InvalidMultiSearchQueryRankingRules)
+    }
+    pub fn reason(&self) -> &'static str {
+        match (self.previous.kind, self.current.kind) {
+            (RankingRuleKind::Relevancy, RankingRuleKind::AscendingSort)
+            | (RankingRuleKind::Relevancy, RankingRuleKind::DescendingSort)
+            | (RankingRuleKind::AscendingSort, RankingRuleKind::Relevancy)
+            | (RankingRuleKind::DescendingSort, RankingRuleKind::Relevancy) => {
+                "cannot compare a relevancy rule with a sort rule"
+            }
+
+            (RankingRuleKind::Relevancy, RankingRuleKind::AscendingGeoSort)
+            | (RankingRuleKind::Relevancy, RankingRuleKind::DescendingGeoSort)
+            | (RankingRuleKind::AscendingGeoSort, RankingRuleKind::Relevancy)
+            | (RankingRuleKind::DescendingGeoSort, RankingRuleKind::Relevancy) => {
+                "cannot compare a relevancy rule with a sort rule"
+            }
+
+            (RankingRuleKind::AscendingSort, RankingRuleKind::DescendingSort)
+            | (RankingRuleKind::DescendingSort, RankingRuleKind::AscendingSort) => {
+                "cannot compare two sort rules in opposite directions"
+            }
+
+            (RankingRuleKind::AscendingSort, RankingRuleKind::AscendingGeoSort)
+            | (RankingRuleKind::AscendingSort, RankingRuleKind::DescendingGeoSort)
+            | (RankingRuleKind::DescendingSort, RankingRuleKind::AscendingGeoSort)
+            | (RankingRuleKind::DescendingSort, RankingRuleKind::DescendingGeoSort)
+            | (RankingRuleKind::AscendingGeoSort, RankingRuleKind::AscendingSort)
+            | (RankingRuleKind::AscendingGeoSort, RankingRuleKind::DescendingSort)
+            | (RankingRuleKind::DescendingGeoSort, RankingRuleKind::AscendingSort)
+            | (RankingRuleKind::DescendingGeoSort, RankingRuleKind::DescendingSort) => {
+                "cannot compare a sort rule with a geosort rule"
+            }
+
+            (RankingRuleKind::AscendingGeoSort, RankingRuleKind::DescendingGeoSort)
+            | (RankingRuleKind::DescendingGeoSort, RankingRuleKind::AscendingGeoSort) => {
+                "cannot compare two geosort rules in opposite directions"
+            }
+            (RankingRuleKind::Relevancy, RankingRuleKind::Relevancy)
+            | (RankingRuleKind::AscendingSort, RankingRuleKind::AscendingSort)
+            | (RankingRuleKind::DescendingSort, RankingRuleKind::DescendingSort)
+            | (RankingRuleKind::AscendingGeoSort, RankingRuleKind::AscendingGeoSort)
+            | (RankingRuleKind::DescendingGeoSort, RankingRuleKind::DescendingGeoSort) => {
+                "internal error, comparison should be possible"
+            }
+        }
+    }
+}
+
+impl RankingRules {
+    pub fn new(
+        criteria: Vec<Criterion>,
+        sort: Option<Vec<AscDesc>>,
+        terms_matching_strategy: TermsMatchingStrategy,
+        canonicalization_kind: CanonicalizationKind,
+    ) -> Self {
+        let (canonical_criteria, canonical_sort, canonicalization_actions) =
+            Self::canonicalize(&criteria, &sort, terms_matching_strategy, canonicalization_kind);
+        Self {
+            canonical_criteria,
+            canonical_sort,
+            canonicalization_actions,
+            source_criteria: criteria,
+            source_sort: sort,
+        }
+    }
+
+    fn canonicalize(
+        criteria: &[Criterion],
+        sort: &Option<Vec<AscDesc>>,
+        terms_matching_strategy: TermsMatchingStrategy,
+        canonicalization_kind: CanonicalizationKind,
+    ) -> (Vec<Criterion>, Option<Vec<AscDesc>>, Vec<CanonicalizationAction>) {
+        match canonicalization_kind {
+            CanonicalizationKind::Placeholder => Self::canonicalize_placeholder(criteria, sort),
+            CanonicalizationKind::Keyword => {
+                Self::canonicalize_keyword(criteria, sort, terms_matching_strategy)
+            }
+            CanonicalizationKind::Vector => Self::canonicalize_vector(criteria, sort),
+        }
+    }
+
+    fn canonicalize_placeholder(
+        criteria: &[Criterion],
+        sort_query: &Option<Vec<AscDesc>>,
+    ) -> (Vec<Criterion>, Option<Vec<AscDesc>>, Vec<CanonicalizationAction>) {
+        let mut sort = None;
+
+        let mut sorted_fields = HashMap::new();
+        let mut canonicalization_actions = Vec::new();
+        let mut canonical_criteria = Vec::new();
+        let mut canonical_sort = None;
+
+        for (criterion_index, criterion) in criteria.iter().enumerate() {
+            match criterion.clone() {
+                Criterion::Words
+                | Criterion::Typo
+                | Criterion::Proximity
+                | Criterion::Attribute
+                | Criterion::Exactness => {
+                    canonicalization_actions.push(CanonicalizationAction::RemovedPlaceholder {
+                        removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                    })
+                }
+
+                Criterion::Sort => {
+                    if let Some(previous_index) = sort {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: RankingRuleSource::Criterion(previous_index),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        });
+                    } else if let Some(sort_query) = sort_query {
+                        sort = Some(criterion_index);
+                        canonical_criteria.push(criterion.clone());
+                        canonical_sort = Some(canonicalize_sort(
+                            &mut sorted_fields,
+                            sort_query.as_slice(),
+                            criterion_index,
+                            &mut canonicalization_actions,
+                        ));
+                    } else {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedSort {
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        })
+                    }
+                }
+                Criterion::Asc(s) | Criterion::Desc(s) => match sorted_fields.entry(s) {
+                    std::collections::hash_map::Entry::Occupied(entry) => canonicalization_actions
+                        .push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: *entry.get(),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        }),
+                    std::collections::hash_map::Entry::Vacant(entry) => {
+                        entry.insert(RankingRuleSource::Criterion(criterion_index));
+                        canonical_criteria.push(criterion.clone())
+                    }
+                },
+            }
+        }
+
+        (canonical_criteria, canonical_sort, canonicalization_actions)
+    }
+
+    fn canonicalize_vector(
+        criteria: &[Criterion],
+        sort_query: &Option<Vec<AscDesc>>,
+    ) -> (Vec<Criterion>, Option<Vec<AscDesc>>, Vec<CanonicalizationAction>) {
+        let mut sort = None;
+
+        let mut sorted_fields = HashMap::new();
+        let mut canonicalization_actions = Vec::new();
+        let mut canonical_criteria = Vec::new();
+        let mut canonical_sort = None;
+
+        let mut vector = None;
+
+        'criteria: for (criterion_index, criterion) in criteria.iter().enumerate() {
+            match criterion.clone() {
+                Criterion::Words
+                | Criterion::Typo
+                | Criterion::Proximity
+                | Criterion::Attribute
+                | Criterion::Exactness => match vector {
+                    Some(previous_occurrence) => {
+                        if sorted_fields.is_empty() {
+                            canonicalization_actions.push(CanonicalizationAction::RemovedVector {
+                                vector_rule: RankingRuleSource::Criterion(previous_occurrence),
+                                removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                            });
+                        } else {
+                            canonicalization_actions.push(
+                                CanonicalizationAction::TruncatedVector {
+                                    vector_rule: RankingRuleSource::Criterion(previous_occurrence),
+                                    truncated_from: RankingRuleSource::Criterion(criterion_index),
+                                },
+                            );
+                            break 'criteria;
+                        }
+                    }
+                    None => {
+                        canonical_criteria.push(criterion.clone());
+                        vector = Some(criterion_index);
+                    }
+                },
+
+                Criterion::Sort => {
+                    if let Some(previous_index) = sort {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: RankingRuleSource::Criterion(previous_index),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        });
+                    } else if let Some(sort_query) = sort_query {
+                        sort = Some(criterion_index);
+                        canonical_criteria.push(criterion.clone());
+                        canonical_sort = Some(canonicalize_sort(
+                            &mut sorted_fields,
+                            sort_query.as_slice(),
+                            criterion_index,
+                            &mut canonicalization_actions,
+                        ));
+                    } else {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedSort {
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        })
+                    }
+                }
+                Criterion::Asc(s) | Criterion::Desc(s) => match sorted_fields.entry(s) {
+                    std::collections::hash_map::Entry::Occupied(entry) => canonicalization_actions
+                        .push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: *entry.get(),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        }),
+                    std::collections::hash_map::Entry::Vacant(entry) => {
+                        entry.insert(RankingRuleSource::Criterion(criterion_index));
+                        canonical_criteria.push(criterion.clone())
+                    }
+                },
+            }
+        }
+
+        (canonical_criteria, canonical_sort, canonicalization_actions)
+    }
+
+    fn canonicalize_keyword(
+        criteria: &[Criterion],
+        sort_query: &Option<Vec<AscDesc>>,
+        terms_matching_strategy: TermsMatchingStrategy,
+    ) -> (Vec<Criterion>, Option<Vec<AscDesc>>, Vec<CanonicalizationAction>) {
+        let mut words = None;
+        let mut typo = None;
+        let mut proximity = None;
+        let mut sort = None;
+        let mut attribute = None;
+        let mut exactness = None;
+        let mut sorted_fields = HashMap::new();
+
+        let mut canonical_criteria = Vec::new();
+        let mut canonical_sort = None;
+
+        let mut canonicalization_actions = Vec::new();
+
+        for (criterion_index, criterion) in criteria.iter().enumerate() {
+            let criterion = criterion.clone();
+            match criterion.clone() {
+                Criterion::Words => {
+                    if let TermsMatchingStrategy::All = terms_matching_strategy {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedWords {
+                            reason: RemoveWords::MatchingStrategyAll,
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        });
+                        continue;
+                    }
+                    if let Some(maybe_previous_index) = words {
+                        if let Some(previous_index) = maybe_previous_index {
+                            canonicalization_actions.push(
+                                CanonicalizationAction::RemovedDuplicate {
+                                    earlier_occurrence: RankingRuleSource::Criterion(
+                                        previous_index,
+                                    ),
+                                    removed_occurrence: RankingRuleSource::Criterion(
+                                        criterion_index,
+                                    ),
+                                },
+                            );
+                            continue;
+                        }
+                        canonicalization_actions.push(CanonicalizationAction::RemovedWords {
+                            reason: RemoveWords::WasPrepended,
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        })
+                    }
+                    words = Some(Some(criterion_index));
+                    canonical_criteria.push(criterion);
+                }
+                Criterion::Typo => {
+                    canonicalize_criterion(
+                        criterion,
+                        criterion_index,
+                        terms_matching_strategy,
+                        &mut words,
+                        &mut canonicalization_actions,
+                        &mut canonical_criteria,
+                        &mut typo,
+                    );
+                }
+                Criterion::Proximity => {
+                    canonicalize_criterion(
+                        criterion,
+                        criterion_index,
+                        terms_matching_strategy,
+                        &mut words,
+                        &mut canonicalization_actions,
+                        &mut canonical_criteria,
+                        &mut proximity,
+                    );
+                }
+                Criterion::Attribute => {
+                    canonicalize_criterion(
+                        criterion,
+                        criterion_index,
+                        terms_matching_strategy,
+                        &mut words,
+                        &mut canonicalization_actions,
+                        &mut canonical_criteria,
+                        &mut attribute,
+                    );
+                }
+                Criterion::Exactness => {
+                    canonicalize_criterion(
+                        criterion,
+                        criterion_index,
+                        terms_matching_strategy,
+                        &mut words,
+                        &mut canonicalization_actions,
+                        &mut canonical_criteria,
+                        &mut exactness,
+                    );
+                }
+
+                Criterion::Sort => {
+                    if let Some(previous_index) = sort {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: RankingRuleSource::Criterion(previous_index),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        });
+                    } else if let Some(sort_query) = sort_query {
+                        sort = Some(criterion_index);
+                        canonical_criteria.push(criterion);
+                        canonical_sort = Some(canonicalize_sort(
+                            &mut sorted_fields,
+                            sort_query.as_slice(),
+                            criterion_index,
+                            &mut canonicalization_actions,
+                        ));
+                    } else {
+                        canonicalization_actions.push(CanonicalizationAction::RemovedSort {
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        })
+                    }
+                }
+                Criterion::Asc(s) | Criterion::Desc(s) => match sorted_fields.entry(s) {
+                    std::collections::hash_map::Entry::Occupied(entry) => canonicalization_actions
+                        .push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: *entry.get(),
+                            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+                        }),
+                    std::collections::hash_map::Entry::Vacant(entry) => {
+                        entry.insert(RankingRuleSource::Criterion(criterion_index));
+                        canonical_criteria.push(criterion)
+                    }
+                },
+            }
+        }
+
+        (canonical_criteria, canonical_sort, canonicalization_actions)
+    }
+
+    pub fn is_compatible_with(&self, previous: &Self) -> Result<(), CompatibilityError> {
+        for (current, previous) in self.coalesce_iterator().zip(previous.coalesce_iterator()) {
+            if current.kind != previous.kind {
+                return Err(CompatibilityError { current, previous });
+            }
+        }
+        Ok(())
+    }
+
+    pub fn constraint_count(&self) -> usize {
+        self.coalesce_iterator().count()
+    }
+
+    fn coalesce_iterator(&self) -> impl Iterator<Item = RankingRule> + '_ {
+        self.canonical_criteria
+            .iter()
+            .enumerate()
+            .flat_map(|(criterion_index, criterion)| {
+                RankingRule::from_criterion(criterion_index, criterion, &self.canonical_sort)
+            })
+            .coalesce(
+                |previous @ RankingRule { source: previous_source, kind: previous_kind },
+                 current @ RankingRule { source, kind }| {
+                    match (previous_kind, kind) {
+                        (RankingRuleKind::Relevancy, RankingRuleKind::Relevancy) => {
+                            let merged_source = match (previous_source, source) {
+                                (
+                                    RankingRuleSource::Criterion(previous),
+                                    RankingRuleSource::Criterion(current),
+                                ) => RankingRuleSource::CoalescedCriteria(previous, current),
+                                (
+                                    RankingRuleSource::CoalescedCriteria(begin, _end),
+                                    RankingRuleSource::Criterion(current),
+                                ) => RankingRuleSource::CoalescedCriteria(begin, current),
+                                (_previous, current) => current,
+                            };
+                            Ok(RankingRule { source: merged_source, kind })
+                        }
+                        _ => Err((previous, current)),
+                    }
+                },
+            )
+    }
+
+    fn canonicalization_notes(&self) -> String {
+        use CanonicalizationAction::*;
+        let mut notes = String::new();
+        for (index, action) in self.canonicalization_actions.iter().enumerate() {
+            let index = index + 1;
+            let _ = match action {
+                PrependedWords { prepended_index } => writeln!(
+                    &mut notes,
+                    "    {index}. Prepended rule `words` before first relevancy rule `{}` at position {}",
+                    prepended_index.rule_name(&self.source_criteria, &self.source_sort),
+                    prepended_index.rule_position()
+                ),
+                RemovedDuplicate { earlier_occurrence, removed_occurrence } => writeln!(
+                    &mut notes,
+                    "    {index}. Removed duplicate rule `{}` at position {} as it already appears at position {}",
+                    earlier_occurrence.rule_name(&self.source_criteria, &self.source_sort),
+                    removed_occurrence.rule_position(),
+                    earlier_occurrence.rule_position(),
+                ),
+                RemovedWords { reason, removed_occurrence } => writeln!(
+                    &mut notes,
+                    "    {index}. Removed rule `words` at position {} because {reason}",
+                    removed_occurrence.rule_position()
+                ),
+                RemovedPlaceholder { removed_occurrence } => writeln!(
+                    &mut notes,
+                    "    {index}. Removed relevancy rule `{}` at position {} because the query is a placeholder search (`q`: \"\")",
+                    removed_occurrence.rule_name(&self.source_criteria, &self.source_sort),
+                    removed_occurrence.rule_position()
+                ),
+                TruncatedVector { vector_rule, truncated_from } => writeln!(
+                    &mut notes,
+                    "    {index}. Truncated relevancy rule `{}` at position {} and later rules because the query is a vector search and `vector` was inserted at position {}",
+                    truncated_from.rule_name(&self.source_criteria, &self.source_sort),
+                    truncated_from.rule_position(),
+                    vector_rule.rule_position(),
+                ),
+                RemovedVector { vector_rule, removed_occurrence } => writeln!(
+                    &mut notes,
+                    "    {index}. Removed relevancy rule `{}` at position {} because the query is a vector search and `vector` was already inserted at position {}",
+                    removed_occurrence.rule_name(&self.source_criteria, &self.source_sort),
+                    removed_occurrence.rule_position(),
+                    vector_rule.rule_position(),
+                ),
+                RemovedSort { removed_occurrence } => writeln!(
+                    &mut notes,
+                    "   {index}. Removed rule `sort` at position {} because `query.sort` is empty",
+removed_occurrence.rule_position()
+                ),
+            };
+        }
+        notes
+    }
+}
+
+fn canonicalize_sort(
+    sorted_fields: &mut HashMap<String, RankingRuleSource>,
+    sort_query: &[AscDesc],
+    criterion_index: usize,
+    canonicalization_actions: &mut Vec<CanonicalizationAction>,
+) -> Vec<AscDesc> {
+    let mut geo_sorted = None;
+    let mut canonical_sort = Vec::new();
+    for (sort_index, asc_desc) in sort_query.iter().enumerate() {
+        let source = RankingRuleSource::Sort { criterion_index, sort_index };
+        let asc_desc = asc_desc.clone();
+        match asc_desc.clone() {
+            AscDesc::Asc(Member::Field(s)) | AscDesc::Desc(Member::Field(s)) => {
+                match sorted_fields.entry(s) {
+                    std::collections::hash_map::Entry::Occupied(entry) => canonicalization_actions
+                        .push(CanonicalizationAction::RemovedDuplicate {
+                            earlier_occurrence: *entry.get(),
+                            removed_occurrence: source,
+                        }),
+                    std::collections::hash_map::Entry::Vacant(entry) => {
+                        entry.insert(source);
+                        canonical_sort.push(asc_desc);
+                    }
+                }
+            }
+            AscDesc::Asc(Member::Geo(_)) | AscDesc::Desc(Member::Geo(_)) => match geo_sorted {
+                Some(earlier_sort_index) => {
+                    canonicalization_actions.push(CanonicalizationAction::RemovedDuplicate {
+                        earlier_occurrence: RankingRuleSource::Sort {
+                            criterion_index,
+                            sort_index: earlier_sort_index,
+                        },
+                        removed_occurrence: source,
+                    })
+                }
+                None => {
+                    geo_sorted = Some(sort_index);
+                    canonical_sort.push(asc_desc);
+                }
+            },
+        }
+    }
+    canonical_sort
+}
+
+fn canonicalize_criterion(
+    criterion: Criterion,
+    criterion_index: usize,
+    terms_matching_strategy: TermsMatchingStrategy,
+    words: &mut Option<Option<usize>>,
+    canonicalization_actions: &mut Vec<CanonicalizationAction>,
+    canonical_criteria: &mut Vec<Criterion>,
+    rule: &mut Option<usize>,
+) {
+    *words = match (terms_matching_strategy, words.take()) {
+        (TermsMatchingStrategy::All, words) => words,
+        (_, None) => {
+            // inject words
+            canonicalization_actions.push(CanonicalizationAction::PrependedWords {
+                prepended_index: RankingRuleSource::Criterion(criterion_index),
+            });
+            canonical_criteria.push(Criterion::Words);
+            Some(None)
+        }
+        (_, words) => words,
+    };
+    if let Some(previous_index) = *rule {
+        canonicalization_actions.push(CanonicalizationAction::RemovedDuplicate {
+            earlier_occurrence: RankingRuleSource::Criterion(previous_index),
+            removed_occurrence: RankingRuleSource::Criterion(criterion_index),
+        });
+    } else {
+        *rule = Some(criterion_index);
+        canonical_criteria.push(criterion)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum RankingRuleKind {
+    Relevancy,
+    AscendingSort,
+    DescendingSort,
+    AscendingGeoSort,
+    DescendingGeoSort,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct RankingRule {
+    source: RankingRuleSource,
+    kind: RankingRuleKind,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum RankingRuleSource {
+    Criterion(usize),
+    CoalescedCriteria(usize, usize),
+    Sort { criterion_index: usize, sort_index: usize },
+}
+
+impl RankingRuleSource {
+    fn rule_name(&self, criteria: &[Criterion], sort: &Option<Vec<AscDesc>>) -> String {
+        match self {
+            RankingRuleSource::Criterion(criterion_index) => criteria
+                .get(*criterion_index)
+                .map(|c| c.to_string())
+                .unwrap_or_else(|| "unknown".into()),
+            RankingRuleSource::CoalescedCriteria(begin, end) => {
+                let rules: Vec<_> = criteria
+                    .get(*begin..=*end)
+                    .iter()
+                    .flat_map(|c| c.iter())
+                    .map(|c| c.to_string())
+                    .collect();
+                rules.join(", ")
+            }
+            RankingRuleSource::Sort { criterion_index: _, sort_index } => {
+                match sort.as_deref().and_then(|sort| sort.get(*sort_index)) {
+                    Some(sort) => match sort {
+                        AscDesc::Asc(Member::Field(field_name)) => format!("{field_name}:asc"),
+                        AscDesc::Desc(Member::Field(field_name)) => {
+                            format!("{field_name}:desc")
+                        }
+                        AscDesc::Asc(Member::Geo(_)) => "_geo(..):asc".to_string(),
+                        AscDesc::Desc(Member::Geo(_)) => "_geo(..):desc".to_string(),
+                    },
+                    None => "unknown".into(),
+                }
+            }
+        }
+    }
+
+    fn rule_position(&self) -> String {
+        match self {
+            RankingRuleSource::Criterion(criterion_index) => {
+                format!("#{criterion_index} in ranking rules")
+            }
+            RankingRuleSource::CoalescedCriteria(begin, end) => {
+                format!("#{begin} to #{end} in ranking rules")
+            }
+            RankingRuleSource::Sort { criterion_index, sort_index } => format!(
+                "#{sort_index} in `query.sort` (as `sort` is #{criterion_index} in ranking rules)"
+            ),
+        }
+    }
+}
+
+impl RankingRule {
+    fn from_criterion<'a>(
+        criterion_index: usize,
+        criterion: &'a Criterion,
+        sort: &'a Option<Vec<AscDesc>>,
+    ) -> impl Iterator<Item = Self> + 'a {
+        let kind = match criterion {
+            Criterion::Words
+            | Criterion::Typo
+            | Criterion::Proximity
+            | Criterion::Attribute
+            | Criterion::Exactness => RankingRuleKind::Relevancy,
+            Criterion::Asc(s) if s == "_geo" => RankingRuleKind::AscendingGeoSort,
+
+            Criterion::Asc(_) => RankingRuleKind::AscendingSort,
+            Criterion::Desc(s) if s == "_geo" => RankingRuleKind::DescendingGeoSort,
+
+            Criterion::Desc(_) => RankingRuleKind::DescendingSort,
+            Criterion::Sort => {
+                return either::Right(sort.iter().flatten().enumerate().map(
+                    move |(rule_index, asc_desc)| {
+                        Self::from_asc_desc(asc_desc, criterion_index, rule_index)
+                    },
+                ))
+            }
+        };
+
+        either::Left(std::iter::once(Self {
+            source: RankingRuleSource::Criterion(criterion_index),
+            kind,
+        }))
+    }
+
+    fn from_asc_desc(asc_desc: &AscDesc, sort_index: usize, rule_index_in_sort: usize) -> Self {
+        let kind = match asc_desc {
+            AscDesc::Asc(Member::Field(_)) => RankingRuleKind::AscendingSort,
+            AscDesc::Desc(Member::Field(_)) => RankingRuleKind::DescendingSort,
+            AscDesc::Asc(Member::Geo(_)) => RankingRuleKind::AscendingGeoSort,
+            AscDesc::Desc(Member::Geo(_)) => RankingRuleKind::DescendingGeoSort,
+        };
+        Self {
+            source: RankingRuleSource::Sort {
+                criterion_index: sort_index,
+                sort_index: rule_index_in_sort,
+            },
+            kind,
+        }
+    }
+
+    fn as_string(
+        &self,
+        canonical_criteria: &[Criterion],
+        canonical_sort: &Option<Vec<AscDesc>>,
+        query_index: usize,
+        index_uid: &str,
+    ) -> String {
+        let kind = match self.kind {
+            RankingRuleKind::Relevancy => "relevancy",
+            RankingRuleKind::AscendingSort => "ascending sort",
+            RankingRuleKind::DescendingSort => "descending sort",
+            RankingRuleKind::AscendingGeoSort => "ascending geo sort",
+            RankingRuleKind::DescendingGeoSort => "descending geo sort",
+        };
+        let rules = self.fetch_from_source(canonical_criteria, canonical_sort);
+
+        let source = match self.source {
+            RankingRuleSource::Criterion(criterion_index) => format!("`queries[{query_index}]`, `{index_uid}.rankingRules[{criterion_index}]`"),
+            RankingRuleSource::CoalescedCriteria(begin, end) => format!("`queries[{query_index}]`, `{index_uid}.rankingRules[{begin}..={end}]`"),
+            RankingRuleSource::Sort { criterion_index, sort_index } => format!("`queries[{query_index}].sort[{sort_index}]`, `{index_uid}.rankingRules[{criterion_index}]`"),
+        };
+
+        format!("{source}: {kind} {rules}")
+    }
+
+    fn fetch_from_source(
+        &self,
+        canonical_criteria: &[Criterion],
+        canonical_sort: &Option<Vec<AscDesc>>,
+    ) -> String {
+        let rule_name = match self.source {
+            RankingRuleSource::Criterion(index) => {
+                canonical_criteria.get(index).map(|criterion| criterion.to_string())
+            }
+            RankingRuleSource::CoalescedCriteria(begin, end) => {
+                let rules: Vec<String> = canonical_criteria
+                    .get(begin..=end)
+                    .into_iter()
+                    .flat_map(|criteria| criteria.iter())
+                    .map(|criterion| criterion.to_string())
+                    .collect();
+
+                (!rules.is_empty()).then_some(rules.join(", "))
+            }
+            RankingRuleSource::Sort { criterion_index: _, sort_index } => canonical_sort
+                .as_deref()
+                .and_then(|canonical_sort| canonical_sort.get(sort_index))
+                .and_then(|asc_desc: &AscDesc| match asc_desc {
+                    AscDesc::Asc(Member::Field(s)) | AscDesc::Desc(Member::Field(s)) => {
+                        Some(format!("on field `{s}`"))
+                    }
+                    _ => None,
+                }),
+        };
+
+        let rule_name = rule_name.unwrap_or_else(|| "default".into());
+
+        format!("rule(s) {rule_name}")
+    }
+}

meilisearch/tests/auth/errors.rs

@@ -1,5 +1,5 @@
+use actix_web::http::StatusCode;
 use actix_web::test;
-use http::StatusCode;
 use jsonwebtoken::{EncodingKey, Header};
 use meili_snap::*;
 use uuid::Uuid;

meilisearch/tests/auth/tenant_token_multi_search.rs

@@ -310,6 +310,23 @@ macro_rules! compute_authorized_single_search {
                     tenant_token,
                     key_content
                 );
+
+                // federated
+                let (response, code) = server.multi_search(json!({"federation": {}, "queries" : [{"indexUid": "sales", "filter": $filter}]})).await;
+                assert_eq!(
+                    200, code,
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response, tenant_token, key_content
+                );
+                assert_eq!(
+                    // same count as the search is federated over a single query
+                    $expected_count,
+                    response["hits"].as_array().unwrap().len(),
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response,
+                    tenant_token,
+                    key_content
+                );
             }
         }
     };
@@ -375,6 +392,25 @@ macro_rules! compute_authorized_multiple_search {
                     tenant_token,
                     key_content
                 );
+
+                let (response, code) = server.multi_search(json!({"federation": {}, "queries" : [
+                    {"indexUid": "sales", "filter": $filter1},
+                    {"indexUid": "products", "filter": $filter2},
+                ]})).await;
+                assert_eq!(
+                    code, 200,
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response, tenant_token, key_content
+                );
+                assert_eq!(
+                    response["hits"].as_array().unwrap().len(),
+                    // sum of counts as the search is federated across to queries in different indexes
+                    $expected_count1 + $expected_count2,
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response,
+                    tenant_token,
+                    key_content
+                );
             }
         }
     };
@@ -433,6 +469,24 @@ macro_rules! compute_forbidden_single_search {
                     "{} using tenant_token: {:?} generated with parent_key: {:?}",
                     response, tenant_token, key_content
                 );
+
+                let (mut response, code) = server.multi_search(json!({"federation": {}, "queries" : [{"indexUid": "sales"}]})).await;
+                if failed_query_index.is_none() && !response["message"].is_null() {
+                    response["message"] = serde_json::json!(null);
+                }
+                assert_eq!(
+                    response,
+                    invalid_response(failed_query_index),
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response,
+                    tenant_token,
+                    key_content
+                );
+                assert_eq!(
+                    code, 403,
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response, tenant_token, key_content
+                );
             }
         }
     };
@@ -494,6 +548,27 @@ macro_rules! compute_forbidden_multiple_search {
                     "{} using tenant_token: {:?} generated with parent_key: {:?}",
                     response, tenant_token, key_content
                 );
+
+                let (mut response, code) = server.multi_search(json!({"federation": {}, "queries" : [
+                    {"indexUid": "sales"},
+                    {"indexUid": "products"},
+                ]})).await;
+                if failed_query_index.is_none() && !response["message"].is_null() {
+                    response["message"] = serde_json::json!(null);
+                }
+                assert_eq!(
+                    response,
+                    invalid_response(failed_query_index),
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response,
+                    tenant_token,
+                    key_content
+                );
+                assert_eq!(
+                    code, 403,
+                    "{} using tenant_token: {:?} generated with parent_key: {:?}",
+                    response, tenant_token, key_content
+                );
             }
         }
     };

meilisearch/tests/common/server.rs

@@ -6,7 +6,7 @@ use std::time::Duration;
 use actix_http::body::MessageBody;
 use actix_web::dev::ServiceResponse;
 use actix_web::http::StatusCode;
-use byte_unit::{Byte, ByteUnit};
+use byte_unit::{Byte, Unit};
 use clap::Parser;
 use meilisearch::option::{IndexerOpts, MaxMemory, Opt};
 use meilisearch::{analytics, create_app, setup_meilisearch, SubscriberForSecondLayer};
@@ -231,9 +231,9 @@ pub fn default_settings(dir: impl AsRef<Path>) -> Opt {
         env: "development".to_owned(),
         #[cfg(feature = "analytics")]
         no_analytics: true,
-        max_index_size: Byte::from_unit(100.0, ByteUnit::MiB).unwrap(),
-        max_task_db_size: Byte::from_unit(1.0, ByteUnit::GiB).unwrap(),
-        http_payload_size_limit: Byte::from_unit(10.0, ByteUnit::MiB).unwrap(),
+        max_index_size: Byte::from_u64_with_unit(100, Unit::MiB).unwrap(),
+        max_task_db_size: Byte::from_u64_with_unit(1, Unit::GiB).unwrap(),
+        http_payload_size_limit: Byte::from_u64_with_unit(10, Unit::MiB).unwrap(),
         snapshot_dir: ".".into(),
         indexer_options: IndexerOpts {
             // memory has to be unlimited because several meilisearch are running in test context.

meilisearch/tests/documents/add_documents.rs

@@ -2274,7 +2274,7 @@ async fn error_add_documents_payload_size() {
     snapshot!(json_string!(response, { ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
         @r###"
     {
-      "message": "The provided payload reached the size limit. The maximum accepted payload size is 10.00 MiB.",
+      "message": "The provided payload reached the size limit. The maximum accepted payload size is 10 MiB.",
       "code": "payload_too_large",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#payload_too_large"

meilisearch/tests/documents/get_documents.rs

@@ -1,5 +1,5 @@
+use actix_web::http::header::ACCEPT_ENCODING;
 use actix_web::test;
-use http::header::ACCEPT_ENCODING;
 use meili_snap::*;
 use urlencoding::encode as urlencode;
 
@@ -535,7 +535,8 @@ async fn get_document_with_vectors() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/dumps/mod.rs

@@ -1859,7 +1859,8 @@ async fn import_dump_v6_containing_experimental_features() {
     {
       "vectorStore": false,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -1952,7 +1953,8 @@ async fn generate_and_import_dump_containing_vectors() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
     let index = server.index("pets");
@@ -2022,7 +2024,8 @@ async fn generate_and_import_dump_containing_vectors() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/features/mod.rs

@@ -20,7 +20,8 @@ async fn experimental_features() {
     {
       "vectorStore": false,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -31,7 +32,8 @@ async fn experimental_features() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -42,7 +44,8 @@ async fn experimental_features() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -54,7 +57,8 @@ async fn experimental_features() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -66,7 +70,8 @@ async fn experimental_features() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 }
@@ -85,7 +90,8 @@ async fn experimental_feature_metrics() {
     {
       "vectorStore": false,
       "metrics": true,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -140,7 +146,7 @@ async fn errors() {
     meili_snap::snapshot!(code, @"400 Bad Request");
     meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
     {
-      "message": "Unknown field `NotAFeature`: expected one of `vectorStore`, `metrics`, `logsRoute`",
+      "message": "Unknown field `NotAFeature`: expected one of `vectorStore`, `metrics`, `logsRoute`, `editDocumentsByFunction`",
       "code": "bad_request",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#bad_request"

meilisearch/tests/index/create_index.rs

@@ -1,6 +1,5 @@
-use actix_web::http::header::ContentType;
+use actix_web::http::header::{ContentType, ACCEPT_ENCODING};
 use actix_web::test;
-use http::header::ACCEPT_ENCODING;
 use meili_snap::{json_string, snapshot};
 use meilisearch::Opt;
 

meilisearch/tests/search/hybrid.rs

@@ -18,7 +18,8 @@ async fn index_with_documents_user_provided<'a>(
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -46,7 +47,8 @@ async fn index_with_documents_hf<'a>(server: &'a Server, documents: &Value) -> I
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/search/mod.rs

@@ -132,6 +132,79 @@ static NESTED_DOCUMENTS: Lazy<Value> = Lazy::new(|| {
     ])
 });
 
+static FRUITS_DOCUMENTS: Lazy<Value> = Lazy::new(|| {
+    json!([
+        {
+            "name": "Exclusive sale: green apple",
+            "id": "green-apple-boosted",
+            "BOOST": true
+        },
+        {
+            "name": "Pear",
+            "id": "pear",
+        },
+        {
+            "name": "Red apple gala",
+            "id": "red-apple-gala",
+        },
+        {
+            "name": "Exclusive sale: Red Tomato",
+            "id": "red-tomatoes-boosted",
+            "BOOST": true
+        },
+        {
+            "name": "Exclusive sale: Red delicious apple",
+            "id": "red-delicious-boosted",
+            "BOOST": true,
+        }
+    ])
+});
+
+static VECTOR_DOCUMENTS: Lazy<Value> = Lazy::new(|| {
+    json!([
+      {
+        "id": "A",
+        "description": "the dog barks at the cat",
+        "_vectors": {
+          // dimensions [canine, feline, young]
+          "animal": [0.9, 0.8, 0.05],
+          // dimensions [negative/positive, energy]
+          "sentiment": [-0.1, 0.55]
+        }
+      },
+      {
+        "id": "B",
+        "description": "the kitten scratched the beagle",
+        "_vectors": {
+          // dimensions [canine, feline, young]
+          "animal": [0.8, 0.9, 0.5],
+          // dimensions [negative/positive, energy]
+          "sentiment": [-0.2, 0.65]
+        }
+      },
+      {
+        "id": "C",
+        "description": "the dog had to stay alone today",
+        "_vectors": {
+          // dimensions [canine, feline, young]
+          "animal": [0.85, 0.02, 0.1],
+          // dimensions [negative/positive, energy]
+          "sentiment": [-1.0, 0.1]
+        }
+      },
+      {
+        "id": "D",
+        "description": "the little boy pets the puppy",
+        "_vectors": {
+          // dimensions [canine, feline, young]
+          "animal": [0.8, 0.09, 0.8],
+          // dimensions [negative/positive, energy]
+          "sentiment": [0.8, 0.3]
+        }
+      },
+    ])
+});
+
 #[actix_rt::test]
 async fn simple_placeholder_search() {
     let server = Server::new().await;

meilisearch/tests/settings/get_settings.rs

@@ -98,7 +98,8 @@ async fn secrets_are_hidden_in_settings() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/similar/mod.rs

@@ -55,7 +55,8 @@ async fn basic() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -244,7 +245,8 @@ async fn ranking_score_threshold() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -523,7 +525,8 @@ async fn filter() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -650,7 +653,8 @@ async fn limit_and_offset() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/tasks/errors.rs

@@ -97,7 +97,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r###"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"
@@ -108,7 +108,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r###"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"
@@ -119,7 +119,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r###"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"

meilisearch/tests/vector/mod.rs

@@ -16,7 +16,8 @@ async fn add_remove_user_provided() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -159,7 +160,8 @@ async fn generate_default_user_provided_documents(server: &Server) -> Index {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 
@@ -516,7 +518,8 @@ async fn add_remove_one_vector_4588() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilisearch/tests/vector/settings.rs

@@ -14,7 +14,8 @@ async fn update_embedder() {
     {
       "vectorStore": true,
       "metrics": false,
-      "logsRoute": false
+      "logsRoute": false,
+      "editDocumentsByFunction": false
     }
     "###);
 

meilitool/Cargo.toml

@@ -9,11 +9,11 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-anyhow = "1.0.79"
-clap = { version = "4.4.17", features = ["derive"] }
+anyhow = "1.0.86"
+clap = { version = "4.5.9", features = ["derive"] }
 dump = { path = "../dump" }
 file-store = { path = "../file-store" }
 meilisearch-auth = { path = "../meilisearch-auth" }
 meilisearch-types = { path = "../meilisearch-types" }
-time = { version = "0.3.31", features = ["formatting"] }
-uuid = { version = "1.6.1", features = ["v4"], default-features = false }
+time = { version = "0.3.36", features = ["formatting"] }
+uuid = { version = "1.10.0", features = ["v4"], default-features = false }

milli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "milli"
-edition = "2018"
+edition = "2021"
 publish = false
 
 version.workspace = true
@@ -14,81 +14,82 @@ license.workspace = true
 [dependencies]
 bimap = { version = "0.6.3", features = ["serde"] }
 bincode = "1.3.3"
-bstr = "1.9.0"
-bytemuck = { version = "1.14.0", features = ["extern_crate_alloc"] }
+bstr = "1.9.1"
+bytemuck = { version = "1.16.1", features = ["extern_crate_alloc"] }
 byteorder = "1.5.0"
-charabia = { version = "0.8.11", default-features = false }
+charabia = { version = "0.8.12", default-features = false }
 concat-arrays = "0.1.2"
-crossbeam-channel = "0.5.11"
-deserr = "0.6.1"
-either = { version = "1.9.0", features = ["serde"] }
+crossbeam-channel = "0.5.13"
+deserr = "0.6.2"
+either = { version = "1.13.0", features = ["serde"] }
 flatten-serde-json = { path = "../flatten-serde-json" }
 fst = "0.4.7"
 fxhash = "0.2.1"
 geoutils = "0.5.1"
-grenad = { version = "0.4.6", default-features = false, features = [
+grenad = { version = "0.4.7", default-features = false, features = [
     "rayon",
     "tempfile",
 ] }
-heed = { version = "0.20.1", default-features = false, features = [
+heed = { version = "0.20.3", default-features = false, features = [
     "serde-json",
     "serde-bincode",
     "read-txn-no-tls",
 ] }
-indexmap = { version = "2.1.0", features = ["serde"] }
+indexmap = { version = "2.2.6", features = ["serde"] }
 json-depth-checker = { path = "../json-depth-checker" }
 levenshtein_automata = { version = "0.2.1", features = ["fst_automaton"] }
-memmap2 = "0.7.1"
-obkv = "0.2.1"
+memmap2 = "0.9.4"
+obkv = "0.2.2"
 once_cell = "1.19.0"
-ordered-float = "4.2.0"
-rand_pcg = { version = "0.3.1", features = ["serde1"] }
-rayon = "1.8.0"
-roaring = { version = "0.10.2", features = ["serde"] }
-rstar = { version = "0.11.0", features = ["serde"] }
-serde = { version = "1.0.195", features = ["derive"] }
-serde_json = { version = "1.0.111", features = ["preserve_order"] }
+ordered-float = "4.2.1"
+rayon = "1.10.0"
+roaring = { version = "0.10.6", features = ["serde"] }
+rstar = { version = "0.12.0", features = ["serde"] }
+serde = { version = "1.0.204", features = ["derive"] }
+serde_json = { version = "1.0.120", features = ["preserve_order"] }
 slice-group-by = "0.3.1"
 smallstr = { version = "0.3.0", features = ["serde"] }
-smallvec = "1.12.0"
+smallvec = "1.13.2"
 smartstring = "1.0.1"
-tempfile = "3.9.0"
-thiserror = "1.0.56"
-time = { version = "0.3.31", features = [
+tempfile = "3.10.1"
+thiserror = "1.0.61"
+time = { version = "0.3.36", features = [
     "serde-well-known",
     "formatting",
     "parsing",
     "macros",
 ] }
-uuid = { version = "1.6.1", features = ["v4"] }
+uuid = { version = "1.10.0", features = ["v4"] }
 
 filter-parser = { path = "../filter-parser" }
 
 # documents words self-join
-itertools = "0.11.0"
+itertools = "0.13.0"
 
 csv = "1.3.0"
-candle-core = { version = "0.4.1" }
-candle-transformers = { version = "0.4.1" }
-candle-nn = { version = "0.4.1" }
+candle-core = { version = "0.6.0" }
+candle-transformers = { version = "0.6.0" }
+candle-nn = { version = "0.6.0" }
 tokenizers = { git = "https://github.com/huggingface/tokenizers.git", tag = "v0.15.2", version = "0.15.2", default-features = false, features = [
     "onig",
 ] }
 hf-hub = { git = "https://github.com/dureuill/hf-hub.git", branch = "rust_tls", default-features = false, features = [
     "online",
 ] }
-tiktoken-rs = "0.5.8"
-liquid = "0.26.4"
+tiktoken-rs = "0.5.9"
+liquid = "0.26.6"
+rhai = { version = "1.19.0", features = ["serde", "no_module", "no_custom_syntax", "no_time", "sync"] }
 arroy = "0.4.0"
 rand = "0.8.5"
 tracing = "0.1.40"
-ureq = { version = "2.9.7", features = ["json"] }
-url = "2.5.0"
+ureq = { version = "2.10.0", features = ["json"] }
+url = "2.5.2"
+rayon-par-bridge = "0.1.0"
 
 [dev-dependencies]
-mimalloc = { version = "0.1.39", default-features = false }
+mimalloc = { version = "0.1.43", default-features = false }
 big_s = "1.0.2"
-insta = "1.34.0"
+insta = "1.39.0"
 maplit = "1.0.2"
 md5 = "0.7.0"
 meili-snap = { path = "../meili-snap" }

milli/src/documents/enriched.rs

@@ -95,7 +95,7 @@ impl<R: io::Read + io::Seek> EnrichedDocumentsBatchCursor<R> {
     /// `next_document` advance the document reader until all the documents have been read.
     pub fn next_enriched_document(
         &mut self,
-    ) -> Result<Option<EnrichedDocument>, DocumentsBatchCursorError> {
+    ) -> Result<Option<EnrichedDocument<'_>>, DocumentsBatchCursorError> {
         let document = self.documents.next_document()?;
         let document_id = match self.external_ids.move_on_next()? {
             Some((_, bytes)) => serde_json::from_slice(bytes).map(Some)?,

milli/src/documents/mod.rs

@@ -27,7 +27,7 @@ use crate::{FieldId, Object, Result};
 const DOCUMENTS_BATCH_INDEX_KEY: [u8; 8] = u64::MAX.to_be_bytes();
 
 /// Helper function to convert an obkv reader into a JSON object.
-pub fn obkv_to_object(obkv: &KvReader<FieldId>, index: &DocumentsBatchIndex) -> Result<Object> {
+pub fn obkv_to_object(obkv: &KvReader<'_, FieldId>, index: &DocumentsBatchIndex) -> Result<Object> {
     obkv.iter()
         .map(|(field_id, value)| {
             let field_name = index
@@ -64,7 +64,7 @@ impl DocumentsBatchIndex {
         self.0.len()
     }
 
-    pub fn iter(&self) -> bimap::hash::Iter<FieldId, String> {
+    pub fn iter(&self) -> bimap::hash::Iter<'_, FieldId, String> {
         self.0.iter()
     }
 
@@ -76,7 +76,7 @@ impl DocumentsBatchIndex {
         self.0.get_by_right(name).cloned()
     }
 
-    pub fn recreate_json(&self, document: &obkv::KvReaderU16) -> Result<Object> {
+    pub fn recreate_json(&self, document: &obkv::KvReaderU16<'_>) -> Result<Object> {
         let mut map = Object::new();
 
         for (k, v) in document.iter() {

milli/src/documents/primary_key.rs

@@ -52,7 +52,7 @@ impl<'a> PrimaryKey<'a> {
 
     pub fn document_id(
         &self,
-        document: &obkv::KvReader<FieldId>,
+        document: &obkv::KvReader<'_, FieldId>,
         fields: &impl FieldIdMapper,
     ) -> Result<StdResult<String, DocumentIdExtractionError>> {
         match self {

milli/src/documents/reader.rs

@@ -76,7 +76,7 @@ impl<R: io::Read + io::Seek> DocumentsBatchCursor<R> {
     /// `next_document` advance the document reader until all the documents have been read.
     pub fn next_document(
         &mut self,
-    ) -> Result<Option<KvReader<FieldId>>, DocumentsBatchCursorError> {
+    ) -> Result<Option<KvReader<'_, FieldId>>, DocumentsBatchCursorError> {
         match self.cursor.move_on_next()? {
             Some((key, value)) if key != DOCUMENTS_BATCH_INDEX_KEY => {
                 Ok(Some(KvReader::new(value)))
@@ -108,7 +108,7 @@ impl From<serde_json::Error> for DocumentsBatchCursorError {
 impl error::Error for DocumentsBatchCursorError {}
 
 impl fmt::Display for DocumentsBatchCursorError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             DocumentsBatchCursorError::Grenad(e) => e.fmt(f),
             DocumentsBatchCursorError::SerdeJson(e) => e.fmt(f),

milli/src/documents/serde_impl.rs

@@ -56,7 +56,7 @@ impl<'a, 'de, W: Write> Visitor<'de> for &mut DocumentVisitor<'a, W> {
         Ok(Ok(()))
     }
 
-    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "a documents, or a sequence of documents.")
     }
 }

milli/src/error.rs

@@ -5,6 +5,7 @@ use std::{io, str};
 
 use heed::{Error as HeedError, MdbError};
 use rayon::ThreadPoolBuildError;
+use rhai::EvalAltResult;
 use serde_json::Value;
 use thiserror::Error;
 
@@ -259,6 +260,14 @@ only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and undersco
     InvalidSettingsDimensions { embedder_name: String },
     #[error("`.embedders.{embedder_name}.url`: could not parse `{url}`: {inner_error}")]
     InvalidUrl { embedder_name: String, inner_error: url::ParseError, url: String },
+    #[error("Document editions cannot modify a document's primary key")]
+    DocumentEditionCannotModifyPrimaryKey,
+    #[error("Document editions must keep documents as objects")]
+    DocumentEditionDocumentMustBeObject,
+    #[error("Document edition runtime error encountered while running the function: {0}")]
+    DocumentEditionRuntimeError(Box<EvalAltResult>),
+    #[error("Document edition runtime error encountered while compiling the function: {0}")]
+    DocumentEditionCompilationError(rhai::ParseError),
 }
 
 impl From<crate::vector::Error> for Error {

milli/src/external_documents_ids.rs

@@ -24,17 +24,21 @@ impl ExternalDocumentsIds {
     }
 
     /// Returns `true` if hard and soft external documents lists are empty.
-    pub fn is_empty(&self, rtxn: &RoTxn) -> heed::Result<bool> {
+    pub fn is_empty(&self, rtxn: &RoTxn<'_>) -> heed::Result<bool> {
         self.0.is_empty(rtxn).map_err(Into::into)
     }
 
-    pub fn get<A: AsRef<str>>(&self, rtxn: &RoTxn, external_id: A) -> heed::Result<Option<u32>> {
+    pub fn get<A: AsRef<str>>(
+        &self,
+        rtxn: &RoTxn<'_>,
+        external_id: A,
+    ) -> heed::Result<Option<u32>> {
         self.0.get(rtxn, external_id.as_ref())
     }
 
     /// An helper function to debug this type, returns an `HashMap` of both,
     /// soft and hard fst maps, combined.
-    pub fn to_hash_map(&self, rtxn: &RoTxn) -> heed::Result<HashMap<String, u32>> {
+    pub fn to_hash_map(&self, rtxn: &RoTxn<'_>) -> heed::Result<HashMap<String, u32>> {
         let mut map = HashMap::default();
         for result in self.0.iter(rtxn)? {
             let (external, internal) = result?;
@@ -51,7 +55,11 @@ impl ExternalDocumentsIds {
     ///
     /// - If attempting to delete a document that doesn't exist
     /// - If attempting to create a document that already exists
-    pub fn apply(&self, wtxn: &mut RwTxn, operations: Vec<DocumentOperation>) -> heed::Result<()> {
+    pub fn apply(
+        &self,
+        wtxn: &mut RwTxn<'_>,
+        operations: Vec<DocumentOperation>,
+    ) -> heed::Result<()> {
         for DocumentOperation { external_id, internal_id, kind } in operations {
             match kind {
                 DocumentOperationKind::Create => {
@@ -69,7 +77,7 @@ impl ExternalDocumentsIds {
     }
 
     /// Returns an iterator over all the external ids.
-    pub fn iter<'t>(&self, rtxn: &'t RoTxn) -> heed::Result<RoIter<'t, Str, BEU32>> {
+    pub fn iter<'t>(&self, rtxn: &'t RoTxn<'_>) -> heed::Result<RoIter<'t, Str, BEU32>> {
         self.0.iter(rtxn)
     }
 }

milli/src/facet/facet_type.rs

@@ -11,7 +11,7 @@ pub enum FacetType {
 }
 
 impl fmt::Display for FacetType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             FacetType::String => f.write_str("string"),
             FacetType::Number => f.write_str("number"),
@@ -37,7 +37,7 @@ impl FromStr for FacetType {
 pub struct InvalidFacetType;
 
 impl fmt::Display for InvalidFacetType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(r#"Invalid facet type, must be "string" or "number""#)
     }
 }

milli/src/heed_codec/beu16_str_codec.rs

@@ -20,7 +20,7 @@ impl<'a> heed::BytesDecode<'a> for BEU16StrCodec {
 impl<'a> heed::BytesEncode<'a> for BEU16StrCodec {
     type EItem = (u16, &'a str);
 
-    fn bytes_encode((n, s): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((n, s): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(s.len() + 2);
         bytes.extend_from_slice(&n.to_be_bytes());
         bytes.extend_from_slice(s.as_bytes());

milli/src/heed_codec/beu32_str_codec.rs

@@ -20,7 +20,7 @@ impl<'a> heed::BytesDecode<'a> for BEU32StrCodec {
 impl<'a> heed::BytesEncode<'a> for BEU32StrCodec {
     type EItem = (u32, &'a str);
 
-    fn bytes_encode((n, s): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((n, s): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(s.len() + 4);
         bytes.extend_from_slice(&n.to_be_bytes());
         bytes.extend_from_slice(s.as_bytes());

milli/src/heed_codec/facet/field_doc_id_facet_codec.rs

@@ -35,7 +35,7 @@ where
 
     fn bytes_encode(
         (field_id, document_id, value): &'a Self::EItem,
-    ) -> Result<Cow<[u8]>, BoxedError> {
+    ) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(32);
         bytes.extend_from_slice(&field_id.to_be_bytes()); // 2 bytes
         bytes.extend_from_slice(&document_id.to_be_bytes()); // 4 bytes

milli/src/heed_codec/facet/ordered_f64_codec.rs

@@ -24,7 +24,7 @@ impl<'a> BytesDecode<'a> for OrderedF64Codec {
 impl heed::BytesEncode<'_> for OrderedF64Codec {
     type EItem = f64;
 
-    fn bytes_encode(f: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(f: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         let mut buffer = [0u8; 16];
 
         // write the globally ordered float

milli/src/heed_codec/field_id_word_count_codec.rs

@@ -21,7 +21,7 @@ impl<'a> heed::BytesDecode<'a> for FieldIdWordCountCodec {
 impl<'a> heed::BytesEncode<'a> for FieldIdWordCountCodec {
     type EItem = (FieldId, u8);
 
-    fn bytes_encode((field_id, word_count): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((field_id, word_count): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(2 + 1);
         bytes.extend_from_slice(&field_id.to_be_bytes());
         bytes.push(*word_count);

milli/src/heed_codec/obkv_codec.rs

@@ -16,7 +16,7 @@ impl<'a> heed::BytesDecode<'a> for ObkvCodec {
 impl heed::BytesEncode<'_> for ObkvCodec {
     type EItem = KvWriterU16<Vec<u8>>;
 
-    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         item.clone().into_inner().map(Cow::Owned).map_err(Into::into)
     }
 }

milli/src/heed_codec/roaring_bitmap/bo_roaring_bitmap_codec.rs

@@ -42,7 +42,7 @@ impl BytesDecodeOwned for BoRoaringBitmapCodec {
 impl heed::BytesEncode<'_> for BoRoaringBitmapCodec {
     type EItem = RoaringBitmap;
 
-    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         let mut out = Vec::new();
         BoRoaringBitmapCodec::serialize_into(item, &mut out);
         Ok(Cow::Owned(out))

milli/src/heed_codec/roaring_bitmap/cbo_roaring_bitmap_codec.rs

@@ -167,7 +167,7 @@ impl BytesDecodeOwned for CboRoaringBitmapCodec {
 impl heed::BytesEncode<'_> for CboRoaringBitmapCodec {
     type EItem = RoaringBitmap;
 
-    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         let mut vec = Vec::with_capacity(Self::serialized_size(item));
         Self::serialize_into(item, &mut vec);
         Ok(Cow::Owned(vec))

milli/src/heed_codec/roaring_bitmap/roaring_bitmap_codec.rs

@@ -26,7 +26,7 @@ impl BytesDecodeOwned for RoaringBitmapCodec {
 impl heed::BytesEncode<'_> for RoaringBitmapCodec {
     type EItem = RoaringBitmap;
 
-    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(item.serialized_size());
         item.serialize_into(&mut bytes)?;
         Ok(Cow::Owned(bytes))

milli/src/heed_codec/roaring_bitmap_length/roaring_bitmap_len_codec.rs

@@ -25,7 +25,7 @@ impl RoaringBitmapLenCodec {
             }
         };
 
-        if size > u16::max_value() as usize + 1 {
+        if size > u16::MAX as usize + 1 {
             return Err(io::Error::new(io::ErrorKind::Other, "size is greater than supported"));
         }
 

milli/src/heed_codec/script_language_codec.rs

@@ -25,7 +25,7 @@ impl<'a> heed::BytesDecode<'a> for ScriptLanguageCodec {
 impl<'a> heed::BytesEncode<'a> for ScriptLanguageCodec {
     type EItem = (Script, Language);
 
-    fn bytes_encode((script, lan): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((script, lan): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let script_name = script.name().as_bytes();
         let lan_name = lan.name().as_bytes();
 

milli/src/heed_codec/str_beu32_codec.rs

@@ -30,7 +30,7 @@ impl<'a> heed::BytesDecode<'a> for StrBEU32Codec {
 impl<'a> heed::BytesEncode<'a> for StrBEU32Codec {
     type EItem = (&'a str, u32);
 
-    fn bytes_encode((word, pos): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((word, pos): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let pos = pos.to_be_bytes();
 
         let mut bytes = Vec::with_capacity(word.len() + pos.len());
@@ -66,7 +66,7 @@ impl<'a> heed::BytesDecode<'a> for StrBEU16Codec {
 impl<'a> heed::BytesEncode<'a> for StrBEU16Codec {
     type EItem = (&'a str, u16);
 
-    fn bytes_encode((word, pos): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((word, pos): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let pos = pos.to_be_bytes();
 
         let mut bytes = Vec::with_capacity(word.len() + 1 + pos.len());

milli/src/heed_codec/str_str_u8_codec.rs

@@ -24,7 +24,7 @@ impl<'a> heed::BytesDecode<'a> for U8StrStrCodec {
 impl<'a> heed::BytesEncode<'a> for U8StrStrCodec {
     type EItem = (u8, &'a str, &'a str);
 
-    fn bytes_encode((n, s1, s2): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((n, s1, s2): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(s1.len() + s2.len() + 1);
         bytes.push(*n);
         bytes.extend_from_slice(s1.as_bytes());
@@ -51,7 +51,7 @@ impl<'a> heed::BytesDecode<'a> for UncheckedU8StrStrCodec {
 impl<'a> heed::BytesEncode<'a> for UncheckedU8StrStrCodec {
     type EItem = (u8, &'a [u8], &'a [u8]);
 
-    fn bytes_encode((n, s1, s2): &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode((n, s1, s2): &Self::EItem) -> Result<Cow<'a, [u8]>, BoxedError> {
         let mut bytes = Vec::with_capacity(s1.len() + s2.len() + 1);
         bytes.push(*n);
         bytes.extend_from_slice(s1);

milli/src/index.rs

@@ -287,12 +287,12 @@ impl Index {
     }
 
     /// Create a write transaction to be able to write into the index.
-    pub fn write_txn(&self) -> heed::Result<RwTxn> {
+    pub fn write_txn(&self) -> heed::Result<RwTxn<'_>> {
         self.env.write_txn()
     }
 
     /// Create a read transaction to be able to read the index.
-    pub fn read_txn(&self) -> heed::Result<RoTxn> {
+    pub fn read_txn(&self) -> heed::Result<RoTxn<'_>> {
         self.env.read_txn()
     }
 
@@ -344,7 +344,7 @@ impl Index {
     /// Writes the documents ids that corresponds to the user-ids-documents-ids FST.
     pub(crate) fn put_documents_ids(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         docids: &RoaringBitmap,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, RoaringBitmapCodec>().put(
@@ -355,7 +355,7 @@ impl Index {
     }
 
     /// Returns the internal documents ids.
-    pub fn documents_ids(&self, rtxn: &RoTxn) -> heed::Result<RoaringBitmap> {
+    pub fn documents_ids(&self, rtxn: &RoTxn<'_>) -> heed::Result<RoaringBitmap> {
         Ok(self
             .main
             .remap_types::<Str, RoaringBitmapCodec>()
@@ -364,7 +364,7 @@ impl Index {
     }
 
     /// Returns the number of documents indexed in the database.
-    pub fn number_of_documents(&self, rtxn: &RoTxn) -> Result<u64> {
+    pub fn number_of_documents(&self, rtxn: &RoTxn<'_>) -> Result<u64> {
         let count = self
             .main
             .remap_types::<Str, RoaringBitmapLenCodec>()
@@ -375,18 +375,22 @@ impl Index {
     /* primary key */
 
     /// Writes the documents primary key, this is the field name that is used to store the id.
-    pub(crate) fn put_primary_key(&self, wtxn: &mut RwTxn, primary_key: &str) -> heed::Result<()> {
+    pub(crate) fn put_primary_key(
+        &self,
+        wtxn: &mut RwTxn<'_>,
+        primary_key: &str,
+    ) -> heed::Result<()> {
         self.set_updated_at(wtxn, &OffsetDateTime::now_utc())?;
         self.main.remap_types::<Str, Str>().put(wtxn, main_key::PRIMARY_KEY_KEY, primary_key)
     }
 
     /// Deletes the primary key of the documents, this can be done to reset indexes settings.
-    pub(crate) fn delete_primary_key(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_primary_key(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::PRIMARY_KEY_KEY)
     }
 
     /// Returns the documents primary key, `None` if it hasn't been defined.
-    pub fn primary_key<'t>(&self, rtxn: &'t RoTxn) -> heed::Result<Option<&'t str>> {
+    pub fn primary_key<'t>(&self, rtxn: &'t RoTxn<'_>) -> heed::Result<Option<&'t str>> {
         self.main.remap_types::<Str, Str>().get(rtxn, main_key::PRIMARY_KEY_KEY)
     }
 
@@ -404,7 +408,7 @@ impl Index {
     /// (i.e. `u8`), this field id is used to identify fields in the obkv documents.
     pub(crate) fn put_fields_ids_map(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         map: &FieldsIdsMap,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<FieldsIdsMap>>().put(
@@ -416,7 +420,7 @@ impl Index {
 
     /// Returns the fields ids map which associate the documents keys with an internal field id
     /// (i.e. `u8`), this field id is used to identify fields in the obkv documents.
-    pub fn fields_ids_map(&self, rtxn: &RoTxn) -> heed::Result<FieldsIdsMap> {
+    pub fn fields_ids_map(&self, rtxn: &RoTxn<'_>) -> heed::Result<FieldsIdsMap> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<FieldsIdsMap>>()
@@ -431,7 +435,7 @@ impl Index {
     /// Writes the fieldids weights map which associates the field ids to their weights
     pub(crate) fn put_fieldids_weights_map(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         map: &FieldidsWeightsMap,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<_>>().put(
@@ -442,7 +446,7 @@ impl Index {
     }
 
     /// Get the fieldids weights map which associates the field ids to their weights
-    pub fn fieldids_weights_map(&self, rtxn: &RoTxn) -> heed::Result<FieldidsWeightsMap> {
+    pub fn fieldids_weights_map(&self, rtxn: &RoTxn<'_>) -> heed::Result<FieldidsWeightsMap> {
         self.main
             .remap_types::<Str, SerdeJson<_>>()
             .get(rtxn, main_key::FIELDIDS_WEIGHTS_MAP_KEY)?
@@ -455,13 +459,13 @@ impl Index {
     }
 
     /// Delete the fieldsids weights map
-    pub fn delete_fieldids_weights_map(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub fn delete_fieldids_weights_map(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::FIELDIDS_WEIGHTS_MAP_KEY)
     }
 
     pub fn searchable_fields_and_weights<'a>(
         &self,
-        rtxn: &'a RoTxn,
+        rtxn: &'a RoTxn<'a>,
     ) -> Result<Vec<(Cow<'a, str>, FieldId, Weight)>> {
         let fid_map = self.fields_ids_map(rtxn)?;
         let weight_map = self.fieldids_weights_map(rtxn)?;
@@ -488,7 +492,7 @@ impl Index {
     /// Writes the provided `rtree` which associates coordinates to documents ids.
     pub(crate) fn put_geo_rtree(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         rtree: &RTree<GeoPoint>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<RTree<GeoPoint>>>().put(
@@ -499,12 +503,12 @@ impl Index {
     }
 
     /// Delete the `rtree` which associates coordinates to documents ids.
-    pub(crate) fn delete_geo_rtree(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_geo_rtree(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::GEO_RTREE_KEY)
     }
 
     /// Returns the `rtree` which associates coordinates to documents ids.
-    pub fn geo_rtree(&self, rtxn: &RoTxn) -> Result<Option<RTree<GeoPoint>>> {
+    pub fn geo_rtree(&self, rtxn: &RoTxn<'_>) -> Result<Option<RTree<GeoPoint>>> {
         match self
             .main
             .remap_types::<Str, SerdeBincode<RTree<GeoPoint>>>()
@@ -520,7 +524,7 @@ impl Index {
     /// Writes the documents ids that are faceted with a _geo field.
     pub(crate) fn put_geo_faceted_documents_ids(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         docids: &RoaringBitmap,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, RoaringBitmapCodec>().put(
@@ -531,12 +535,15 @@ impl Index {
     }
 
     /// Delete the documents ids that are faceted with a _geo field.
-    pub(crate) fn delete_geo_faceted_documents_ids(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_geo_faceted_documents_ids(
+        &self,
+        wtxn: &mut RwTxn<'_>,
+    ) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::GEO_FACETED_DOCUMENTS_IDS_KEY)
     }
 
     /// Retrieve all the documents ids that are faceted with a _geo field.
-    pub fn geo_faceted_documents_ids(&self, rtxn: &RoTxn) -> heed::Result<RoaringBitmap> {
+    pub fn geo_faceted_documents_ids(&self, rtxn: &RoTxn<'_>) -> heed::Result<RoaringBitmap> {
         match self
             .main
             .remap_types::<Str, RoaringBitmapCodec>()
@@ -552,7 +559,7 @@ impl Index {
     /// the number of times it occurs in the documents.
     pub(crate) fn put_field_distribution(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         distribution: &FieldDistribution,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<FieldDistribution>>().put(
@@ -564,7 +571,7 @@ impl Index {
 
     /// Returns the field distribution which associates every field name with
     /// the number of times it occurs in the documents.
-    pub fn field_distribution(&self, rtxn: &RoTxn) -> heed::Result<FieldDistribution> {
+    pub fn field_distribution(&self, rtxn: &RoTxn<'_>) -> heed::Result<FieldDistribution> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<FieldDistribution>>()
@@ -578,7 +585,7 @@ impl Index {
     /// There must be not be any duplicate field id.
     pub(crate) fn put_displayed_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fields: &[&str],
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<&[&str]>>().put(
@@ -590,20 +597,20 @@ impl Index {
 
     /// Deletes the displayed fields ids, this will make the engine to display
     /// all the documents attributes in the order of the `FieldsIdsMap`.
-    pub(crate) fn delete_displayed_fields(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_displayed_fields(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::DISPLAYED_FIELDS_KEY)
     }
 
     /// Returns the displayed fields in the order they were set by the user. If it returns
     /// `None` it means that all the attributes are set as displayed in the order of the `FieldsIdsMap`.
-    pub fn displayed_fields<'t>(&self, rtxn: &'t RoTxn) -> heed::Result<Option<Vec<&'t str>>> {
+    pub fn displayed_fields<'t>(&self, rtxn: &'t RoTxn<'_>) -> heed::Result<Option<Vec<&'t str>>> {
         self.main
             .remap_types::<Str, SerdeBincode<Vec<&'t str>>>()
             .get(rtxn, main_key::DISPLAYED_FIELDS_KEY)
     }
 
     /// Identical to `displayed_fields`, but returns the ids instead.
-    pub fn displayed_fields_ids(&self, rtxn: &RoTxn) -> Result<Option<Vec<FieldId>>> {
+    pub fn displayed_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<Option<Vec<FieldId>>> {
         match self.displayed_fields(rtxn)? {
             Some(fields) => {
                 let fields_ids_map = self.fields_ids_map(rtxn)?;
@@ -622,7 +629,7 @@ impl Index {
     /* remove hidden fields */
     pub fn remove_hidden_fields(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         fields: impl IntoIterator<Item = impl AsRef<str>>,
     ) -> Result<(BTreeSet<String>, bool)> {
         let mut valid_fields =
@@ -644,7 +651,7 @@ impl Index {
     /// Write the user defined searchable fields and generate the real searchable fields from the specified fields ids map.
     pub(crate) fn put_all_searchable_fields_from_fields_ids_map(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         user_fields: &[&str],
         non_searchable_fields_ids: &[FieldId],
         fields_ids_map: &FieldsIdsMap,
@@ -681,7 +688,7 @@ impl Index {
         Ok(())
     }
 
-    pub(crate) fn delete_all_searchable_fields(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_all_searchable_fields(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         let did_delete_searchable = self.delete_searchable_fields(wtxn)?;
         let did_delete_user_defined = self.delete_user_defined_searchable_fields(wtxn)?;
         self.delete_fieldids_weights_map(wtxn)?;
@@ -689,7 +696,7 @@ impl Index {
     }
 
     /// Writes the searchable fields, when this list is specified, only these are indexed.
-    fn put_searchable_fields(&self, wtxn: &mut RwTxn, fields: &[&str]) -> heed::Result<()> {
+    fn put_searchable_fields(&self, wtxn: &mut RwTxn<'_>, fields: &[&str]) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<&[&str]>>().put(
             wtxn,
             main_key::SEARCHABLE_FIELDS_KEY,
@@ -698,12 +705,12 @@ impl Index {
     }
 
     /// Deletes the searchable fields, when no fields are specified, all fields are indexed.
-    fn delete_searchable_fields(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    fn delete_searchable_fields(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::SEARCHABLE_FIELDS_KEY)
     }
 
     /// Returns the searchable fields, those are the fields that are indexed,
-    pub fn searchable_fields<'t>(&self, rtxn: &'t RoTxn) -> heed::Result<Vec<Cow<'t, str>>> {
+    pub fn searchable_fields<'t>(&self, rtxn: &'t RoTxn<'_>) -> heed::Result<Vec<Cow<'t, str>>> {
         self.main
             .remap_types::<Str, SerdeBincode<Vec<&'t str>>>()
             .get(rtxn, main_key::SEARCHABLE_FIELDS_KEY)?
@@ -719,7 +726,7 @@ impl Index {
     }
 
     /// Identical to `searchable_fields`, but returns the ids instead.
-    pub fn searchable_fields_ids(&self, rtxn: &RoTxn) -> Result<Vec<FieldId>> {
+    pub fn searchable_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<Vec<FieldId>> {
         let fields = self.searchable_fields(rtxn)?;
         let fields_ids_map = self.fields_ids_map(rtxn)?;
         let mut fields_ids = Vec::new();
@@ -734,7 +741,7 @@ impl Index {
     /// Writes the searchable fields, when this list is specified, only these are indexed.
     pub(crate) fn put_user_defined_searchable_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fields: &[&str],
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<_>>().put(
@@ -747,7 +754,7 @@ impl Index {
     /// Deletes the searchable fields, when no fields are specified, all fields are indexed.
     pub(crate) fn delete_user_defined_searchable_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
     ) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::USER_DEFINED_SEARCHABLE_FIELDS_KEY)
     }
@@ -755,7 +762,7 @@ impl Index {
     /// Returns the user defined searchable fields.
     pub fn user_defined_searchable_fields<'t>(
         &self,
-        rtxn: &'t RoTxn,
+        rtxn: &'t RoTxn<'t>,
     ) -> heed::Result<Option<Vec<&'t str>>> {
         self.main
             .remap_types::<Str, SerdeBincode<Vec<_>>>()
@@ -763,7 +770,10 @@ impl Index {
     }
 
     /// Identical to `user_defined_searchable_fields`, but returns ids instead.
-    pub fn user_defined_searchable_fields_ids(&self, rtxn: &RoTxn) -> Result<Option<Vec<FieldId>>> {
+    pub fn user_defined_searchable_fields_ids(
+        &self,
+        rtxn: &RoTxn<'_>,
+    ) -> Result<Option<Vec<FieldId>>> {
         match self.user_defined_searchable_fields(rtxn)? {
             Some(fields) => {
                 let fields_ids_map = self.fields_ids_map(rtxn)?;
@@ -784,7 +794,7 @@ impl Index {
     /// Writes the filterable fields names in the database.
     pub(crate) fn put_filterable_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fields: &HashSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<_>>().put(
@@ -795,12 +805,12 @@ impl Index {
     }
 
     /// Deletes the filterable fields ids in the database.
-    pub(crate) fn delete_filterable_fields(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_filterable_fields(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::FILTERABLE_FIELDS_KEY)
     }
 
     /// Returns the filterable fields names.
-    pub fn filterable_fields(&self, rtxn: &RoTxn) -> heed::Result<HashSet<String>> {
+    pub fn filterable_fields(&self, rtxn: &RoTxn<'_>) -> heed::Result<HashSet<String>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<_>>()
@@ -809,7 +819,7 @@ impl Index {
     }
 
     /// Identical to `filterable_fields`, but returns ids instead.
-    pub fn filterable_fields_ids(&self, rtxn: &RoTxn) -> Result<HashSet<FieldId>> {
+    pub fn filterable_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<HashSet<FieldId>> {
         let fields = self.filterable_fields(rtxn)?;
         let fields_ids_map = self.fields_ids_map(rtxn)?;
 
@@ -828,7 +838,7 @@ impl Index {
     /// Writes the sortable fields names in the database.
     pub(crate) fn put_sortable_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fields: &HashSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<_>>().put(
@@ -839,12 +849,12 @@ impl Index {
     }
 
     /// Deletes the sortable fields ids in the database.
-    pub(crate) fn delete_sortable_fields(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_sortable_fields(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::SORTABLE_FIELDS_KEY)
     }
 
     /// Returns the sortable fields names.
-    pub fn sortable_fields(&self, rtxn: &RoTxn) -> heed::Result<HashSet<String>> {
+    pub fn sortable_fields(&self, rtxn: &RoTxn<'_>) -> heed::Result<HashSet<String>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<_>>()
@@ -853,7 +863,7 @@ impl Index {
     }
 
     /// Identical to `sortable_fields`, but returns ids instead.
-    pub fn sortable_fields_ids(&self, rtxn: &RoTxn) -> Result<HashSet<FieldId>> {
+    pub fn sortable_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<HashSet<FieldId>> {
         let fields = self.sortable_fields(rtxn)?;
         let fields_ids_map = self.fields_ids_map(rtxn)?;
         Ok(fields.into_iter().filter_map(|name| fields_ids_map.id(&name)).collect())
@@ -864,7 +874,7 @@ impl Index {
     /// Writes the faceted fields in the database.
     pub(crate) fn put_faceted_fields(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fields: &HashSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<_>>().put(
@@ -875,7 +885,7 @@ impl Index {
     }
 
     /// Returns the faceted fields names.
-    pub fn faceted_fields(&self, rtxn: &RoTxn) -> heed::Result<HashSet<String>> {
+    pub fn faceted_fields(&self, rtxn: &RoTxn<'_>) -> heed::Result<HashSet<String>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<_>>()
@@ -884,7 +894,7 @@ impl Index {
     }
 
     /// Identical to `faceted_fields`, but returns ids instead.
-    pub fn faceted_fields_ids(&self, rtxn: &RoTxn) -> Result<HashSet<FieldId>> {
+    pub fn faceted_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<HashSet<FieldId>> {
         let fields = self.faceted_fields(rtxn)?;
         let fields_ids_map = self.fields_ids_map(rtxn)?;
 
@@ -903,7 +913,7 @@ impl Index {
     /// Returns the user defined faceted fields names.
     ///
     /// The user faceted fields are the union of all the filterable, sortable, distinct, and Asc/Desc fields.
-    pub fn user_defined_faceted_fields(&self, rtxn: &RoTxn) -> Result<HashSet<String>> {
+    pub fn user_defined_faceted_fields(&self, rtxn: &RoTxn<'_>) -> Result<HashSet<String>> {
         let filterable_fields = self.filterable_fields(rtxn)?;
         let sortable_fields = self.sortable_fields(rtxn)?;
         let distinct_field = self.distinct_field(rtxn)?;
@@ -924,7 +934,7 @@ impl Index {
     }
 
     /// Identical to `user_defined_faceted_fields`, but returns ids instead.
-    pub fn user_defined_faceted_fields_ids(&self, rtxn: &RoTxn) -> Result<HashSet<FieldId>> {
+    pub fn user_defined_faceted_fields_ids(&self, rtxn: &RoTxn<'_>) -> Result<HashSet<FieldId>> {
         let fields = self.user_defined_faceted_fields(rtxn)?;
         let fields_ids_map = self.fields_ids_map(rtxn)?;
 
@@ -943,7 +953,7 @@ impl Index {
     /// Retrieve all the documents which contain this field id set as null
     pub fn null_faceted_documents_ids(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         field_id: FieldId,
     ) -> heed::Result<RoaringBitmap> {
         match self.facet_id_is_null_docids.get(rtxn, &field_id)? {
@@ -955,7 +965,7 @@ impl Index {
     /// Retrieve all the documents which contain this field id and that is considered empty
     pub fn empty_faceted_documents_ids(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         field_id: FieldId,
     ) -> heed::Result<RoaringBitmap> {
         match self.facet_id_is_empty_docids.get(rtxn, &field_id)? {
@@ -967,7 +977,7 @@ impl Index {
     /// Retrieve all the documents which contain this field id
     pub fn exists_faceted_documents_ids(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         field_id: FieldId,
     ) -> heed::Result<RoaringBitmap> {
         match self.facet_id_exists_docids.get(rtxn, &field_id)? {
@@ -980,17 +990,17 @@ impl Index {
 
     pub(crate) fn put_distinct_field(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         distinct_field: &str,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, Str>().put(wtxn, main_key::DISTINCT_FIELD_KEY, distinct_field)
     }
 
-    pub fn distinct_field<'a>(&self, rtxn: &'a RoTxn) -> heed::Result<Option<&'a str>> {
+    pub fn distinct_field<'a>(&self, rtxn: &'a RoTxn<'_>) -> heed::Result<Option<&'a str>> {
         self.main.remap_types::<Str, Str>().get(rtxn, main_key::DISTINCT_FIELD_KEY)
     }
 
-    pub(crate) fn delete_distinct_field(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_distinct_field(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::DISTINCT_FIELD_KEY)
     }
 
@@ -998,7 +1008,7 @@ impl Index {
 
     pub(crate) fn put_criteria(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         criteria: &[Criterion],
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<&[Criterion]>>().put(
@@ -1008,11 +1018,11 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_criteria(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_criteria(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::CRITERIA_KEY)
     }
 
-    pub fn criteria(&self, rtxn: &RoTxn) -> heed::Result<Vec<Criterion>> {
+    pub fn criteria(&self, rtxn: &RoTxn<'_>) -> heed::Result<Vec<Criterion>> {
         match self
             .main
             .remap_types::<Str, SerdeJson<Vec<Criterion>>>()
@@ -1028,7 +1038,7 @@ impl Index {
     /// Writes the FST which is the words dictionary of the engine.
     pub(crate) fn put_words_fst<A: AsRef<[u8]>>(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fst: &fst::Set<A>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, Bytes>().put(
@@ -1039,7 +1049,7 @@ impl Index {
     }
 
     /// Returns the FST which is the words dictionary of the engine.
-    pub fn words_fst<'t>(&self, rtxn: &'t RoTxn) -> Result<fst::Set<Cow<'t, [u8]>>> {
+    pub fn words_fst<'t>(&self, rtxn: &'t RoTxn<'_>) -> Result<fst::Set<Cow<'t, [u8]>>> {
         match self.main.remap_types::<Str, Bytes>().get(rtxn, main_key::WORDS_FST_KEY)? {
             Some(bytes) => Ok(fst::Set::new(bytes)?.map_data(Cow::Borrowed)?),
             None => Ok(fst::Set::default().map_data(Cow::Owned)?),
@@ -1050,7 +1060,7 @@ impl Index {
 
     pub(crate) fn put_stop_words<A: AsRef<[u8]>>(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fst: &fst::Set<A>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, Bytes>().put(
@@ -1060,11 +1070,11 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_stop_words(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_stop_words(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::STOP_WORDS_KEY)
     }
 
-    pub fn stop_words<'t>(&self, rtxn: &'t RoTxn) -> Result<Option<fst::Set<&'t [u8]>>> {
+    pub fn stop_words<'t>(&self, rtxn: &'t RoTxn<'t>) -> Result<Option<fst::Set<&'t [u8]>>> {
         match self.main.remap_types::<Str, Bytes>().get(rtxn, main_key::STOP_WORDS_KEY)? {
             Some(bytes) => Ok(Some(fst::Set::new(bytes)?)),
             None => Ok(None),
@@ -1075,7 +1085,7 @@ impl Index {
 
     pub(crate) fn put_non_separator_tokens(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         set: &BTreeSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<_>>().put(
@@ -1085,11 +1095,11 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_non_separator_tokens(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_non_separator_tokens(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::NON_SEPARATOR_TOKENS_KEY)
     }
 
-    pub fn non_separator_tokens(&self, rtxn: &RoTxn) -> Result<Option<BTreeSet<String>>> {
+    pub fn non_separator_tokens(&self, rtxn: &RoTxn<'_>) -> Result<Option<BTreeSet<String>>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeBincode<BTreeSet<String>>>()
@@ -1100,7 +1110,7 @@ impl Index {
 
     pub(crate) fn put_separator_tokens(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         set: &BTreeSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<_>>().put(
@@ -1110,11 +1120,11 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_separator_tokens(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_separator_tokens(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::SEPARATOR_TOKENS_KEY)
     }
 
-    pub fn separator_tokens(&self, rtxn: &RoTxn) -> Result<Option<BTreeSet<String>>> {
+    pub fn separator_tokens(&self, rtxn: &RoTxn<'_>) -> Result<Option<BTreeSet<String>>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeBincode<BTreeSet<String>>>()
@@ -1123,7 +1133,7 @@ impl Index {
 
     /* separators easing method */
 
-    pub fn allowed_separators(&self, rtxn: &RoTxn) -> Result<Option<BTreeSet<String>>> {
+    pub fn allowed_separators(&self, rtxn: &RoTxn<'_>) -> Result<Option<BTreeSet<String>>> {
         let default_separators =
             charabia::separators::DEFAULT_SEPARATORS.iter().map(|s| s.to_string());
         let mut separators: Option<BTreeSet<_>> = None;
@@ -1145,17 +1155,17 @@ impl Index {
 
     pub(crate) fn put_dictionary(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         set: &BTreeSet<String>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<_>>().put(wtxn, main_key::DICTIONARY_KEY, set)
     }
 
-    pub(crate) fn delete_dictionary(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_dictionary(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::DICTIONARY_KEY)
     }
 
-    pub fn dictionary(&self, rtxn: &RoTxn) -> Result<Option<BTreeSet<String>>> {
+    pub fn dictionary(&self, rtxn: &RoTxn<'_>) -> Result<Option<BTreeSet<String>>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeBincode<BTreeSet<String>>>()
@@ -1166,7 +1176,7 @@ impl Index {
 
     pub(crate) fn put_synonyms(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         synonyms: &HashMap<Vec<String>, Vec<Vec<String>>>,
         user_defined_synonyms: &BTreeMap<String, Vec<String>>,
     ) -> heed::Result<()> {
@@ -1182,14 +1192,14 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_synonyms(&self, wtxn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_synonyms(&self, wtxn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::SYNONYMS_KEY)?;
         self.main.remap_key_type::<Str>().delete(wtxn, main_key::USER_DEFINED_SYNONYMS_KEY)
     }
 
     pub fn user_defined_synonyms(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
     ) -> heed::Result<BTreeMap<String, Vec<String>>> {
         Ok(self
             .main
@@ -1198,7 +1208,10 @@ impl Index {
             .unwrap_or_default())
     }
 
-    pub fn synonyms(&self, rtxn: &RoTxn) -> heed::Result<HashMap<Vec<String>, Vec<Vec<String>>>> {
+    pub fn synonyms(
+        &self,
+        rtxn: &RoTxn<'_>,
+    ) -> heed::Result<HashMap<Vec<String>, Vec<Vec<String>>>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeBincode<_>>()
@@ -1208,7 +1221,7 @@ impl Index {
 
     pub fn words_synonyms<S: AsRef<str>>(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         words: &[S],
     ) -> heed::Result<Option<Vec<Vec<String>>>> {
         let words: Vec<_> = words.iter().map(|s| s.as_ref().to_owned()).collect();
@@ -1220,7 +1233,7 @@ impl Index {
     /// Writes the FST which is the words prefixes dictionary of the engine.
     pub(crate) fn put_words_prefixes_fst<A: AsRef<[u8]>>(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         fst: &fst::Set<A>,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, Bytes>().put(
@@ -1231,7 +1244,7 @@ impl Index {
     }
 
     /// Returns the FST which is the words prefixes dictionary of the engine.
-    pub fn words_prefixes_fst<'t>(&self, rtxn: &'t RoTxn) -> Result<fst::Set<Cow<'t, [u8]>>> {
+    pub fn words_prefixes_fst<'t>(&self, rtxn: &'t RoTxn<'t>) -> Result<fst::Set<Cow<'t, [u8]>>> {
         match self.main.remap_types::<Str, Bytes>().get(rtxn, main_key::WORDS_PREFIXES_FST_KEY)? {
             Some(bytes) => Ok(fst::Set::new(bytes)?.map_data(Cow::Borrowed)?),
             None => Ok(fst::Set::default().map_data(Cow::Owned)?),
@@ -1242,7 +1255,7 @@ impl Index {
 
     /// Returns the number of documents ids associated with the given word,
     /// it is much faster than deserializing the bitmap and getting the length of it.
-    pub fn word_documents_count(&self, rtxn: &RoTxn, word: &str) -> heed::Result<Option<u64>> {
+    pub fn word_documents_count(&self, rtxn: &RoTxn<'_>, word: &str) -> heed::Result<Option<u64>> {
         self.word_docids.remap_data_type::<RoaringBitmapLenCodec>().get(rtxn, word)
     }
 
@@ -1251,7 +1264,7 @@ impl Index {
     /// Returns an iterator over the requested documents. The next item will be an error if a document is missing.
     pub fn iter_documents<'a, 't: 'a>(
         &'a self,
-        rtxn: &'t RoTxn,
+        rtxn: &'t RoTxn<'t>,
         ids: impl IntoIterator<Item = DocumentId> + 'a,
     ) -> Result<impl Iterator<Item = Result<(DocumentId, obkv::KvReaderU16<'t>)>> + 'a> {
         Ok(ids.into_iter().map(move |id| {
@@ -1266,7 +1279,7 @@ impl Index {
     /// Returns a [`Vec`] of the requested documents. Returns an error if a document is missing.
     pub fn documents<'t>(
         &self,
-        rtxn: &'t RoTxn,
+        rtxn: &'t RoTxn<'t>,
         ids: impl IntoIterator<Item = DocumentId>,
     ) -> Result<Vec<(DocumentId, obkv::KvReaderU16<'t>)>> {
         self.iter_documents(rtxn, ids)?.collect()
@@ -1275,14 +1288,14 @@ impl Index {
     /// Returns an iterator over all the documents in the index.
     pub fn all_documents<'a, 't: 'a>(
         &'a self,
-        rtxn: &'t RoTxn,
+        rtxn: &'t RoTxn<'t>,
     ) -> Result<impl Iterator<Item = Result<(DocumentId, obkv::KvReaderU16<'t>)>> + 'a> {
         self.iter_documents(rtxn, self.documents_ids(rtxn)?)
     }
 
     pub fn external_id_of<'a, 't: 'a>(
         &'a self,
-        rtxn: &'t RoTxn,
+        rtxn: &'t RoTxn<'t>,
         ids: impl IntoIterator<Item = DocumentId> + 'a,
     ) -> Result<impl IntoIterator<Item = Result<String>> + 'a> {
         let fields = self.fields_ids_map(rtxn)?;
@@ -1310,16 +1323,16 @@ impl Index {
         }))
     }
 
-    pub fn facets_distribution<'a>(&'a self, rtxn: &'a RoTxn) -> FacetDistribution<'a> {
+    pub fn facets_distribution<'a>(&'a self, rtxn: &'a RoTxn<'a>) -> FacetDistribution<'a> {
         FacetDistribution::new(rtxn, self)
     }
 
-    pub fn search<'a>(&'a self, rtxn: &'a RoTxn) -> Search<'a> {
+    pub fn search<'a>(&'a self, rtxn: &'a RoTxn<'a>) -> Search<'a> {
         Search::new(rtxn, self)
     }
 
     /// Returns the index creation time.
-    pub fn created_at(&self, rtxn: &RoTxn) -> Result<OffsetDateTime> {
+    pub fn created_at(&self, rtxn: &RoTxn<'_>) -> Result<OffsetDateTime> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<OffsetDateTime>>()
@@ -1331,7 +1344,7 @@ impl Index {
     }
 
     /// Returns the index last updated time.
-    pub fn updated_at(&self, rtxn: &RoTxn) -> Result<OffsetDateTime> {
+    pub fn updated_at(&self, rtxn: &RoTxn<'_>) -> Result<OffsetDateTime> {
         Ok(self
             .main
             .remap_types::<Str, SerdeJson<OffsetDateTime>>()
@@ -1344,7 +1357,7 @@ impl Index {
 
     pub(crate) fn set_updated_at(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &mut RwTxn<'_>,
         time: &OffsetDateTime,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<OffsetDateTime>>().put(
@@ -1354,7 +1367,7 @@ impl Index {
         )
     }
 
-    pub fn authorize_typos(&self, txn: &RoTxn) -> heed::Result<bool> {
+    pub fn authorize_typos(&self, txn: &RoTxn<'_>) -> heed::Result<bool> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1364,7 +1377,7 @@ impl Index {
         }
     }
 
-    pub(crate) fn put_authorize_typos(&self, txn: &mut RwTxn, flag: bool) -> heed::Result<()> {
+    pub(crate) fn put_authorize_typos(&self, txn: &mut RwTxn<'_>, flag: bool) -> heed::Result<()> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1373,7 +1386,7 @@ impl Index {
         Ok(())
     }
 
-    pub fn min_word_len_one_typo(&self, txn: &RoTxn) -> heed::Result<u8> {
+    pub fn min_word_len_one_typo(&self, txn: &RoTxn<'_>) -> heed::Result<u8> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1384,7 +1397,11 @@ impl Index {
             .unwrap_or(DEFAULT_MIN_WORD_LEN_ONE_TYPO))
     }
 
-    pub(crate) fn put_min_word_len_one_typo(&self, txn: &mut RwTxn, val: u8) -> heed::Result<()> {
+    pub(crate) fn put_min_word_len_one_typo(
+        &self,
+        txn: &mut RwTxn<'_>,
+        val: u8,
+    ) -> heed::Result<()> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1392,7 +1409,7 @@ impl Index {
         Ok(())
     }
 
-    pub fn min_word_len_two_typos(&self, txn: &RoTxn) -> heed::Result<u8> {
+    pub fn min_word_len_two_typos(&self, txn: &RoTxn<'_>) -> heed::Result<u8> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1403,7 +1420,11 @@ impl Index {
             .unwrap_or(DEFAULT_MIN_WORD_LEN_TWO_TYPOS))
     }
 
-    pub(crate) fn put_min_word_len_two_typos(&self, txn: &mut RwTxn, val: u8) -> heed::Result<()> {
+    pub(crate) fn put_min_word_len_two_typos(
+        &self,
+        txn: &mut RwTxn<'_>,
+        val: u8,
+    ) -> heed::Result<()> {
         // It is not possible to put a bool in heed with OwnedType, so we put a u8 instead. We
         // identify 0 as being false, and anything else as true. The absence of a value is true,
         // because by default, we authorize typos.
@@ -1412,7 +1433,7 @@ impl Index {
     }
 
     /// List the words on which typo are not allowed
-    pub fn exact_words<'t>(&self, txn: &'t RoTxn) -> Result<Option<fst::Set<Cow<'t, [u8]>>>> {
+    pub fn exact_words<'t>(&self, txn: &'t RoTxn<'t>) -> Result<Option<fst::Set<Cow<'t, [u8]>>>> {
         match self.main.remap_types::<Str, Bytes>().get(txn, main_key::EXACT_WORDS)? {
             Some(bytes) => Ok(Some(fst::Set::new(bytes)?.map_data(Cow::Borrowed)?)),
             None => Ok(None),
@@ -1421,7 +1442,7 @@ impl Index {
 
     pub(crate) fn put_exact_words<A: AsRef<[u8]>>(
         &self,
-        txn: &mut RwTxn,
+        txn: &mut RwTxn<'_>,
         words: &fst::Set<A>,
     ) -> Result<()> {
         self.main.remap_types::<Str, Bytes>().put(
@@ -1433,7 +1454,7 @@ impl Index {
     }
 
     /// Returns the exact attributes: attributes for which typo is disallowed.
-    pub fn exact_attributes<'t>(&self, txn: &'t RoTxn) -> Result<Vec<&'t str>> {
+    pub fn exact_attributes<'t>(&self, txn: &'t RoTxn<'t>) -> Result<Vec<&'t str>> {
         Ok(self
             .main
             .remap_types::<Str, SerdeBincode<Vec<&str>>>()
@@ -1442,14 +1463,14 @@ impl Index {
     }
 
     /// Returns the list of exact attributes field ids.
-    pub fn exact_attributes_ids(&self, txn: &RoTxn) -> Result<HashSet<FieldId>> {
+    pub fn exact_attributes_ids(&self, txn: &RoTxn<'_>) -> Result<HashSet<FieldId>> {
         let attrs = self.exact_attributes(txn)?;
         let fid_map = self.fields_ids_map(txn)?;
         Ok(attrs.iter().filter_map(|attr| fid_map.id(attr)).collect())
     }
 
     /// Writes the exact attributes to the database.
-    pub(crate) fn put_exact_attributes(&self, txn: &mut RwTxn, attrs: &[&str]) -> Result<()> {
+    pub(crate) fn put_exact_attributes(&self, txn: &mut RwTxn<'_>, attrs: &[&str]) -> Result<()> {
         self.main.remap_types::<Str, SerdeBincode<&[&str]>>().put(
             txn,
             main_key::EXACT_ATTRIBUTES,
@@ -1459,23 +1480,27 @@ impl Index {
     }
 
     /// Clears the exact attributes from the store.
-    pub(crate) fn delete_exact_attributes(&self, txn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_exact_attributes(&self, txn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(txn, main_key::EXACT_ATTRIBUTES)
     }
 
-    pub fn max_values_per_facet(&self, txn: &RoTxn) -> heed::Result<Option<u64>> {
+    pub fn max_values_per_facet(&self, txn: &RoTxn<'_>) -> heed::Result<Option<u64>> {
         self.main.remap_types::<Str, BEU64>().get(txn, main_key::MAX_VALUES_PER_FACET)
     }
 
-    pub(crate) fn put_max_values_per_facet(&self, txn: &mut RwTxn, val: u64) -> heed::Result<()> {
+    pub(crate) fn put_max_values_per_facet(
+        &self,
+        txn: &mut RwTxn<'_>,
+        val: u64,
+    ) -> heed::Result<()> {
         self.main.remap_types::<Str, BEU64>().put(txn, main_key::MAX_VALUES_PER_FACET, &val)
     }
 
-    pub(crate) fn delete_max_values_per_facet(&self, txn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_max_values_per_facet(&self, txn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(txn, main_key::MAX_VALUES_PER_FACET)
     }
 
-    pub fn sort_facet_values_by(&self, txn: &RoTxn) -> heed::Result<OrderByMap> {
+    pub fn sort_facet_values_by(&self, txn: &RoTxn<'_>) -> heed::Result<OrderByMap> {
         let orders = self
             .main
             .remap_types::<Str, SerdeJson<OrderByMap>>()
@@ -1486,33 +1511,36 @@ impl Index {
 
     pub(crate) fn put_sort_facet_values_by(
         &self,
-        txn: &mut RwTxn,
+        txn: &mut RwTxn<'_>,
         val: &OrderByMap,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeJson<_>>().put(txn, main_key::SORT_FACET_VALUES_BY, &val)
     }
 
-    pub(crate) fn delete_sort_facet_values_by(&self, txn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_sort_facet_values_by(&self, txn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(txn, main_key::SORT_FACET_VALUES_BY)
     }
 
-    pub fn pagination_max_total_hits(&self, txn: &RoTxn) -> heed::Result<Option<u64>> {
+    pub fn pagination_max_total_hits(&self, txn: &RoTxn<'_>) -> heed::Result<Option<u64>> {
         self.main.remap_types::<Str, BEU64>().get(txn, main_key::PAGINATION_MAX_TOTAL_HITS)
     }
 
     pub(crate) fn put_pagination_max_total_hits(
         &self,
-        txn: &mut RwTxn,
+        txn: &mut RwTxn<'_>,
         val: u64,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, BEU64>().put(txn, main_key::PAGINATION_MAX_TOTAL_HITS, &val)
     }
 
-    pub(crate) fn delete_pagination_max_total_hits(&self, txn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_pagination_max_total_hits(
+        &self,
+        txn: &mut RwTxn<'_>,
+    ) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(txn, main_key::PAGINATION_MAX_TOTAL_HITS)
     }
 
-    pub fn proximity_precision(&self, txn: &RoTxn) -> heed::Result<Option<ProximityPrecision>> {
+    pub fn proximity_precision(&self, txn: &RoTxn<'_>) -> heed::Result<Option<ProximityPrecision>> {
         self.main
             .remap_types::<Str, SerdeBincode<ProximityPrecision>>()
             .get(txn, main_key::PROXIMITY_PRECISION)
@@ -1520,7 +1548,7 @@ impl Index {
 
     pub(crate) fn put_proximity_precision(
         &self,
-        txn: &mut RwTxn,
+        txn: &mut RwTxn<'_>,
         val: ProximityPrecision,
     ) -> heed::Result<()> {
         self.main.remap_types::<Str, SerdeBincode<ProximityPrecision>>().put(
@@ -1530,7 +1558,7 @@ impl Index {
         )
     }
 
-    pub(crate) fn delete_proximity_precision(&self, txn: &mut RwTxn) -> heed::Result<bool> {
+    pub(crate) fn delete_proximity_precision(&self, txn: &mut RwTxn<'_>) -> heed::Result<bool> {
         self.main.remap_key_type::<Str>().delete(txn, main_key::PROXIMITY_PRECISION)
     }
 
@@ -1538,13 +1566,16 @@ impl Index {
     /// Retrieve all the documents ids that correspond with (Script, Language) key, `None` if it is any.
     pub fn script_language_documents_ids(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &RoTxn<'_>,
         key: &(Script, Language),
     ) -> heed::Result<Option<RoaringBitmap>> {
         self.script_language_docids.get(rtxn, key)
     }
 
-    pub fn script_language(&self, rtxn: &RoTxn) -> heed::Result<HashMap<Script, Vec<Language>>> {
+    pub fn script_language(
+        &self,
+        rtxn: &RoTxn<'_>,
+    ) -> heed::Result<HashMap<Script, Vec<Language>>> {
         let mut script_language: HashMap<Script, Vec<Language>> = HashMap::new();
         let mut script_language_doc_count: Vec<(Script, Language, u64)> = Vec::new();
         let mut total = 0;
@@ -1605,7 +1636,7 @@ impl Index {
         &'a self,
         rtxn: &'a RoTxn<'a>,
         embedder_id: u8,
-    ) -> impl Iterator<Item = Result<arroy::Reader<arroy::distances::Angular>>> + 'a {
+    ) -> impl Iterator<Item = Result<arroy::Reader<'a, arroy::distances::Angular>>> + 'a {
         crate::vector::arroy_db_range_for_embedder(embedder_id).map_while(move |k| {
             arroy::Reader::open(rtxn, k, self.vector_arroy)
                 .map(Some)
@@ -1763,7 +1794,7 @@ pub(crate) mod tests {
 
         pub fn update_settings(
             &self,
-            update: impl Fn(&mut Settings),
+            update: impl Fn(&mut Settings<'_, '_, '_>),
         ) -> Result<(), crate::error::Error> {
             let mut wtxn = self.write_txn().unwrap();
             self.update_settings_using_wtxn(&mut wtxn, update)?;
@@ -1773,7 +1804,7 @@ pub(crate) mod tests {
         pub fn update_settings_using_wtxn<'t>(
             &'t self,
             wtxn: &mut RwTxn<'t>,
-            update: impl Fn(&mut Settings),
+            update: impl Fn(&mut Settings<'_, '_, '_>),
         ) -> Result<(), crate::error::Error> {
             let mut builder = update::Settings::new(wtxn, &self.inner, &self.indexer_config);
             update(&mut builder);
@@ -2089,7 +2120,7 @@ pub(crate) mod tests {
             .filter(Filter::from_str("_geoBoundingBox([-80, 0], [80, 0])").unwrap().unwrap())
             .execute()
             .unwrap_err();
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(
             error,
             @r###"
         The top latitude `-80` is below the bottom latitude `80`.
@@ -2102,7 +2133,7 @@ pub(crate) mod tests {
             .filter(Filter::from_str("_geoBoundingBox([-10, 0], [10, 0])").unwrap().unwrap())
             .execute()
             .unwrap_err();
-        insta::assert_display_snapshot!(
+        insta::assert_snapshot!(
             error,
             @r###"
         The top latitude `-10` is below the bottom latitude `10`.
@@ -2684,7 +2715,7 @@ pub(crate) mod tests {
                 documents!({ "id" : "doggo", "_geo": { "lat": 1, "lng": 2, "doggo": "are the best" }}),
             )
             .unwrap_err();
-        insta::assert_display_snapshot!(err, @r###"The `_geo` field in the document with the id: `"\"doggo\""` contains the following unexpected fields: `{"doggo":"are the best"}`."###);
+        insta::assert_snapshot!(err, @r###"The `_geo` field in the document with the id: `"\"doggo\""` contains the following unexpected fields: `{"doggo":"are the best"}`."###);
 
         db_snap!(index, geo_faceted_documents_ids); // ensure that no documents were inserted
 
@@ -2694,7 +2725,7 @@ pub(crate) mod tests {
                 documents!({ "id" : "doggo", "_geo": { "lat": 1, "lng": 2, "doggo": "are the best", "and": { "all": ["cats", { "are": "beautiful" } ] } } }),
             )
             .unwrap_err();
-        insta::assert_display_snapshot!(err, @r###"The `_geo` field in the document with the id: `"\"doggo\""` contains the following unexpected fields: `{"and":{"all":["cats",{"are":"beautiful"}]},"doggo":"are the best"}`."###);
+        insta::assert_snapshot!(err, @r###"The `_geo` field in the document with the id: `"\"doggo\""` contains the following unexpected fields: `{"and":{"all":["cats",{"are":"beautiful"}]},"doggo":"are the best"}`."###);
 
         db_snap!(index, geo_faceted_documents_ids); // ensure that no documents were inserted
     }

milli/src/lib.rs

@@ -45,7 +45,7 @@ pub use search::new::{
 };
 use serde_json::Value;
 pub use thread_pool_no_abort::{PanicCatched, ThreadPoolNoAbort, ThreadPoolNoAbortBuilder};
-pub use {charabia as tokenizer, heed};
+pub use {charabia as tokenizer, heed, rhai};
 
 pub use self::asc_desc::{AscDesc, AscDescError, Member, SortError};
 pub use self::criterion::{default_criteria, Criterion, CriterionError};
@@ -211,7 +211,7 @@ pub fn bucketed_position(relative: u16) -> u16 {
 pub fn obkv_to_json(
     displayed_fields: &[FieldId],
     fields_ids_map: &FieldsIdsMap,
-    obkv: obkv::KvReaderU16,
+    obkv: obkv::KvReaderU16<'_>,
 ) -> Result<Object> {
     displayed_fields
         .iter()
@@ -229,7 +229,10 @@ pub fn obkv_to_json(
 }
 
 /// Transform every field of a raw obkv store into a JSON Object.
-pub fn all_obkv_to_json(obkv: obkv::KvReaderU16, fields_ids_map: &FieldsIdsMap) -> Result<Object> {
+pub fn all_obkv_to_json(
+    obkv: obkv::KvReaderU16<'_>,
+    fields_ids_map: &FieldsIdsMap,
+) -> Result<Object> {
     let all_keys = obkv.iter().map(|(k, _v)| k).collect::<Vec<_>>();
     obkv_to_json(all_keys.as_slice(), fields_ids_map, obkv)
 }

milli/src/score_details.rs

@@ -425,9 +425,6 @@ pub struct Sort {
 
 impl PartialOrd for Sort {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        if self.field_name != other.field_name {
-            return None;
-        }
         if self.ascending != other.ascending {
             return None;
         }
@@ -466,9 +463,6 @@ pub struct GeoSort {
 
 impl PartialOrd for GeoSort {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        if self.target_point != other.target_point {
-            return None;
-        }
         if self.ascending != other.ascending {
             return None;
         }

milli/src/search/facet/facet_distribution.rs

@@ -47,7 +47,7 @@ pub struct FacetDistribution<'a> {
 }
 
 impl<'a> FacetDistribution<'a> {
-    pub fn new(rtxn: &'a heed::RoTxn, index: &'a Index) -> FacetDistribution<'a> {
+    pub fn new(rtxn: &'a heed::RoTxn<'a>, index: &'a Index) -> FacetDistribution<'a> {
         FacetDistribution {
             facets: None,
             candidates: None,
@@ -374,7 +374,7 @@ impl<'a> FacetDistribution<'a> {
 }
 
 impl fmt::Debug for FacetDistribution<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let FacetDistribution {
             facets,
             candidates,

milli/src/search/facet/filter.rs

@@ -221,14 +221,14 @@ impl<'a> Filter<'a> {
 }
 
 impl<'a> Filter<'a> {
-    pub fn evaluate(&self, rtxn: &heed::RoTxn, index: &Index) -> Result<RoaringBitmap> {
+    pub fn evaluate(&self, rtxn: &heed::RoTxn<'_>, index: &Index) -> Result<RoaringBitmap> {
         // to avoid doing this for each recursive call we're going to do it ONCE ahead of time
         let filterable_fields = index.filterable_fields(rtxn)?;
         self.inner_evaluate(rtxn, index, &filterable_fields, None)
     }
 
     fn evaluate_operator(
-        rtxn: &heed::RoTxn,
+        rtxn: &heed::RoTxn<'_>,
         index: &Index,
         field_id: FieldId,
         universe: Option<&RoaringBitmap>,
@@ -313,7 +313,7 @@ impl<'a> Filter<'a> {
     /// Aggregates the documents ids that are part of the specified range automatically
     /// going deeper through the levels.
     fn explore_facet_number_levels(
-        rtxn: &heed::RoTxn,
+        rtxn: &heed::RoTxn<'_>,
         db: heed::Database<FacetGroupKeyCodec<OrderedF64Codec>, FacetGroupValueCodec>,
         field_id: FieldId,
         left: Bound<f64>,
@@ -338,7 +338,7 @@ impl<'a> Filter<'a> {
 
     fn inner_evaluate(
         &self,
-        rtxn: &heed::RoTxn,
+        rtxn: &heed::RoTxn<'_>,
         index: &Index,
         filterable_fields: &HashSet<String>,
         universe: Option<&RoaringBitmap>,

milli/src/search/facet/mod.rs

@@ -33,7 +33,7 @@ fn facet_extreme_value<'t>(
 
 pub fn facet_min_value<'t>(
     index: &'t Index,
-    rtxn: &'t heed::RoTxn,
+    rtxn: &'t heed::RoTxn<'t>,
     field_id: u16,
     candidates: RoaringBitmap,
 ) -> Result<Option<f64>> {
@@ -44,7 +44,7 @@ pub fn facet_min_value<'t>(
 
 pub fn facet_max_value<'t>(
     index: &'t Index,
-    rtxn: &'t heed::RoTxn,
+    rtxn: &'t heed::RoTxn<'t>,
     field_id: u16,
     candidates: RoaringBitmap,
 ) -> Result<Option<f64>> {
@@ -55,7 +55,7 @@ pub fn facet_max_value<'t>(
 
 /// Get the first facet value in the facet database
 pub(crate) fn get_first_facet_value<'t, BoundCodec, DC>(
-    txn: &'t RoTxn,
+    txn: &'t RoTxn<'t>,
     db: heed::Database<FacetGroupKeyCodec<BytesRefCodec>, DC>,
     field_id: u16,
 ) -> heed::Result<Option<BoundCodec::DItem>>
@@ -79,7 +79,7 @@ where
 
 /// Get the last facet value in the facet database
 pub(crate) fn get_last_facet_value<'t, BoundCodec, DC>(
-    txn: &'t RoTxn,
+    txn: &'t RoTxn<'t>,
     db: heed::Database<FacetGroupKeyCodec<BytesRefCodec>, DC>,
     field_id: u16,
 ) -> heed::Result<Option<BoundCodec::DItem>>

milli/src/search/mod.rs

@@ -55,7 +55,7 @@ pub struct Search<'a> {
 }
 
 impl<'a> Search<'a> {
-    pub fn new(rtxn: &'a heed::RoTxn, index: &'a Index) -> Search<'a> {
+    pub fn new(rtxn: &'a heed::RoTxn<'a>, index: &'a Index) -> Search<'a> {
         Search {
             query: None,
             filter: None,
@@ -253,7 +253,7 @@ impl<'a> Search<'a> {
 }
 
 impl fmt::Debug for Search<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Search {
             query,
             filter,

milli/src/search/new/db_cache.rs

@@ -46,38 +46,72 @@ pub struct DatabaseCache<'ctx> {
     pub word_prefix_fids: FxHashMap<Interned<String>, Vec<u16>>,
 }
 impl<'ctx> DatabaseCache<'ctx> {
-    fn get_value<'v, K1, KC, DC>(
-        txn: &'ctx RoTxn,
+    fn get_value<'v, K1, KC>(
+        txn: &'ctx RoTxn<'_>,
         cache_key: K1,
         db_key: &'v KC::EItem,
         cache: &mut FxHashMap<K1, Option<Cow<'ctx, [u8]>>>,
+        universe: Option<&RoaringBitmap>,
         db: Database<KC, Bytes>,
-    ) -> Result<Option<DC::DItem>>
+    ) -> Result<Option<RoaringBitmap>>
     where
         K1: Copy + Eq + Hash,
         KC: BytesEncode<'v>,
-        DC: BytesDecodeOwned,
     {
         if let Entry::Vacant(entry) = cache.entry(cache_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)
+        let bitmap_bytes = match cache.get(&cache_key).unwrap() {
+            Some(Cow::Borrowed(bytes)) => bytes,
+            Some(Cow::Owned(bytes)) => bytes.as_slice(),
+            None => return Ok(None),
+        };
+
+        match (bitmap_bytes, universe) {
+            (bytes, Some(universe)) => {
+                CboRoaringBitmapCodec::intersection_with_serialized(bytes, universe)
+                    .map(Some)
+                    .map_err(Into::into)
+            }
+            (bytes, None) => CboRoaringBitmapCodec::bytes_decode_owned(bytes)
                 .map(Some)
                 .map_err(heed::Error::Decoding)
                 .map_err(Into::into),
-            Some(Cow::Owned(bytes)) => DC::bytes_decode_owned(bytes)
-                .map(Some)
-                .map_err(heed::Error::Decoding)
-                .map_err(Into::into),
-            None => Ok(None),
         }
     }
 
+    fn get_value_length<'v, K1, KC>(
+        txn: &'ctx RoTxn<'_>,
+        cache_key: K1,
+        db_key: &'v KC::EItem,
+        cache: &mut FxHashMap<K1, Option<Cow<'ctx, [u8]>>>,
+        db: Database<KC, Bytes>,
+    ) -> Result<Option<u64>>
+    where
+        K1: Copy + Eq + Hash,
+        KC: BytesEncode<'v>,
+    {
+        if let Entry::Vacant(entry) = cache.entry(cache_key) {
+            let bitmap_ptr = db.get(txn, db_key)?.map(Cow::Borrowed);
+            entry.insert(bitmap_ptr);
+        }
+
+        let bitmap_bytes = match cache.get(&cache_key).unwrap() {
+            Some(Cow::Borrowed(bytes)) => bytes,
+            Some(Cow::Owned(bytes)) => bytes.as_slice(),
+            None => return Ok(None),
+        };
+
+        CboRoaringBitmapLenCodec::bytes_decode_owned(bitmap_bytes)
+            .map(Some)
+            .map_err(heed::Error::Decoding)
+            .map_err(Into::into)
+    }
+
     fn get_value_from_keys<'v, K1, KC, DC>(
-        txn: &'ctx RoTxn,
+        txn: &'ctx RoTxn<'_>,
         cache_key: K1,
         db_keys: &'v [KC::EItem],
         cache: &mut FxHashMap<K1, Option<Cow<'ctx, [u8]>>>,
@@ -99,7 +133,7 @@ impl<'ctx> DatabaseCache<'ctx> {
                         .iter()
                         .filter_map(|key| db.get(txn, key).transpose())
                         .map(|v| v.map(Cow::Borrowed))
-                        .collect::<std::result::Result<Vec<Cow<[u8]>>, _>>()?;
+                        .collect::<std::result::Result<Vec<Cow<'_, [u8]>>, _>>()?;
 
                     if bitmaps.is_empty() {
                         None
@@ -137,11 +171,15 @@ impl<'ctx> SearchContext<'ctx> {
         }
     }
 
-    pub fn word_docids(&mut self, word: Word) -> Result<Option<RoaringBitmap>> {
+    pub fn word_docids(
+        &mut self,
+        universe: Option<&RoaringBitmap>,
+        word: Word,
+    ) -> Result<Option<RoaringBitmap>> {
         match word {
             Word::Original(word) => {
-                let exact = self.get_db_exact_word_docids(word)?;
-                let tolerant = self.get_db_word_docids(word)?;
+                let exact = self.get_db_exact_word_docids(universe, word)?;
+                let tolerant = self.get_db_word_docids(universe, word)?;
                 Ok(match (exact, tolerant) {
                     (None, None) => None,
                     (None, Some(tolerant)) => Some(tolerant),
@@ -153,12 +191,16 @@ impl<'ctx> SearchContext<'ctx> {
                     }
                 })
             }
-            Word::Derived(word) => self.get_db_word_docids(word),
+            Word::Derived(word) => self.get_db_word_docids(universe, word),
         }
     }
 
     /// Retrieve or insert the given value in the `word_docids` database.
-    fn get_db_word_docids(&mut self, word: Interned<String>) -> Result<Option<RoaringBitmap>> {
+    fn get_db_word_docids(
+        &mut self,
+        universe: Option<&RoaringBitmap>,
+        word: Interned<String>,
+    ) -> Result<Option<RoaringBitmap>> {
         match &self.restricted_fids {
             Some(restricted_fids) => {
                 let interned = self.word_interner.get(word).as_str();
@@ -174,11 +216,12 @@ impl<'ctx> SearchContext<'ctx> {
                     merge_cbo_roaring_bitmaps,
                 )
             }
-            None => DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+            None => DatabaseCache::get_value::<_, _>(
                 self.txn,
                 word,
                 self.word_interner.get(word).as_str(),
                 &mut self.db_cache.word_docids,
+                universe,
                 self.index.word_docids.remap_data_type::<Bytes>(),
             ),
         }
@@ -186,6 +229,7 @@ impl<'ctx> SearchContext<'ctx> {
 
     fn get_db_exact_word_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
         match &self.restricted_fids {
@@ -203,21 +247,26 @@ impl<'ctx> SearchContext<'ctx> {
                     merge_cbo_roaring_bitmaps,
                 )
             }
-            None => DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+            None => DatabaseCache::get_value::<_, _>(
                 self.txn,
                 word,
                 self.word_interner.get(word).as_str(),
                 &mut self.db_cache.exact_word_docids,
+                universe,
                 self.index.exact_word_docids.remap_data_type::<Bytes>(),
             ),
         }
     }
 
-    pub fn word_prefix_docids(&mut self, prefix: Word) -> Result<Option<RoaringBitmap>> {
+    pub fn word_prefix_docids(
+        &mut self,
+        universe: Option<&RoaringBitmap>,
+        prefix: Word,
+    ) -> Result<Option<RoaringBitmap>> {
         match prefix {
             Word::Original(prefix) => {
-                let exact = self.get_db_exact_word_prefix_docids(prefix)?;
-                let tolerant = self.get_db_word_prefix_docids(prefix)?;
+                let exact = self.get_db_exact_word_prefix_docids(universe, prefix)?;
+                let tolerant = self.get_db_word_prefix_docids(universe, prefix)?;
                 Ok(match (exact, tolerant) {
                     (None, None) => None,
                     (None, Some(tolerant)) => Some(tolerant),
@@ -229,13 +278,14 @@ impl<'ctx> SearchContext<'ctx> {
                     }
                 })
             }
-            Word::Derived(prefix) => self.get_db_word_prefix_docids(prefix),
+            Word::Derived(prefix) => self.get_db_word_prefix_docids(universe, prefix),
         }
     }
 
     /// Retrieve or insert the given value in the `word_prefix_docids` database.
     fn get_db_word_prefix_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         prefix: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
         match &self.restricted_fids {
@@ -253,11 +303,12 @@ impl<'ctx> SearchContext<'ctx> {
                     merge_cbo_roaring_bitmaps,
                 )
             }
-            None => DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+            None => DatabaseCache::get_value::<_, _>(
                 self.txn,
                 prefix,
                 self.word_interner.get(prefix).as_str(),
                 &mut self.db_cache.word_prefix_docids,
+                universe,
                 self.index.word_prefix_docids.remap_data_type::<Bytes>(),
             ),
         }
@@ -265,6 +316,7 @@ impl<'ctx> SearchContext<'ctx> {
 
     fn get_db_exact_word_prefix_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         prefix: Interned<String>,
     ) -> Result<Option<RoaringBitmap>> {
         match &self.restricted_fids {
@@ -282,11 +334,12 @@ impl<'ctx> SearchContext<'ctx> {
                     merge_cbo_roaring_bitmaps,
                 )
             }
-            None => DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+            None => DatabaseCache::get_value::<_, _>(
                 self.txn,
                 prefix,
                 self.word_interner.get(prefix).as_str(),
                 &mut self.db_cache.exact_word_prefix_docids,
+                universe,
                 self.index.exact_word_prefix_docids.remap_data_type::<Bytes>(),
             ),
         }
@@ -294,6 +347,7 @@ impl<'ctx> SearchContext<'ctx> {
 
     pub fn get_db_word_pair_proximity_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word1: Interned<String>,
         word2: Interned<String>,
         proximity: u8,
@@ -320,8 +374,8 @@ impl<'ctx> SearchContext<'ctx> {
                     for fid in fids {
                         // for each field, intersect left word bitmap and right word bitmap,
                         // then merge the result in a global bitmap before storing it in the cache.
-                        let word1_docids = self.get_db_word_fid_docids(word1, fid)?;
-                        let word2_docids = self.get_db_word_fid_docids(word2, fid)?;
+                        let word1_docids = self.get_db_word_fid_docids(universe, word1, fid)?;
+                        let word2_docids = self.get_db_word_fid_docids(universe, word2, fid)?;
                         if let (Some(word1_docids), Some(word2_docids)) =
                             (word1_docids, word2_docids)
                         {
@@ -341,7 +395,33 @@ impl<'ctx> SearchContext<'ctx> {
 
                 Ok(docids)
             }
-            ProximityPrecision::ByWord => DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+            ProximityPrecision::ByWord => DatabaseCache::get_value::<_, _>(
+                self.txn,
+                (proximity, word1, word2),
+                &(
+                    proximity,
+                    self.word_interner.get(word1).as_str(),
+                    self.word_interner.get(word2).as_str(),
+                ),
+                &mut self.db_cache.word_pair_proximity_docids,
+                universe,
+                self.index.word_pair_proximity_docids.remap_data_type::<Bytes>(),
+            ),
+        }
+    }
+
+    pub fn get_db_word_pair_proximity_docids_len(
+        &mut self,
+        universe: Option<&RoaringBitmap>,
+        word1: Interned<String>,
+        word2: Interned<String>,
+        proximity: u8,
+    ) -> Result<Option<u64>> {
+        match self.index.proximity_precision(self.txn)?.unwrap_or_default() {
+            ProximityPrecision::ByAttribute => Ok(self
+                .get_db_word_pair_proximity_docids(universe, word1, word2, proximity)?
+                .map(|d| d.len())),
+            ProximityPrecision::ByWord => DatabaseCache::get_value_length::<_, _>(
                 self.txn,
                 (proximity, word1, word2),
                 &(
@@ -355,34 +435,9 @@ impl<'ctx> SearchContext<'ctx> {
         }
     }
 
-    pub fn get_db_word_pair_proximity_docids_len(
-        &mut self,
-        word1: Interned<String>,
-        word2: Interned<String>,
-        proximity: u8,
-    ) -> Result<Option<u64>> {
-        match self.index.proximity_precision(self.txn)?.unwrap_or_default() {
-            ProximityPrecision::ByAttribute => Ok(self
-                .get_db_word_pair_proximity_docids(word1, word2, proximity)?
-                .map(|d| d.len())),
-            ProximityPrecision::ByWord => {
-                DatabaseCache::get_value::<_, _, CboRoaringBitmapLenCodec>(
-                    self.txn,
-                    (proximity, word1, word2),
-                    &(
-                        proximity,
-                        self.word_interner.get(word1).as_str(),
-                        self.word_interner.get(word2).as_str(),
-                    ),
-                    &mut self.db_cache.word_pair_proximity_docids,
-                    self.index.word_pair_proximity_docids.remap_data_type::<Bytes>(),
-                )
-            }
-        }
-    }
-
     pub fn get_db_word_prefix_pair_proximity_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word1: Interned<String>,
         prefix2: Interned<String>,
         mut proximity: u8,
@@ -409,8 +464,9 @@ impl<'ctx> SearchContext<'ctx> {
                     // for each field, intersect left word bitmap and right word bitmap,
                     // then merge the result in a global bitmap before storing it in the cache.
                     for fid in fids {
-                        let word1_docids = self.get_db_word_fid_docids(word1, fid)?;
-                        let prefix2_docids = self.get_db_word_prefix_fid_docids(prefix2, fid)?;
+                        let word1_docids = self.get_db_word_fid_docids(universe, word1, fid)?;
+                        let prefix2_docids =
+                            self.get_db_word_prefix_fid_docids(universe, prefix2, fid)?;
                         if let (Some(word1_docids), Some(prefix2_docids)) =
                             (word1_docids, prefix2_docids)
                         {
@@ -452,16 +508,18 @@ impl<'ctx> SearchContext<'ctx> {
 
     pub fn get_db_prefix_word_pair_proximity_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         left_prefix: Interned<String>,
         right: Interned<String>,
         proximity: u8,
     ) -> Result<Option<RoaringBitmap>> {
         // only accept exact matches on reverted positions
-        self.get_db_word_pair_proximity_docids(left_prefix, right, proximity)
+        self.get_db_word_pair_proximity_docids(universe, left_prefix, right, proximity)
     }
 
     pub fn get_db_word_fid_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word: Interned<String>,
         fid: u16,
     ) -> Result<Option<RoaringBitmap>> {
@@ -470,17 +528,19 @@ impl<'ctx> SearchContext<'ctx> {
             return Ok(None);
         }
 
-        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+        DatabaseCache::get_value::<_, _>(
             self.txn,
             (word, fid),
             &(self.word_interner.get(word).as_str(), fid),
             &mut self.db_cache.word_fid_docids,
+            universe,
             self.index.word_fid_docids.remap_data_type::<Bytes>(),
         )
     }
 
     pub fn get_db_word_prefix_fid_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word_prefix: Interned<String>,
         fid: u16,
     ) -> Result<Option<RoaringBitmap>> {
@@ -489,11 +549,12 @@ impl<'ctx> SearchContext<'ctx> {
             return Ok(None);
         }
 
-        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+        DatabaseCache::get_value::<_, _>(
             self.txn,
             (word_prefix, fid),
             &(self.word_interner.get(word_prefix).as_str(), fid),
             &mut self.db_cache.word_prefix_fid_docids,
+            universe,
             self.index.word_prefix_fid_docids.remap_data_type::<Bytes>(),
         )
     }
@@ -554,28 +615,32 @@ impl<'ctx> SearchContext<'ctx> {
 
     pub fn get_db_word_position_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word: Interned<String>,
         position: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+        DatabaseCache::get_value::<_, _>(
             self.txn,
             (word, position),
             &(self.word_interner.get(word).as_str(), position),
             &mut self.db_cache.word_position_docids,
+            universe,
             self.index.word_position_docids.remap_data_type::<Bytes>(),
         )
     }
 
     pub fn get_db_word_prefix_position_docids(
         &mut self,
+        universe: Option<&RoaringBitmap>,
         word_prefix: Interned<String>,
         position: u16,
     ) -> Result<Option<RoaringBitmap>> {
-        DatabaseCache::get_value::<_, _, CboRoaringBitmapCodec>(
+        DatabaseCache::get_value::<_, _>(
             self.txn,
             (word_prefix, position),
             &(self.word_interner.get(word_prefix).as_str(), position),
             &mut self.db_cache.word_prefix_position_docids,
+            universe,
             self.index.word_prefix_position_docids.remap_data_type::<Bytes>(),
         )
     }

milli/src/search/new/distinct.rs

@@ -23,7 +23,7 @@ pub struct DistinctOutput {
 /// - `excluded`: the set of document ids that contain a value for the given field that occurs
 /// in the given candidates.
 pub fn apply_distinct_rule(
-    ctx: &mut SearchContext,
+    ctx: &mut SearchContext<'_>,
     field_id: u16,
     candidates: &RoaringBitmap,
 ) -> Result<DistinctOutput> {
@@ -42,7 +42,7 @@ pub fn apply_distinct_rule(
 /// Apply the distinct rule defined by [`apply_distinct_rule`] for a single document id.
 pub fn distinct_single_docid(
     index: &Index,
-    txn: &RoTxn,
+    txn: &RoTxn<'_>,
     field_id: u16,
     docid: u32,
     excluded: &mut RoaringBitmap,
@@ -72,7 +72,7 @@ pub fn distinct_single_docid(
 /// Return all the docids containing the given value in the given field
 fn facet_value_docids(
     database: Database<FacetGroupKeyCodec<BytesRefCodec>, FacetGroupValueCodec>,
-    txn: &RoTxn,
+    txn: &RoTxn<'_>,
     field_id: u16,
     facet_value: &[u8],
 ) -> heed::Result<Option<RoaringBitmap>> {
@@ -86,7 +86,7 @@ fn facet_number_values<'a>(
     docid: u32,
     field_id: u16,
     index: &Index,
-    txn: &'a RoTxn,
+    txn: &'a RoTxn<'a>,
 ) -> Result<RoPrefix<'a, FieldDocIdFacetCodec<BytesRefCodec>, Unit>> {
     let key = facet_values_prefix_key(field_id, docid);
 
@@ -104,7 +104,7 @@ pub fn facet_string_values<'a>(
     docid: u32,
     field_id: u16,
     index: &Index,
-    txn: &'a RoTxn,
+    txn: &'a RoTxn<'a>,
 ) -> Result<RoPrefix<'a, FieldDocIdFacetCodec<BytesRefCodec>, Str>> {
     let key = facet_values_prefix_key(field_id, docid);
 

milli/src/search/new/exact_attribute.rs

@@ -1,3 +1,4 @@
+use heed::types::Bytes;
 use roaring::{MultiOps, RoaringBitmap};
 
 use super::query_graph::QueryGraph;
@@ -5,7 +6,7 @@ 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};
+use crate::{CboRoaringBitmapCodec, Result, SearchContext, SearchLogger};
 
 /// A ranking rule that produces 3 disjoint buckets:
 ///
@@ -171,9 +172,9 @@ impl State {
                 // Note: Since the position is stored bucketed in word_position_docids, for queries with a lot of
                 // longer phrases we'll be losing on precision here.
                 let bucketed_position = crate::bucketed_position(position + offset);
-                let word_position_docids =
-                    ctx.get_db_word_position_docids(*word, bucketed_position)?.unwrap_or_default()
-                        & universe;
+                let word_position_docids = ctx
+                    .get_db_word_position_docids(Some(universe), *word, bucketed_position)?
+                    .unwrap_or_default();
                 candidates &= word_position_docids;
                 if candidates.is_empty() {
                     return Ok(State::Empty(query_graph.clone()));
@@ -192,26 +193,34 @@ impl State {
         let mut candidates_per_attribute = Vec::with_capacity(searchable_fields_ids.len());
         // then check that there exists at least one attribute that has all of the terms
         for fid in searchable_fields_ids {
-            let mut intersection = MultiOps::intersection(
+            let intersection = MultiOps::intersection(
                 words_positions
                     .iter()
                     .flat_map(|(words, ..)| words.iter())
                     // ignore stop words words in phrases
                     .flatten()
                     .map(|word| -> Result<_> {
-                        Ok(ctx.get_db_word_fid_docids(*word, fid)?.unwrap_or_default())
+                        Ok(ctx
+                            .get_db_word_fid_docids(Some(&candidates), *word, fid)?
+                            .unwrap_or_default())
                     }),
             )?;
-            intersection &= &candidates;
             if !intersection.is_empty() {
                 // Although not really worth it in terms of performance,
                 // if would be good to put this in cache for the sake of consistency
                 let candidates_with_exact_word_count = if count_all_positions < u8::MAX as usize {
-                    ctx.index
+                    let bitmap_bytes = ctx
+                        .index
                         .field_id_word_count_docids
-                        .get(ctx.txn, &(fid, count_all_positions as u8))?
-                        .unwrap_or_default()
-                        & universe
+                        .remap_data_type::<Bytes>()
+                        .get(ctx.txn, &(fid, count_all_positions as u8))?;
+
+                    match bitmap_bytes {
+                        Some(bytes) => {
+                            CboRoaringBitmapCodec::intersection_with_serialized(bytes, universe)?
+                        }
+                        None => RoaringBitmap::default(),
+                    }
                 } else {
                     RoaringBitmap::default()
                 };
@@ -234,6 +243,8 @@ impl State {
         let (state, output) = match state {
             State::Uninitialized => (state, None),
             State::ExactAttribute(query_graph, candidates_per_attribute) => {
+                // TODO it can be much faster to do the intersections before the unions...
+                //      or maybe the candidates_per_attribute are not containing anything outside universe
                 let mut candidates = MultiOps::union(candidates_per_attribute.iter().map(
                     |FieldCandidates { start_with_exact, exact_word_count }| {
                         start_with_exact & exact_word_count
@@ -252,6 +263,8 @@ impl State {
                 )
             }
             State::AttributeStarts(query_graph, candidates_per_attribute) => {
+                // TODO it can be much faster to do the intersections before the unions...
+                //      or maybe the candidates_per_attribute are not containing anything outside universe
                 let mut candidates = MultiOps::union(candidates_per_attribute.into_iter().map(
                     |FieldCandidates { mut start_with_exact, exact_word_count }| {
                         start_with_exact -= exact_word_count;