Merge pull request #349 from meilisearch/bump-version

Bump meilisearch crates to v0.8.2

.dockerignore

@@ -0,0 +1,5 @@
+target
+Dockerfile
+.dockerignore
+.git
+.gitignore

.github/workflows/README.md

@@ -0,0 +1,11 @@
+# GitHub actions workflow for MeiliDB
+
+> **Note:**
+
+> - We do not use [cache](https://github.com/actions/cache) yet but we could use it to speed up CI
+
+## Workflow
+
+- On each pull request, we are triggering `cargo test`.
+- On each commit on master, we are building the latest docker image.
+- On each tag, we are building the tagged docker image and the binaries for MacOS & Ubuntu.

.github/workflows/publish-binaries.yml

@@ -0,0 +1,36 @@
+name: Publish binaries to GitHub release
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish:
+    name: Publish for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        include:
+          - os: ubuntu-latest
+            artifact_name: meilisearch
+            asset_name: meilisearch-linux-amd64
+          - os: macos-latest
+            artifact_name: meilisearch
+            asset_name: meilisearch-macos-amd64
+
+    steps:
+    - uses: hecrj/setup-rust-action@master
+      with:
+        rust-version: stable
+    - uses: actions/checkout@v1
+    - name: Build
+      run: cargo build --release --locked
+    - name: Upload binaries to release
+      uses: svenstaro/upload-release-action@v1-release
+      with:
+        repo_token: ${{ secrets.GITHUB_TOKEN }}
+        file: target/release/${{ matrix.artifact_name }}
+        asset_name: ${{ matrix.asset_name }}
+        tag: ${{ github.ref }}

.github/workflows/publish-docker-latest.yml

@@ -0,0 +1,19 @@
+---
+on:
+  push:
+    branches:
+      - master
+
+name: Publish latest image to Docker Hub
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Publish to Registry
+        uses: elgohr/Publish-Docker-Github-Action@master
+        with:
+          name: getmeili/meilisearch
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}

.github/workflows/publish-docker-tag.yml

@@ -0,0 +1,20 @@
+---
+on:
+  push:
+    tags:
+      - '*'
+
+name: Publish tagged image to Docker Hub
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Publish to Registry
+        uses: elgohr/Publish-Docker-Github-Action@master
+        with:
+          name: getmeili/meilisearch
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+          tag_names: true

.github/workflows/test.yml

@@ -0,0 +1,21 @@
+---
+on: [pull_request]
+
+name: Cargo test
+
+jobs:
+  check:
+    name: MeiliSearch
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - name: Run cargo test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --locked

.gitignore

@@ -1,5 +1,4 @@
 /target
-Cargo.lock
 **/*.csv
 **/*.json_lines
 **/*.rs.bk

Cargo.toml

@@ -1,9 +1,10 @@
 [workspace]
 members = [
-    "meilidb-core",
-    "meilidb-http",
-    "meilidb-schema",
-    "meilidb-tokenizer",
+    "meilisearch-core",
+    "meilisearch-http",
+    "meilisearch-schema",
+    "meilisearch-tokenizer",
+    "meilisearch-types",
 ]
 
 [profile.release]

Dockerfile

@@ -0,0 +1,27 @@
+# Compile
+FROM    alpine:3.10 AS compiler
+
+RUN     apk update --quiet
+RUN     apk add curl
+RUN     apk add build-base
+
+RUN     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+
+WORKDIR /meilisearch
+
+COPY    . .
+
+ENV     RUSTFLAGS="-C target-feature=-crt-static"
+
+RUN     $HOME/.cargo/bin/cargo build --release
+
+# Run
+FROM    alpine:3.10
+
+RUN     apk update --quiet
+RUN     apk add libgcc
+
+COPY    --from=compiler /meilisearch/target/release/meilisearch .
+
+ENV     MEILI_HTTP_ADDR 0.0.0.0:8080
+CMD     ./meilisearch

LICENSE

@@ -1,13 +1,21 @@
-“Commons Clause” License Condition v1.0
+MIT License
 
-The Software is provided to you by the Licensor under the License, as defined below, subject to the following condition.
+Copyright (c) 2019-2020 Meili SAS
 
-Without limiting other conditions in the License, the grant of rights under the License will not include, and the License does not grant to you, the right to Sell the Software.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/ support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software. Any license notice or attribution required by the License must also include this Commons Clause License Condition notice.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Software: MeiliDB
-
-License: MIT
-
-Licensor: MEILI SAS
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,44 +1,122 @@
-# MeiliDB
+# MeiliSearch
 
-[![Build Status](https://dev.azure.com/thomas0884/thomas/_apis/build/status/meilisearch.MeiliDB?branchName=master)](https://dev.azure.com/thomas0884/thomas/_build/latest?definitionId=1&branchName=master)
-[![dependency status](https://deps.rs/repo/github/meilisearch/MeiliDB/status.svg)](https://deps.rs/repo/github/meilisearch/MeiliDB)
-[![License](https://img.shields.io/badge/license-commons%20clause-lightgrey)](https://commonsclause.com/)
+[![Build Status](https://github.com/meilisearch/MeiliSearch/workflows/Cargo%20test/badge.svg)](https://github.com/meilisearch/MeiliSearch/actions)
+[![dependency status](https://deps.rs/repo/github/meilisearch/MeiliSearch/status.svg)](https://deps.rs/repo/github/meilisearch/MeiliSearch)
+[![License](https://img.shields.io/badge/license-MIT-informational)](https://github.com/meilisearch/MeiliSearch/blob/master/LICENSE)
 
-A _full-text search database_ based on the fast [LMDB key-value store](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database).
+⚡ Ultra relevant and instant full-text search API 🔍
 
-## Features
+MeiliSearch is a powerful, fast, open-source, easy to use, and deploy search engine. The search and indexation are fully customizable and handles features like typo-tolerance, filters, and synonyms.
 
-- Provides [6 default ranking criteria](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/criterion/mod.rs#L107-L113) used to [bucket sort](https://en.wikipedia.org/wiki/Bucket_sort) documents
-- Accepts [custom criteria](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/criterion/mod.rs#L24-L33) and can apply them in any custom order
-- Support [ranged queries](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/query_builder.rs#L283), useful for paginating results
-- Can [distinct](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/query_builder.rs#L265-L270) and [filter](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/query_builder.rs#L246-L259) returned documents based on context defined rules
-- Searches for [concatenated](https://github.com/meilisearch/MeiliDB/pull/164) and [splitted query words](https://github.com/meilisearch/MeiliDB/pull/232) to improve the search quality.
-- Can store complete documents or only [user schema specified fields](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-schema/src/lib.rs#L265-L279)
-- The [default tokenizer](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-tokenizer/src/lib.rs) can index latin and kanji based languages
-- Returns [the matching text areas](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/lib.rs#L66-L88), useful to highlight matched words in results
-- Accepts query time search config like the [searchable attributes](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/query_builder.rs#L272-L275)
-- Supports [runtime incremental indexing](https://github.com/meilisearch/MeiliDB/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilidb-core/src/store/mod.rs#L143-L173)
+## What MeiliSearch has to offer
+* Search as-you-type experience (answers < 50ms)
+* Full-text search
+* Typo tolerant (understands typos and spelling mistakes)
+* Supports Kanji
+* Supports Synonym
+* Easy to install, deploy, and maintain
+* Whole documents returned
+* Highly customizable
+* RESTfull API 
+
+For more [details about those features, go to our documentation](https://docs.meilisearch.com/introduction/features.html).
+
+[![crates.io demo gif](misc/crates-io-demo.gif)](https://crates.meilisearch.com)
+
+> Meili helps the Rust community find crates on [crates.meilisearch.com](https://crates.meilisearch.com)
+
+### In-depth features
+
+- Provides [6 default ranking criteria](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/criterion/mod.rs#L107-L113) used to [bucket sort](https://en.wikipedia.org/wiki/Bucket_sort) documents
+- Accepts [custom criteria](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/criterion/mod.rs#L24-L33) and can apply them in any custom order
+- Support [ranged queries](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/query_builder.rs#L283), useful for paginating results
+- Can [distinct](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/query_builder.rs#L265-L270) and [filter](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/query_builder.rs#L246-L259) returned documents based on context defined rules
+- Searches for [concatenated](https://github.com/meilisearch/MeiliSearch/pull/164) and [splitted query words](https://github.com/meilisearch/MeiliSearch/pull/232) to improve the search quality.
+- Can store complete documents or only [user schema specified fields](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-schema/src/lib.rs#L265-L279)
+- The [default tokenizer](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-tokenizer/src/lib.rs) can index latin and kanji based languages
+- Returns [the matching text areas](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/lib.rs#L66-L88), useful to highlight matched words in results
+- Accepts query time search config like the [searchable attributes](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/query_builder.rs#L272-L275)
+- Supports [runtime incremental indexing](https://github.com/meilisearch/MeiliSearch/blob/dc5c42821e1340e96cb90a3da472264624a26326/meilisearch-core/src/store/mod.rs#L143-L173)
 
 
+## Quick Start
 
-It uses [LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database) as the internal key-value store. The key-value store allows us to handle updates and queries with small memory and CPU overheads. The whole ranking system is [data oriented](https://github.com/meilisearch/MeiliDB/issues/82) and provides great performances.
+You can deploy your instant, relevant, and typo-tolerant MeiliSearch search engine by yourself too.
+Something similar to the demo above can be achieved by following these little three steps first.
+You still need to create your front-end to make it pretty, though.
 
-You can [read the deep dive](deep-dive.md) if you want more information on the engine, it describes the whole process of generating updates and handling queries or you can take a look at the [typos and ranking rules](typos-ranking-rules.md) if you want to know the default rules used to sort the documents.
+### Deploy the Server
 
-We will be proud if you submit issues and pull requests. You can help to grow this project and start contributing by checking [issues tagged "good-first-issue"](https://github.com/meilisearch/MeiliDB/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22). It is a good start!
+If you have not yet installed Rust and its package manager `cargo`, go to [the installation page](https://www.rust-lang.org/tools/install).<br/>
+You can deploy the server on your machine; it listens to HTTP requests on the 8080 port by default.
 
-The project is only a library yet. It means that there is no binary provided yet. To get started, you can check the examples wich are made to work with the data located in the `datasets/` folder.
+```bash
+cargo run --release
+```
 
-MeiliDB will be a binary in a near future so you will be able to use it as a database out-of-the-box. We should be able to query it using HTTP. This is our current goal, [see the milestones](https://github.com/meilisearch/MeiliDB/milestones). In the end, the binary will be a bunch of network protocols and wrappers around the library - which will also be published on [crates.io](https://crates.io). Both the binary and the library will follow the same update cycle.
+For more logs during the execution, run:
+```bash
+RUST_LOG=info cargo run --release
+```
 
+### Create an Index and Upload Some Documents
 
+MeiliSearch can serve multiple indexes, with different kinds of documents,
+therefore, it is required to create the index before sending documents to it.
+
+```bash
+curl -i -X POST 'http://127.0.0.1:8080/indexes' --data '{ "name": "Movies", "uid": "movies" }'
+```
+
+Now that the server knows about our brand new index, we can send it data.
+We provided you a small dataset that is available in the `datasets/` directory.
+
+```bash
+curl -i -X POST 'http://127.0.0.1:8080/indexes/movies/documents' \
+  --header 'content-type: application/json' \
+  --data @datasets/movies/movies.json
+```
+
+### Search for Documents
+
+The search engine is now aware of our documents and can serve those via our HTTP server again.
+The [`jq` command-line tool](https://stedolan.github.io/jq/) can significantly help you read the server responses.
+
+```bash
+curl 'http://127.0.0.1:8080/indexes/movies/search?q=botman'
+```
+
+```json
+{
+  "hits": [
+    {
+      "id": "29751",
+      "title": "Batman Unmasked: The Psychology of the Dark Knight",
+      "poster": "https://image.tmdb.org/t/p/w1280/jjHu128XLARc2k4cJrblAvZe0HE.jpg",
+      "overview": "Delve into the world of Batman and the vigilante justice tha",
+      "release_date": "2008-07-15"
+    },
+    {
+      "id": "471474",
+      "title": "Batman: Gotham by Gaslight",
+      "poster": "https://image.tmdb.org/t/p/w1280/7souLi5zqQCnpZVghaXv0Wowi0y.jpg",
+      "overview": "ve Victorian Age Gotham City, Batman begins his war on crime",
+      "release_date": "2018-01-12"
+    }
+  ],
+  "offset": 0,
+  "limit": 2,
+  "processingTimeMs": 1,
+  "query": "botman"
+}
+```
 
 ## Performances
 
-With a database composed of _100 353_ documents with _352_ attributes each and _3_ of them indexed.
+With a dataset composed of _100 353_ documents with _352_ attributes each and _3_ of them indexed.
 So more than _300 000_ fields indexed for _35 million_ stored we can handle more than _2.8k req/sec_ with an average response time of _9 ms_ on an Intel i7-7700 (8) @ 4.2GHz.
 
-Requests are made using [wrk](https://github.com/wg/wrk) and scripted to simulate real users queries.
+Requests are made using [wrk](https://github.com/wg/wrk) and scripted to simulate real users' queries.
 
 ```
 Running 10s test @ http://localhost:2230
@@ -51,29 +129,26 @@ Requests/sec:   2806.46
 Transfer/sec:    759.17KB
 ```
 
+We also indexed a dataset containing something like _12 millions_ cities names in _24 minutes_ on a machine with _8 cores_, _64 GB of RAM_, and a _300 GB NMVe_ SSD.<br/>
+The resulting database was _16 GB_ and search results were between _30 ms_ and _4 seconds_ for short prefix queries.
+
 ### Notes
 
 With Rust 1.32 the allocator has been [changed to use the system allocator](https://blog.rust-lang.org/2019/01/17/Rust-1.32.0.html#jemalloc-is-removed-by-default).
 We have seen much better performances when [using jemalloc as the global allocator](https://github.com/alexcrichton/jemallocator#documentation).
 
-## Usage and examples
+## How it works
 
-Currently MeiliDB do not provide an http server but you can run the example binary.
+MeiliSearch uses [LMDB](https://en.wikipedia.org/wiki/Lightning_Memory-Mapped_Database) as the internal key-value store. The key-value store allows us to handle updates and queries with small memory and CPU overheads. The whole ranking system is [data oriented](https://github.com/meilisearch/MeiliSearch/issues/82) and provides excellent great performances.
 
-The _index_ subcommand has been made to create an index and inject documents into it. Using the command line below, the index will be named _movies_ and the _19 700_ movies of the `datasets/` will be injected in MeiliDB.
+You can [read the deep dive](deep-dive.md) if you want more information on the engine; it describes the whole process of generating updates and handling queries. Also, you can take a look at the [typos and ranking rules](typos-ranking-rules.md) if you want to know the default rules used to sort the documents.
 
-```bash
-cargo run --release --example from_file -- \
-    index example.mdb datasets/movies/data.csv \
-    --schema datasets/movies/schema.toml
-```
+## Contributing
 
-Once the first command is done, you can query the freshly created _movies_ index using the _search_ subcomand. In this example we filtered the dataset to only show _non-adult_ movies using the non-definitive `!adult` syntax filter.
+We will be glad if you submit issues and pull requests. You can help to grow this project and start contributing by checking [issues tagged "good-first-issue"](https://github.com/meilisearch/MeiliSearch/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22). It is a good start!
 
-```bash
-cargo run --release --example from_file -- \
-    search example.mdb
-    --number 4 \
-    --filter '!adult' \
-    id popularity adult original_title
-```
+### Analytic Events
+
+We send events to our Amplitude instance to be aware of the number of people who use MeiliSearch.<br/>
+We only send the platform on which the server runs once by day. No other information is sent.<br/>
+If you do not want us to send events, you can disable these analytics by using the `MEILI_NO_ANALYTICS` env variable.

azure-pipelines.yml

@@ -1,52 +0,0 @@
----
-trigger:
-  branches:
-    include: [ master ]
-
-pr: [ master ]
-
-jobs:
-  - job: test
-    pool:
-      vmImage: 'Ubuntu 16.04'
-    container: tpayet/chiquitita:latest
-    steps:
-      - script: |
-          curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain nightly
-          $HOME/.cargo/bin/rustup component add rustfmt
-        displayName: 'Install rustc and components'
-      - script: |
-          $HOME/.cargo/bin/cargo check
-        displayName: 'Check MeiliDB'
-      - script: |
-          $HOME/.cargo/bin/cargo test
-        displayName: 'Test MeiliDB'
-      - script: |
-          $HOME/.cargo/bin/cargo fmt --all -- --check
-        displayName: 'Fmt MeiliDB'
-
-  - job: build
-    dependsOn:
-      - test
-    condition: succeeded()
-    pool:
-      vmImage: 'Ubuntu 16.04'
-    container: tpayet/chiquitita:latest
-    steps:
-      - script: |
-          curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain nightly
-          $HOME/.cargo/bin/rustup component add rustfmt
-        displayName: 'Install rustc and components'
-      - script: |
-          $HOME/.cargo/bin/cargo build --release
-        displayName: 'Build MeiliDB'
-      - task: CopyFiles@2
-        inputs:
-          contents: '$(System.DefaultWorkingDirectory)/target/release/libmeilidb.rlib'
-          targetFolder: $(Build.ArtifactStagingDirectory)
-        displayName: 'Copy build'
-      - task: PublishBuildArtifacts@1
-        inputs:
-          artifactName: libmeilidb.rlib
-        displayName: 'Upload artifacts'
-

datasets/movies/README.md

@@ -1 +1 @@
-_datas in movies.csv are from https://www.themoviedb.org/_
+_datas in movies.csv are from https://www.themoviedb.org/_

deep-dive.md

@@ -1,8 +1,8 @@
-# A deep dive in MeiliDB
+# A deep dive in MeiliSearch
 
 On the 15 of May 2019.
 
-MeiliDB is a full text search engine based on a final state transducer named [fst](https://github.com/BurntSushi/fst) and a key-value store named [sled](https://github.com/spacejam/sled). The goal of a search engine is to store data and to respond to queries as accurate and fast as possible. To achieve this it must save the matching words in an [inverted index](https://en.wikipedia.org/wiki/Inverted_index).
+MeiliSearch is a full text search engine based on a final state transducer named [fst](https://github.com/BurntSushi/fst) and a key-value store named [sled](https://github.com/spacejam/sled). The goal of a search engine is to store data and to respond to queries as accurate and fast as possible. To achieve this it must save the matching words in an [inverted index](https://en.wikipedia.org/wiki/Inverted_index).
 
 <!-- MarkdownTOC autolink="true" -->
 
@@ -22,7 +22,7 @@ MeiliDB is a full text search engine based on a final state transducer named [fs
 
 ## Where is the data stored?
 
-MeiliDB is entirely backed by a key-value store like any good database (i.e. Postgres, MySQL). This brings a great flexibility in the way documents can be stored and updates handled along time.
+MeiliSearch is entirely backed by a key-value store like any good database (i.e. Postgres, MySQL). This brings a great flexibility in the way documents can be stored and updates handled along time.
 
 [sled will brings some](https://github.com/spacejam/sled/tree/434533332a3f485e6d2e467023be0a0b55d3a1af#plans) of the [A.C.I.D. properties](https://en.wikipedia.org/wiki/ACID_(computer_science)) to help us be sure the saved data is consistent.
 
@@ -34,7 +34,7 @@ It contain the inverted word index, the schema and the documents fields.
 
 ### The inverted word index
 
-[The inverted word index](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/database/words_index.rs) is a sled Tree dedicated to store and give access to all documents that contains a specific word. The information stored under the word is simply a big ordered array of where in the document the word has been found. In other word, a big list of [`DocIndex`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/lib.rs#L35-L51).
+[The inverted word index](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/words_index.rs) is a sled Tree dedicated to store and give access to all documents that contains a specific word. The information stored under the word is simply a big ordered array of where in the document the word has been found. In other word, a big list of [`DocIndex`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/lib.rs#L35-L51).
 
 #### A final state transducer
 
@@ -42,27 +42,27 @@ _...also abbreviated fst_
 
 This is the first entry point of the engine, you can read more about how it work with the beautiful blog post of @BurntSushi, [Index 1,600,000,000 Keys with Automata and Rust](https://blog.burntsushi.net/transducers/).
 
-To make it short it is a powerful way to store all the words that are present in the indexed documents. You construct it by giving it all the words you want to index. When you want to search in it you can provide any automaton you want, in MeiliDB [a custom levenshtein automaton](https://github.com/tantivy-search/levenshtein-automata/) is used.
+To make it short it is a powerful way to store all the words that are present in the indexed documents. You construct it by giving it all the words you want to index. When you want to search in it you can provide any automaton you want, in MeiliSearch [a custom levenshtein automaton](https://github.com/tantivy-search/levenshtein-automata/) is used.
 
 #### Document indexes
 
 The `fst` will only return the words that match with the search automaton but the goal of the search engine is to retrieve all matches in all the documents when a query is made. You want it to return some sort of position in an attribute in a document, an information about where the given word matched.
 
-To make it possible we retrieve all of the `DocIndex` corresponding to all the matching words in the fst, we use the [`WordsIndex`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/database/words_index.rs#L11-L21) Tree to get the `DocIndexes` corresponding the words.
+To make it possible we retrieve all of the `DocIndex` corresponding to all the matching words in the fst, we use the [`WordsIndex`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/words_index.rs#L11-L21) Tree to get the `DocIndexes` corresponding the words.
 
 ### The schema
 
-The schema is a data structure that represents which documents attributes should be stored and which should be indexed. It is stored under a the [`MainIndex`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/database/main_index.rs#L12) Tree and given to MeiliDB only at the creation of an index.
+The schema is a data structure that represents which documents attributes should be stored and which should be indexed. It is stored under a the [`MainIndex`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/main_index.rs#L12) Tree and given to MeiliSearch only at the creation of an index.
 
-Each document attribute is associated to a unique 16 bit number named [`SchemaAttr`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/schema.rs#L186).
+Each document attribute is associated to a unique 16 bit number named [`SchemaAttr`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/schema.rs#L186).
 
 In the future, this schema type could be given along with updates, the database could be able to handled a new schema and reindex the database according to the new one.
 
 ### Document attributes
 
-When the engine handle a query the result that the requester want is a document, not only the [`Matches`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/lib.rs#L62-L88) associated to it, fields of the original document must be returned too.
+When the engine handle a query the result that the requester want is a document, not only the [`Matches`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/lib.rs#L62-L88) associated to it, fields of the original document must be returned too.
 
-So MeiliDB again uses the power of the underlying key-value store and save the documents attributes marked as _STORE_ in the schema. The dedicated Tree for this information is the [`DocumentsIndex`](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/database/documents_index.rs#L11).
+So MeiliSearch again uses the power of the underlying key-value store and save the documents attributes marked as _STORE_ in the schema. The dedicated Tree for this information is the [`DocumentsIndex`](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/documents_index.rs#L11).
 
 When a document field is saved in the key-value store its value is binary encoded using [message pack](https://github.com/3Hren/msgpack-rust), so a document must be serializable using serde.
 
@@ -70,26 +70,26 @@ When a document field is saved in the key-value store its value is binary encode
 
 ## How is a request processed?
 
-Now that we have our inverted index we are able to return results based on a query. In the MeiliDB universe a query is a simple string containing words.
+Now that we have our inverted index we are able to return results based on a query. In the MeiliSearch universe a query is a simple string containing words.
 
 ### Query lexemes
 
-The first step to be able to call the underlying structures is to split the query in words, for that we use a [custom tokenizer](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-tokenizer/src/lib.rs#L82-L84). Note that a tokenizer is specialized for a human language, this is the hard part.
+The first step to be able to call the underlying structures is to split the query in words, for that we use a [custom tokenizer](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-tokenizer/src/lib.rs#L82-L84). Note that a tokenizer is specialized for a human language, this is the hard part.
 
 ### Automatons and query index
 
-So to query the fst we need an automaton, in MeiliDB we use a [levenshtein automaton](https://en.wikipedia.org/wiki/Levenshtein_automaton), this automaton is constructed using a string and a maximum distance. According to the [Algolia's blog post](https://blog.algolia.com/inside-the-algolia-engine-part-3-query-processing/#algolia%e2%80%99s-way-of-searching-for-alternatives) we [created the DFAs](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/automaton.rs#L59-L78) with different settings.
+So to query the fst we need an automaton, in MeiliSearch we use a [levenshtein automaton](https://en.wikipedia.org/wiki/Levenshtein_automaton), this automaton is constructed using a string and a maximum distance. According to the [Algolia's blog post](https://blog.algolia.com/inside-the-algolia-engine-part-3-query-processing/#algolia%e2%80%99s-way-of-searching-for-alternatives) we [created the DFAs](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/automaton.rs#L59-L78) with different settings.
 
 Thanks to the power of the fst library [it is possible to union multiple automatons](https://docs.rs/fst/0.3.2/fst/map/struct.OpBuilder.html#method.union) on the same fst set. The `Stream` is able to return all the matching words. We use these words to find the whole list of `DocIndexes` associated.
 
-With all these informations it is possible [to reconstruct a list of all the `DocIndexes` associated](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/query_builder.rs#L103-L130) with the words queried.
+With all these informations it is possible [to reconstruct a list of all the `DocIndexes` associated](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/query_builder.rs#L103-L130) with the words queried.
 
 ### Sort by criteria
 
-Now that we are able to get a big list of [DocIndexes](https://github.com/Kerollmops/MeiliDB/blob/550dc1e99224e386516877450320f694947332d4/src/lib.rs#L21-L36) it is not enough to sort them by criteria, we need more informations like the levenshtein distance or the fact that a query word match exactly the word stored in the fst. So [we stuff it a little bit](https://github.com/Kerollmops/MeiliDB/blob/550dc1e99224e386516877450320f694947332d4/src/rank/query_builder.rs#L86-L93), and aggregate all these [Matches](https://github.com/Kerollmops/MeiliDB/blob/550dc1e99224e386516877450320f694947332d4/src/lib.rs#L47-L74) for each document. This way it will be easy to sort a simple vector of document using a bunch of functions.
+Now that we are able to get a big list of [DocIndexes](https://github.com/Kerollmops/MeiliSearch/blob/550dc1e99224e386516877450320f694947332d4/src/lib.rs#L21-L36) it is not enough to sort them by criteria, we need more informations like the levenshtein distance or the fact that a query word match exactly the word stored in the fst. So [we stuff it a little bit](https://github.com/Kerollmops/MeiliSearch/blob/550dc1e99224e386516877450320f694947332d4/src/rank/query_builder.rs#L86-L93), and aggregate all these [Matches](https://github.com/Kerollmops/MeiliSearch/blob/550dc1e99224e386516877450320f694947332d4/src/lib.rs#L47-L74) for each document. This way it will be easy to sort a simple vector of document using a bunch of functions.
 
-With this big list of documents and associated matches [we are able to sort only the part of the slice that we want](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/query_builder.rs#L160-L188) using bucket sorting. [Each criterion](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-core/src/criterion/mod.rs#L95-L101) is evaluated on each subslice without copy, thanks to [GroupByMut](https://docs.rs/slice-group-by/0.2.4/slice_group_by/) which, I hope [will soon be merged](https://github.com/rust-lang/rfcs/pull/2477).
+With this big list of documents and associated matches [we are able to sort only the part of the slice that we want](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/query_builder.rs#L160-L188) using bucket sorting. [Each criterion](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/criterion/mod.rs#L95-L101) is evaluated on each subslice without copy, thanks to [GroupByMut](https://docs.rs/slice-group-by/0.2.4/slice_group_by/) which, I hope [will soon be merged](https://github.com/rust-lang/rfcs/pull/2477).
 
-Note that it is possible to customize the criteria used by using the `QueryBuilder::with_criteria` constructor, this way you can implement some custom ranking based on the document attributes using the appropriate structure and the [`document` method](https://github.com/meilisearch/MeiliDB/blob/3db823de002243004612e36a19b4578d800dab97/meilidb-data/src/database/index.rs#L86).
+Note that it is possible to customize the criteria used by using the `QueryBuilder::with_criteria` constructor, this way you can implement some custom ranking based on the document attributes using the appropriate structure and the [`document` method](https://github.com/meilisearch/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/index.rs#L86).
 
-At this point, MeiliDB work is over 🎉
+At this point, MeiliSearch work is over 🎉

meilidb-core/src/lib.rs

@@ -1,169 +0,0 @@
-#[cfg(test)]
-#[macro_use]
-extern crate assert_matches;
-
-mod automaton;
-pub mod criterion;
-mod database;
-mod distinct_map;
-mod error;
-mod levenshtein;
-mod number;
-mod query_builder;
-mod ranked_map;
-mod raw_document;
-pub mod raw_indexer;
-mod reordered_attrs;
-pub mod serde;
-pub mod store;
-mod update;
-
-pub use self::database::{BoxUpdateFn, Database};
-pub use self::error::{Error, MResult};
-pub use self::number::{Number, ParseNumberError};
-pub use self::ranked_map::RankedMap;
-pub use self::raw_document::RawDocument;
-pub use self::store::Index;
-pub use self::update::{EnqueuedUpdateResult, ProcessedUpdateResult, UpdateStatus, UpdateType};
-
-use ::serde::{Deserialize, Serialize};
-use zerocopy::{AsBytes, FromBytes};
-
-/// Represent an internally generated document unique identifier.
-///
-/// It is used to inform the database the document you want to deserialize.
-/// Helpful for custom ranking.
-#[derive(
-    Debug,
-    Copy,
-    Clone,
-    Eq,
-    PartialEq,
-    PartialOrd,
-    Ord,
-    Hash,
-    Serialize,
-    Deserialize,
-    AsBytes,
-    FromBytes,
-)]
-#[repr(C)]
-pub struct DocumentId(pub u64);
-
-/// This structure represent the position of a word
-/// in a document and its attributes.
-///
-/// This is stored in the map, generated at index time,
-/// extracted and interpreted at search time.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, AsBytes, FromBytes)]
-#[repr(C)]
-pub struct DocIndex {
-    /// The document identifier where the word was found.
-    pub document_id: DocumentId,
-
-    /// The attribute in the document where the word was found
-    /// along with the index in it.
-    pub attribute: u16,
-    pub word_index: u16,
-
-    /// The position in bytes where the word was found
-    /// along with the length of it.
-    ///
-    /// It informs on the original word area in the text indexed
-    /// without needing to run the tokenizer again.
-    pub char_index: u16,
-    pub char_length: u16,
-}
-
-/// This structure represent a matching word with informations
-/// on the location of the word in the document.
-///
-/// The order of the field is important because it defines
-/// the way these structures are ordered between themselves.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Highlight {
-    /// The attribute in the document where the word was found
-    /// along with the index in it.
-    pub attribute: u16,
-
-    /// The position in bytes where the word was found.
-    ///
-    /// It informs on the original word area in the text indexed
-    /// without needing to run the tokenizer again.
-    pub char_index: u16,
-
-    /// The length in bytes of the found word.
-    ///
-    /// It informs on the original word area in the text indexed
-    /// without needing to run the tokenizer again.
-    pub char_length: u16,
-}
-
-#[doc(hidden)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct TmpMatch {
-    pub query_index: u32,
-    pub distance: u8,
-    pub attribute: u16,
-    pub word_index: u16,
-    pub is_exact: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Document {
-    pub id: DocumentId,
-    pub highlights: Vec<Highlight>,
-
-    #[cfg(test)]
-    pub matches: Vec<TmpMatch>,
-}
-
-impl Document {
-    #[cfg(not(test))]
-    fn from_raw(raw: RawDocument) -> Document {
-        Document {
-            id: raw.id,
-            highlights: raw.highlights,
-        }
-    }
-
-    #[cfg(test)]
-    fn from_raw(raw: RawDocument) -> Document {
-        let len = raw.query_index().len();
-        let mut matches = Vec::with_capacity(len);
-
-        let query_index = raw.query_index();
-        let distance = raw.distance();
-        let attribute = raw.attribute();
-        let word_index = raw.word_index();
-        let is_exact = raw.is_exact();
-
-        for i in 0..len {
-            let match_ = TmpMatch {
-                query_index: query_index[i],
-                distance: distance[i],
-                attribute: attribute[i],
-                word_index: word_index[i],
-                is_exact: is_exact[i],
-            };
-            matches.push(match_);
-        }
-
-        Document {
-            id: raw.id,
-            matches,
-            highlights: raw.highlights,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::mem;
-
-    #[test]
-    fn docindex_mem_size() {
-        assert_eq!(mem::size_of::<DocIndex>(), 16);
-    }
-}

meilidb-core/src/store/main.rs

@@ -1,125 +0,0 @@
-use crate::RankedMap;
-use heed::types::{ByteSlice, OwnedType, SerdeBincode, Str};
-use heed::Result as ZResult;
-use meilidb_schema::Schema;
-use std::sync::Arc;
-
-const CUSTOMS_KEY: &str = "customs-key";
-const NUMBER_OF_DOCUMENTS_KEY: &str = "number-of-documents";
-const RANKED_MAP_KEY: &str = "ranked-map";
-const SCHEMA_KEY: &str = "schema";
-const SYNONYMS_KEY: &str = "synonyms";
-const STOP_WORDS_KEY: &str = "stop-words";
-const WORDS_KEY: &str = "words";
-
-#[derive(Copy, Clone)]
-pub struct Main {
-    pub(crate) main: heed::PolyDatabase,
-}
-
-impl Main {
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
-        self.main.clear(writer)
-    }
-
-    pub fn put_words_fst(self, writer: &mut heed::RwTxn, fst: &fst::Set) -> ZResult<()> {
-        let bytes = fst.as_fst().as_bytes();
-        self.main.put::<Str, ByteSlice>(writer, WORDS_KEY, bytes)
-    }
-
-    pub fn words_fst(self, reader: &heed::RoTxn) -> ZResult<Option<fst::Set>> {
-        match self.main.get::<Str, ByteSlice>(reader, WORDS_KEY)? {
-            Some(bytes) => {
-                let len = bytes.len();
-                let bytes = Arc::from(bytes);
-                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
-                Ok(Some(fst::Set::from(fst)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    pub fn put_schema(self, writer: &mut heed::RwTxn, schema: &Schema) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeBincode<Schema>>(writer, SCHEMA_KEY, schema)
-    }
-
-    pub fn schema(self, reader: &heed::RoTxn) -> ZResult<Option<Schema>> {
-        self.main
-            .get::<Str, SerdeBincode<Schema>>(reader, SCHEMA_KEY)
-    }
-
-    pub fn put_ranked_map(self, writer: &mut heed::RwTxn, ranked_map: &RankedMap) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeBincode<RankedMap>>(writer, RANKED_MAP_KEY, &ranked_map)
-    }
-
-    pub fn ranked_map(self, reader: &heed::RoTxn) -> ZResult<Option<RankedMap>> {
-        self.main
-            .get::<Str, SerdeBincode<RankedMap>>(reader, RANKED_MAP_KEY)
-    }
-
-    pub fn put_synonyms_fst(self, writer: &mut heed::RwTxn, fst: &fst::Set) -> ZResult<()> {
-        let bytes = fst.as_fst().as_bytes();
-        self.main.put::<Str, ByteSlice>(writer, SYNONYMS_KEY, bytes)
-    }
-
-    pub fn synonyms_fst(self, reader: &heed::RoTxn) -> ZResult<Option<fst::Set>> {
-        match self.main.get::<Str, ByteSlice>(reader, SYNONYMS_KEY)? {
-            Some(bytes) => {
-                let len = bytes.len();
-                let bytes = Arc::from(bytes);
-                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
-                Ok(Some(fst::Set::from(fst)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    pub fn put_stop_words_fst(self, writer: &mut heed::RwTxn, fst: &fst::Set) -> ZResult<()> {
-        let bytes = fst.as_fst().as_bytes();
-        self.main
-            .put::<Str, ByteSlice>(writer, STOP_WORDS_KEY, bytes)
-    }
-
-    pub fn stop_words_fst(self, reader: &heed::RoTxn) -> ZResult<Option<fst::Set>> {
-        match self.main.get::<Str, ByteSlice>(reader, STOP_WORDS_KEY)? {
-            Some(bytes) => {
-                let len = bytes.len();
-                let bytes = Arc::from(bytes);
-                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
-                Ok(Some(fst::Set::from(fst)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    pub fn put_number_of_documents<F>(self, writer: &mut heed::RwTxn, f: F) -> ZResult<u64>
-    where
-        F: Fn(u64) -> u64,
-    {
-        let new = self.number_of_documents(writer).map(f)?;
-        self.main
-            .put::<Str, OwnedType<u64>>(writer, NUMBER_OF_DOCUMENTS_KEY, &new)?;
-        Ok(new)
-    }
-
-    pub fn number_of_documents(self, reader: &heed::RoTxn) -> ZResult<u64> {
-        match self
-            .main
-            .get::<Str, OwnedType<u64>>(reader, NUMBER_OF_DOCUMENTS_KEY)?
-        {
-            Some(value) => Ok(value),
-            None => Ok(0),
-        }
-    }
-
-    pub fn put_customs(self, writer: &mut heed::RwTxn, customs: &[u8]) -> ZResult<()> {
-        self.main
-            .put::<Str, ByteSlice>(writer, CUSTOMS_KEY, customs)
-    }
-
-    pub fn customs<'txn>(self, reader: &'txn heed::RoTxn) -> ZResult<Option<&'txn [u8]>> {
-        self.main.get::<Str, ByteSlice>(reader, CUSTOMS_KEY)
-    }
-}

meilidb-http/src/data.rs

@@ -1,190 +0,0 @@
-use std::collections::HashMap;
-use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-
-use chrono::{DateTime, Utc};
-use heed::types::{SerdeBincode, Str};
-use log::*;
-use meilidb_core::{Database, MResult};
-use sysinfo::Pid;
-
-use crate::option::Opt;
-use crate::routes::index::index_update_callback;
-
-pub type FreqsMap = HashMap<String, usize>;
-type SerdeFreqsMap = SerdeBincode<FreqsMap>;
-type SerdeDatetime = SerdeBincode<DateTime<Utc>>;
-
-#[derive(Clone)]
-pub struct Data {
-    inner: Arc<DataInner>,
-}
-
-impl Deref for Data {
-    type Target = DataInner;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-#[derive(Clone)]
-pub struct DataInner {
-    pub db: Arc<Database>,
-    pub db_path: String,
-    pub admin_token: Option<String>,
-    pub server_pid: Pid,
-    pub accept_updates: Arc<AtomicBool>,
-}
-
-impl DataInner {
-    pub fn is_indexing(&self, reader: &heed::RoTxn, index: &str) -> MResult<Option<bool>> {
-        match self.db.open_index(&index) {
-            Some(index) => index.current_update_id(&reader).map(|u| Some(u.is_some())),
-            None => Ok(None),
-        }
-    }
-
-    pub fn last_update(
-        &self,
-        reader: &heed::RoTxn,
-        index_name: &str,
-    ) -> MResult<Option<DateTime<Utc>>> {
-        let key = format!("last-update-{}", index_name);
-        match self
-            .db
-            .common_store()
-            .get::<Str, SerdeDatetime>(&reader, &key)?
-        {
-            Some(datetime) => Ok(Some(datetime)),
-            None => Ok(None),
-        }
-    }
-
-    pub fn set_last_update(&self, writer: &mut heed::RwTxn, index_name: &str) -> MResult<()> {
-        let key = format!("last-update-{}", index_name);
-        self.db
-            .common_store()
-            .put::<Str, SerdeDatetime>(writer, &key, &Utc::now())
-            .map_err(Into::into)
-    }
-
-    pub fn last_backup(&self, reader: &heed::RoTxn) -> MResult<Option<DateTime<Utc>>> {
-        match self
-            .db
-            .common_store()
-            .get::<Str, SerdeDatetime>(&reader, "last-backup")?
-        {
-            Some(datetime) => Ok(Some(datetime)),
-            None => Ok(None),
-        }
-    }
-
-    pub fn set_last_backup(&self, writer: &mut heed::RwTxn) -> MResult<()> {
-        self.db
-            .common_store()
-            .put::<Str, SerdeDatetime>(writer, "last-backup", &Utc::now())?;
-
-        Ok(())
-    }
-
-    pub fn fields_frequency(
-        &self,
-        reader: &heed::RoTxn,
-        index_name: &str,
-    ) -> MResult<Option<FreqsMap>> {
-        let key = format!("fields-frequency-{}", index_name);
-        match self
-            .db
-            .common_store()
-            .get::<Str, SerdeFreqsMap>(&reader, &key)?
-        {
-            Some(freqs) => Ok(Some(freqs)),
-            None => Ok(None),
-        }
-    }
-
-    pub fn compute_stats(&self, writer: &mut heed::RwTxn, index_name: &str) -> MResult<()> {
-        let index = match self.db.open_index(&index_name) {
-            Some(index) => index,
-            None => {
-                error!("Impossible to retrieve index {}", index_name);
-                return Ok(());
-            }
-        };
-
-        let schema = match index.main.schema(&writer)? {
-            Some(schema) => schema,
-            None => return Ok(()),
-        };
-
-        let all_documents_fields = index
-            .documents_fields_counts
-            .all_documents_fields_counts(&writer)?;
-
-        // count fields frequencies
-        let mut fields_frequency = HashMap::<_, usize>::new();
-        for result in all_documents_fields {
-            let (_, attr, _) = result?;
-            *fields_frequency.entry(attr).or_default() += 1;
-        }
-
-        // convert attributes to their names
-        let frequency: HashMap<_, _> = fields_frequency
-            .into_iter()
-            .map(|(a, c)| (schema.attribute_name(a).to_owned(), c))
-            .collect();
-
-        let key = format!("fields-frequency-{}", index_name);
-        self.db
-            .common_store()
-            .put::<Str, SerdeFreqsMap>(writer, &key, &frequency)?;
-
-        Ok(())
-    }
-
-    pub fn stop_accept_updates(&self) {
-        self.accept_updates.store(false, Ordering::Relaxed);
-    }
-
-    pub fn accept_updates(&self) -> bool {
-        self.accept_updates.load(Ordering::Relaxed)
-    }
-}
-
-impl Data {
-    pub fn new(opt: Opt) -> Data {
-        let db_path = opt.database_path.clone();
-        let admin_token = opt.admin_token.clone();
-        let server_pid = sysinfo::get_current_pid().unwrap();
-
-        let db = Arc::new(Database::open_or_create(opt.database_path.clone()).unwrap());
-        let accept_updates = Arc::new(AtomicBool::new(true));
-
-        let inner_data = DataInner {
-            db: db.clone(),
-            db_path,
-            admin_token,
-            server_pid,
-            accept_updates,
-        };
-
-        let data = Data {
-            inner: Arc::new(inner_data),
-        };
-
-        for index_name in db.indexes_names().unwrap() {
-            let callback_context = data.clone();
-            let callback_name = index_name.clone();
-            db.set_update_callback(
-                index_name,
-                Box::new(move |status| {
-                    index_update_callback(&callback_name, &callback_context, status);
-                }),
-            );
-        }
-
-        data
-    }
-}

meilidb-http/src/helpers/mod.rs

@@ -1,2 +0,0 @@
-pub mod meilidb;
-pub mod tide;

meilidb-http/src/option.rs

@@ -1,56 +0,0 @@
-use envconfig::Envconfig;
-use structopt::StructOpt;
-
-#[derive(Debug, Clone, StructOpt, Envconfig)]
-struct Vars {
-    /// The destination where the database must be created.
-    #[structopt(long)]
-    #[envconfig(from = "MEILI_DATABASE_PATH")]
-    pub database_path: Option<String>,
-
-    /// The addr on which the http server will listen.
-    #[structopt(long)]
-    #[envconfig(from = "MEILI_HTTP_ADDR")]
-    pub http_addr: Option<String>,
-
-    #[structopt(long)]
-    #[envconfig(from = "MEILI_ADMIN_TOKEN")]
-    pub admin_token: Option<String>,
-}
-
-#[derive(Clone, Debug)]
-pub struct Opt {
-    pub database_path: String,
-    pub http_addr: String,
-    pub admin_token: Option<String>,
-}
-
-impl Default for Opt {
-    fn default() -> Self {
-        Opt {
-            database_path: String::from("/tmp/meilidb"),
-            http_addr: String::from("127.0.0.1:8080"),
-            admin_token: None,
-        }
-    }
-}
-
-impl Opt {
-    pub fn new() -> Self {
-        let default = Self::default();
-        let args = Vars::from_args();
-        let env = Vars::init().unwrap();
-
-        Self {
-            database_path: env
-                .database_path
-                .or(args.database_path)
-                .unwrap_or(default.database_path),
-            http_addr: env
-                .http_addr
-                .or(args.http_addr)
-                .unwrap_or(default.http_addr),
-            admin_token: env.admin_token.or(args.admin_token).or(default.admin_token),
-        }
-    }
-}

meilidb-http/src/routes/index.rs

@@ -1,214 +0,0 @@
-use http::StatusCode;
-use meilidb_core::{ProcessedUpdateResult, UpdateStatus};
-use meilidb_schema::Schema;
-use serde_json::json;
-use tide::response::IntoResponse;
-use tide::{Context, Response};
-
-use crate::error::{ResponseError, SResult};
-use crate::helpers::tide::ContextExt;
-use crate::models::schema::SchemaBody;
-use crate::models::token::ACL::*;
-use crate::routes::document::IndexUpdateResponse;
-use crate::Data;
-
-pub async fn list_indexes(ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesRead)?;
-    let list = ctx
-        .state()
-        .db
-        .indexes_names()
-        .map_err(ResponseError::internal)?;
-    Ok(tide::response::json(list))
-}
-
-pub async fn get_index_schema(ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesRead)?;
-
-    let index = ctx.index()?;
-
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
-
-    let schema = index
-        .main
-        .schema(&reader)
-        .map_err(ResponseError::create_index)?;
-
-    match schema {
-        Some(schema) => {
-            let schema = SchemaBody::from(schema);
-            Ok(tide::response::json(schema))
-        }
-        None => Ok(
-            tide::response::json(json!({ "message": "missing index schema" }))
-                .with_status(StatusCode::NOT_FOUND)
-                .into_response(),
-        ),
-    }
-}
-
-pub async fn create_index(mut ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesWrite)?;
-
-    let index_name = ctx.url_param("index")?;
-
-    let body = ctx.body_bytes().await.map_err(ResponseError::bad_request)?;
-    let schema: Option<Schema> = if body.is_empty() {
-        None
-    } else {
-        serde_json::from_slice::<SchemaBody>(&body)
-            .map_err(ResponseError::bad_request)
-            .map(|s| Some(s.into()))?
-    };
-
-    let db = &ctx.state().db;
-
-    let created_index = match db.create_index(&index_name) {
-        Ok(index) => index,
-        Err(meilidb_core::Error::IndexAlreadyExists) => db.open_index(&index_name).ok_or(
-            ResponseError::internal("index not found but must have been found"),
-        )?,
-        Err(e) => return Err(ResponseError::create_index(e)),
-    };
-
-    let callback_context = ctx.state().clone();
-    let callback_name = index_name.clone();
-    db.set_update_callback(
-        &index_name,
-        Box::new(move |status| {
-            index_update_callback(&callback_name, &callback_context, status);
-        }),
-    );
-
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
-
-    match schema {
-        Some(schema) => {
-            let update_id = created_index
-                .schema_update(&mut writer, schema.clone())
-                .map_err(ResponseError::internal)?;
-
-            writer.commit().map_err(ResponseError::internal)?;
-
-            let response_body = IndexUpdateResponse { update_id };
-            Ok(tide::response::json(response_body)
-                .with_status(StatusCode::CREATED)
-                .into_response())
-        }
-        None => Ok(Response::new(tide::Body::empty())
-            .with_status(StatusCode::NO_CONTENT)
-            .into_response()),
-    }
-}
-
-pub async fn update_schema(mut ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesWrite)?;
-
-    let index_name = ctx.url_param("index")?;
-
-    let schema = ctx
-        .body_json::<SchemaBody>()
-        .await
-        .map_err(ResponseError::bad_request)?;
-
-    let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
-
-    let index = db
-        .open_index(&index_name)
-        .ok_or(ResponseError::index_not_found(index_name))?;
-
-    let schema: meilidb_schema::Schema = schema.into();
-    let update_id = index
-        .schema_update(&mut writer, schema.clone())
-        .map_err(ResponseError::internal)?;
-
-    writer.commit().map_err(ResponseError::internal)?;
-
-    let response_body = IndexUpdateResponse { update_id };
-    Ok(tide::response::json(response_body)
-        .with_status(StatusCode::ACCEPTED)
-        .into_response())
-}
-
-pub async fn get_update_status(ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesRead)?;
-
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
-
-    let update_id = ctx
-        .param::<u64>("update_id")
-        .map_err(|e| ResponseError::bad_parameter("update_id", e))?;
-
-    let index = ctx.index()?;
-    let status = index
-        .update_status(&reader, update_id)
-        .map_err(ResponseError::internal)?;
-
-    let response = match status {
-        UpdateStatus::Enqueued(data) => {
-            tide::response::json(json!({ "status": "enqueued", "data": data }))
-                .with_status(StatusCode::OK)
-                .into_response()
-        }
-        UpdateStatus::Processed(data) => {
-            tide::response::json(json!({ "status": "processed", "data": data }))
-                .with_status(StatusCode::OK)
-                .into_response()
-        }
-        UpdateStatus::Unknown => tide::response::json(json!({ "message": "unknown update id" }))
-            .with_status(StatusCode::NOT_FOUND)
-            .into_response(),
-    };
-
-    Ok(response)
-}
-
-pub async fn get_all_updates_status(ctx: Context<Data>) -> SResult<Response> {
-    ctx.is_allowed(IndexesRead)?;
-
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
-
-    let index = ctx.index()?;
-    let all_status = index
-        .all_updates_status(&reader)
-        .map_err(ResponseError::internal)?;
-
-    let response = tide::response::json(all_status)
-        .with_status(StatusCode::OK)
-        .into_response();
-
-    Ok(response)
-}
-
-pub async fn delete_index(ctx: Context<Data>) -> SResult<StatusCode> {
-    ctx.is_allowed(IndexesWrite)?;
-    let index_name = ctx.url_param("index")?;
-
-    let found = ctx
-        .state()
-        .db
-        .delete_index(&index_name)
-        .map_err(ResponseError::internal)?;
-
-    if found {
-        Ok(StatusCode::OK)
-    } else {
-        Ok(StatusCode::NOT_FOUND)
-    }
-}
-
-pub fn index_update_callback(index_name: &str, data: &Data, _status: ProcessedUpdateResult) {
-    let env = &data.db.env;
-    let mut writer = env.write_txn().unwrap();
-
-    data.compute_stats(&mut writer, &index_name).unwrap();
-    data.set_last_update(&mut writer, &index_name).unwrap();
-
-    writer.commit().unwrap();
-}

meilisearch-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "meilidb-core"
-version = "0.6.5"
+name = "meilisearch-core"
+version = "0.8.2"
 authors = ["Kerollmops <clement@meilisearch.com>"]
 edition = "2018"
 
@@ -8,32 +8,27 @@ edition = "2018"
 arc-swap = "0.4.3"
 bincode = "1.1.4"
 byteorder = "1.3.2"
-crossbeam-channel = "0.3.9"
+chrono = { version = "0.4.9", features = ["serde"] }
+crossbeam-channel = "0.4.0"
 deunicode = "1.0.0"
 env_logger = "0.7.0"
+fst = { version = "0.3.5", default-features = false }
 hashbrown = { version = "0.6.0", features = ["serde"] }
-heed = "0.5.0"
+heed = "0.6.0"
+levenshtein_automata = { version = "0.1.1", features = ["fst_automaton"] }
 log = "0.4.8"
-meilidb-schema = { path = "../meilidb-schema", version = "0.6.0" }
-meilidb-tokenizer = { path = "../meilidb-tokenizer", version = "0.6.0" }
+meilisearch-schema = { path = "../meilisearch-schema", version = "0.8.2" }
+meilisearch-tokenizer = { path = "../meilisearch-tokenizer", version = "0.8.2" }
+meilisearch-types = { path = "../meilisearch-types", version = "0.8.2" }
 once_cell = "1.2.0"
 ordered-float = { version = "1.0.2", features = ["serde"] }
 sdset = "0.3.3"
 serde = { version = "1.0.101", features = ["derive"] }
 serde_json = "1.0.41"
-siphasher = "0.3.0"
+siphasher = "0.3.1"
 slice-group-by = "0.2.6"
 zerocopy = "0.2.8"
 
-[dependencies.levenshtein_automata]
-git = "https://github.com/Kerollmops/levenshtein-automata.git"
-branch = "arc-byte-slice"
-features = ["fst_automaton"]
-
-[dependencies.fst]
-git = "https://github.com/Kerollmops/fst.git"
-branch = "arc-byte-slice"
-
 [dev-dependencies]
 assert_matches = "1.3"
 csv = "1.0.7"

meilisearch-core/examples/from_file.rs

@@ -12,8 +12,8 @@ use serde::{Deserialize, Serialize};
 use structopt::StructOpt;
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
-use meilidb_core::{Database, Highlight, ProcessedUpdateResult};
-use meilidb_schema::SchemaAttr;
+use meilisearch_core::{Database, Highlight, ProcessedUpdateResult};
+use meilisearch_schema::SchemaAttr;
 
 #[derive(Debug, StructOpt)]
 struct IndexCommand {
@@ -22,7 +22,7 @@ struct IndexCommand {
     database_path: PathBuf,
 
     #[structopt(long, default_value = "default")]
-    index_name: String,
+    index_uid: String,
 
     /// The csv file to index.
     #[structopt(parse(from_os_str))]
@@ -46,7 +46,7 @@ struct SearchCommand {
     database_path: PathBuf,
 
     #[structopt(long, default_value = "default")]
-    index_name: String,
+    index_uid: String,
 
     /// Timeout after which the search will return results.
     #[structopt(long)]
@@ -76,7 +76,7 @@ struct ShowUpdatesCommand {
     database_path: PathBuf,
 
     #[structopt(long, default_value = "default")]
-    index_name: String,
+    index_uid: String,
 }
 
 #[derive(Debug, StructOpt)]
@@ -104,33 +104,34 @@ fn index_command(command: IndexCommand, database: Database) -> Result<(), Box<dy
     let start = Instant::now();
 
     let (sender, receiver) = mpsc::sync_channel(100);
-    let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
-    let index = match database.open_index(&command.index_name) {
+    let update_fn =
+        move |_name: &str, update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+    let index = match database.open_index(&command.index_uid) {
         Some(index) => index,
-        None => database.create_index(&command.index_name).unwrap(),
+        None => database.create_index(&command.index_uid).unwrap(),
     };
 
-    let done = database.set_update_callback(&command.index_name, Box::new(update_fn));
-    assert!(done, "could not set the index update function");
+    database.set_update_callback(Box::new(update_fn));
 
-    let env = &database.env;
+    let db = &database;
 
     let schema = {
         let string = fs::read_to_string(&command.schema)?;
         toml::from_str(&string).unwrap()
     };
 
-    let mut writer = env.write_txn().unwrap();
-    match index.main.schema(&writer)? {
+    let reader = db.main_read_txn().unwrap();
+    let mut update_writer = db.update_write_txn().unwrap();
+    match index.main.schema(&reader)? {
         Some(current_schema) => {
             if current_schema != schema {
-                return Err(meilidb_core::Error::SchemaDiffer.into());
+                return Err(meilisearch_core::Error::SchemaDiffer.into());
             }
-            writer.abort();
+            update_writer.abort();
         }
         None => {
-            index.schema_update(&mut writer, schema)?;
-            writer.commit().unwrap();
+            index.schema_update(&mut update_writer, schema)?;
+            update_writer.commit().unwrap();
         }
     }
 
@@ -173,10 +174,10 @@ fn index_command(command: IndexCommand, database: Database) -> Result<(), Box<dy
 
         println!();
 
-        let mut writer = env.write_txn().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
         println!("committing update...");
-        let update_id = additions.finalize(&mut writer)?;
-        writer.commit().unwrap();
+        let update_id = additions.finalize(&mut update_writer)?;
+        update_writer.commit().unwrap();
         max_update_id = max_update_id.max(update_id);
         println!("committed update {}", update_id);
     }
@@ -195,8 +196,9 @@ fn index_command(command: IndexCommand, database: Database) -> Result<(), Box<dy
     );
 
     if let Some(path) = command.compact_to_path {
+        fs::create_dir_all(&path)?;
         let start = Instant::now();
-        let _file = database.copy_and_compact_to_path(&path)?;
+        let _file = database.copy_and_compact_to_path(path.join("data.mdb"))?;
         println!(
             "database compacted in {:.2?} at: {:?}",
             start.elapsed(),
@@ -315,16 +317,16 @@ fn crop_text(
 }
 
 fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<dyn Error>> {
-    let env = &database.env;
+    let db = &database;
     let index = database
-        .open_index(&command.index_name)
+        .open_index(&command.index_uid)
         .expect("Could not find index");
 
-    let reader = env.read_txn().unwrap();
+    let reader = db.main_read_txn().unwrap();
     let schema = index.main.schema(&reader)?;
     reader.abort();
 
-    let schema = schema.ok_or(meilidb_core::Error::SchemaMissing)?;
+    let schema = schema.ok_or(meilisearch_core::Error::SchemaMissing)?;
 
     let fields = command.displayed_fields.iter().map(String::as_str);
     let fields = HashSet::from_iter(fields);
@@ -338,7 +340,7 @@ fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<
             Ok(query) => {
                 let start_total = Instant::now();
 
-                let reader = env.read_txn().unwrap();
+                let reader = db.main_read_txn().unwrap();
                 let ref_index = &index;
                 let ref_reader = &reader;
 
@@ -443,12 +445,12 @@ fn show_updates_command(
     command: ShowUpdatesCommand,
     database: Database,
 ) -> Result<(), Box<dyn Error>> {
-    let env = &database.env;
+    let db = &database;
     let index = database
-        .open_index(&command.index_name)
+        .open_index(&command.index_uid)
         .expect("Could not find index");
 
-    let reader = env.read_txn().unwrap();
+    let reader = db.update_read_txn().unwrap();
     let updates = index.all_updates_status(&reader)?;
     println!("{:#?}", updates);
     reader.abort();

meilisearch-core/src/automaton/mod.rs

@@ -6,8 +6,9 @@ use std::{cmp, vec};
 
 use fst::{IntoStreamer, Streamer};
 use levenshtein_automata::DFA;
-use meilidb_tokenizer::{is_cjk, split_query_string};
+use meilisearch_tokenizer::{is_cjk, split_query_string};
 
+use crate::database::MainT;
 use crate::error::MResult;
 use crate::store;
 
@@ -23,7 +24,7 @@ pub struct AutomatonProducer {
 
 impl AutomatonProducer {
     pub fn new(
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         query: &str,
         main_store: store::Main,
         postings_list_store: store::PostingsLists,
@@ -131,7 +132,7 @@ pub fn normalize_str(string: &str) -> String {
 }
 
 fn split_best_frequency<'a>(
-    reader: &heed::RoTxn,
+    reader: &heed::RoTxn<MainT>,
     word: &'a str,
     postings_lists_store: store::PostingsLists,
 ) -> MResult<Option<(&'a str, &'a str)>> {
@@ -159,7 +160,7 @@ fn split_best_frequency<'a>(
 }
 
 fn generate_automatons(
-    reader: &heed::RoTxn,
+    reader: &heed::RoTxn<MainT>,
     query: &str,
     main_store: store::Main,
     postings_lists_store: store::PostingsLists,

meilisearch-core/src/criterion/exact.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 use sdset::Set;
 use slice_group_by::GroupBy;
 

meilisearch-core/src/criterion/sort_by_attr.rs

@@ -4,7 +4,7 @@ use std::fmt;
 
 use crate::criterion::Criterion;
 use crate::{RankedMap, RawDocument};
-use meilidb_schema::{Schema, SchemaAttr};
+use meilisearch_schema::{Schema, SchemaAttr};
 
 /// An helper struct that permit to sort documents by
 /// some of their stored attributes.
@@ -23,7 +23,7 @@ use meilidb_schema::{Schema, SchemaAttr};
 ///
 /// ```ignore
 /// use serde_derive::Deserialize;
-/// use meilidb::rank::criterion::*;
+/// use meilisearch::rank::criterion::*;
 ///
 /// let custom_ranking = SortByAttr::lower_is_better(&ranked_map, &schema, "published_at")?;
 ///

meilisearch-core/src/database.rs

@@ -11,14 +11,19 @@ use log::debug;
 
 use crate::{store, update, Index, MResult};
 
-pub type BoxUpdateFn = Box<dyn Fn(update::ProcessedUpdateResult) + Send + Sync + 'static>;
+pub type BoxUpdateFn = Box<dyn Fn(&str, update::ProcessedUpdateResult) + Send + Sync + 'static>;
 type ArcSwapFn = arc_swap::ArcSwapOption<BoxUpdateFn>;
 
+pub struct MainT;
+pub struct UpdateT;
+
 pub struct Database {
-    pub env: heed::Env,
+    env: heed::Env,
+    update_env: heed::Env,
     common_store: heed::PolyDatabase,
     indexes_store: heed::Database<Str, Unit>,
-    indexes: RwLock<HashMap<String, (Index, Arc<ArcSwapFn>, thread::JoinHandle<()>)>>,
+    indexes: RwLock<HashMap<String, (Index, thread::JoinHandle<MResult<()>>)>>,
+    update_fn: Arc<ArcSwapFn>,
 }
 
 macro_rules! r#break_try {
@@ -35,114 +40,168 @@ macro_rules! r#break_try {
 
 pub enum UpdateEvent {
     NewUpdate,
-    MustStop,
+    MustClear,
 }
 
 pub type UpdateEvents = Receiver<UpdateEvent>;
 pub type UpdateEventsEmitter = Sender<UpdateEvent>;
 
-fn update_awaiter(receiver: UpdateEvents, env: heed::Env, update_fn: Arc<ArcSwapFn>, index: Index) {
+fn update_awaiter(
+    receiver: UpdateEvents,
+    env: heed::Env,
+    update_env: heed::Env,
+    index_uid: &str,
+    update_fn: Arc<ArcSwapFn>,
+    index: Index,
+) -> MResult<()> {
     let mut receiver = receiver.into_iter();
-    while let Some(UpdateEvent::NewUpdate) = receiver.next() {
+    while let Some(event) = receiver.next() {
+
+        // if we receive a *MustClear* event, clear the index and break the loop
+        if let UpdateEvent::MustClear = event {
+            let mut writer = env.typed_write_txn::<MainT>()?;
+            let mut update_writer = update_env.typed_write_txn::<UpdateT>()?;
+
+            store::clear(&mut writer, &mut update_writer, &index)?;
+
+            writer.commit()?;
+            update_writer.commit()?;
+
+            debug!("store {} cleared", index_uid);
+
+            break
+        }
+
         loop {
-            // instantiate a main/parent transaction
-            let mut writer = break_try!(env.write_txn(), "LMDB write transaction begin failed");
+            // We instantiate a *write* transaction to *block* the thread
+            // until the *other*, notifiying, thread commits
+            let result = update_env.typed_write_txn::<UpdateT>();
+            let update_reader = break_try!(result, "LMDB read transaction (update) begin failed");
 
             // retrieve the update that needs to be processed
-            let result = index.updates.pop_front(&mut writer);
+            let result = index.updates.first_update(&update_reader);
             let (update_id, update) = match break_try!(result, "pop front update failed") {
                 Some(value) => value,
                 None => {
                     debug!("no more updates");
-                    writer.abort();
                     break;
                 }
             };
 
-            // instantiate a nested transaction
-            let result = env.nested_write_txn(&mut writer);
-            let mut nested_writer = break_try!(result, "LMDB nested write transaction failed");
+            // do not keep the reader for too long
+            update_reader.abort();
 
-            // try to apply the update to the database using the nested transaction
-            let result = update::update_task(&mut nested_writer, index.clone(), update_id, update);
+            // instantiate a transaction to touch to the main env
+            let result = env.typed_write_txn::<MainT>();
+            let mut main_writer = break_try!(result, "LMDB nested write transaction failed");
+
+            // try to apply the update to the database using the main transaction
+            let result = update::update_task(&mut main_writer, &index, update_id, update);
             let status = break_try!(result, "update task failed");
 
-            // commit the nested transaction if the update was successful, abort it otherwise
-            if status.result.is_ok() {
-                break_try!(nested_writer.commit(), "commit nested transaction failed");
+            // commit the main transaction if the update was successful, abort it otherwise
+            if status.error.is_none() {
+                break_try!(main_writer.commit(), "commit nested transaction failed");
             } else {
-                nested_writer.abort()
+                main_writer.abort()
             }
 
-            // write the result of the update in the updates-results store
-            let updates_results = index.updates_results;
-            let result = updates_results.put_update_result(&mut writer, update_id, &status);
+            // now that the update has been processed we can instantiate
+            // a transaction to move the result to the updates-results store
+            let result = update_env.typed_write_txn::<UpdateT>();
+            let mut update_writer = break_try!(result, "LMDB write transaction begin failed");
 
-            // always commit the main/parent transaction, even if the update was unsuccessful
+            // definitely remove the update from the updates store
+            index.updates.del_update(&mut update_writer, update_id)?;
+
+            // write the result of the updates-results store
+            let updates_results = index.updates_results;
+            let result = updates_results.put_update_result(&mut update_writer, update_id, &status);
+
+            // always commit the main transaction, even if the update was unsuccessful
             break_try!(result, "update result store commit failed");
-            break_try!(writer.commit(), "update parent transaction failed");
+            break_try!(update_writer.commit(), "update transaction commit failed");
 
             // call the user callback when the update and the result are written consistently
             if let Some(ref callback) = *update_fn.load() {
-                (callback)(status);
+                (callback)(index_uid, status);
             }
         }
     }
 
     debug!("update loop system stopped");
+
+    Ok(())
 }
 
 impl Database {
     pub fn open_or_create(path: impl AsRef<Path>) -> MResult<Database> {
-        fs::create_dir_all(path.as_ref())?;
+        let main_path = path.as_ref().join("main");
+        let update_path = path.as_ref().join("update");
 
+        fs::create_dir_all(&main_path)?;
         let env = heed::EnvOpenOptions::new()
             .map_size(10 * 1024 * 1024 * 1024) // 10GB
             .max_dbs(3000)
-            .open(path)?;
+            .open(main_path)?;
+
+        fs::create_dir_all(&update_path)?;
+        let update_env = heed::EnvOpenOptions::new()
+            .map_size(10 * 1024 * 1024 * 1024) // 10GB
+            .max_dbs(3000)
+            .open(update_path)?;
 
         let common_store = env.create_poly_database(Some("common"))?;
         let indexes_store = env.create_database::<Str, Unit>(Some("indexes"))?;
+        let update_fn = Arc::new(ArcSwapFn::empty());
 
         // list all indexes that needs to be opened
         let mut must_open = Vec::new();
         let reader = env.read_txn()?;
         for result in indexes_store.iter(&reader)? {
-            let (index_name, _) = result?;
-            must_open.push(index_name.to_owned());
+            let (index_uid, _) = result?;
+            must_open.push(index_uid.to_owned());
         }
 
         reader.abort();
 
         // open the previously aggregated indexes
         let mut indexes = HashMap::new();
-        for index_name in must_open {
+        for index_uid in must_open {
             let (sender, receiver) = crossbeam_channel::bounded(100);
-            let index = match store::open(&env, &index_name, sender.clone())? {
+            let index = match store::open(&env, &update_env, &index_uid, sender.clone())? {
                 Some(index) => index,
                 None => {
                     log::warn!(
                         "the index {} doesn't exist or has not all the databases",
-                        index_name
+                        index_uid
                     );
                     continue;
                 }
             };
-            let update_fn = Arc::new(ArcSwapFn::empty());
 
             let env_clone = env.clone();
+            let update_env_clone = update_env.clone();
             let index_clone = index.clone();
+            let name_clone = index_uid.clone();
             let update_fn_clone = update_fn.clone();
 
             let handle = thread::spawn(move || {
-                update_awaiter(receiver, env_clone, update_fn_clone, index_clone)
+                update_awaiter(
+                    receiver,
+                    env_clone,
+                    update_env_clone,
+                    &name_clone,
+                    update_fn_clone,
+                    index_clone,
+                )
             });
 
             // send an update notification to make sure that
             // possible pre-boot updates are consumed
             sender.send(UpdateEvent::NewUpdate).unwrap();
 
-            let result = indexes.insert(index_name, (index, update_fn, handle));
+            let result = indexes.insert(index_uid, (index, handle));
             assert!(
                 result.is_none(),
                 "The index should not have been already open"
@@ -151,9 +210,11 @@ impl Database {
 
         Ok(Database {
             env,
+            update_env,
             common_store,
             indexes_store,
             indexes: RwLock::new(indexes),
+            update_fn,
         })
     }
 
@@ -173,23 +234,30 @@ impl Database {
             Entry::Occupied(_) => Err(crate::Error::IndexAlreadyExists),
             Entry::Vacant(entry) => {
                 let (sender, receiver) = crossbeam_channel::bounded(100);
-                let index = store::create(&self.env, name, sender)?;
+                let index = store::create(&self.env, &self.update_env, name, sender)?;
 
                 let mut writer = self.env.write_txn()?;
                 self.indexes_store.put(&mut writer, name, &())?;
 
                 let env_clone = self.env.clone();
+                let update_env_clone = self.update_env.clone();
                 let index_clone = index.clone();
-
-                let no_update_fn = Arc::new(ArcSwapFn::empty());
-                let no_update_fn_clone = no_update_fn.clone();
+                let name_clone = name.to_owned();
+                let update_fn_clone = self.update_fn.clone();
 
                 let handle = thread::spawn(move || {
-                    update_awaiter(receiver, env_clone, no_update_fn_clone, index_clone)
+                    update_awaiter(
+                        receiver,
+                        env_clone,
+                        update_env_clone,
+                        &name_clone,
+                        update_fn_clone,
+                        index_clone,
+                    )
                 });
 
                 writer.commit()?;
-                entry.insert((index.clone(), no_update_fn, handle));
+                entry.insert((index.clone(), handle));
 
                 Ok(index)
             }
@@ -201,16 +269,20 @@ impl Database {
         let mut indexes_lock = self.indexes.write().unwrap();
 
         match indexes_lock.remove_entry(name) {
-            Some((name, (index, _fn, handle))) => {
+            Some((name, (index, handle))) => {
                 // remove the index name from the list of indexes
                 // and clear all the LMDB dbi
                 let mut writer = self.env.write_txn()?;
                 self.indexes_store.delete(&mut writer, &name)?;
-                store::clear(&mut writer, &index)?;
                 writer.commit()?;
 
+                // send a stop event to the update loop of the index
+                index.updates_notifier.send(UpdateEvent::MustClear).unwrap();
+
+                drop(indexes_lock);
+
                 // join the update loop thread to ensure it is stopped
-                handle.join().unwrap();
+                handle.join().unwrap()?;
 
                 Ok(true)
             }
@@ -218,36 +290,38 @@ impl Database {
         }
     }
 
-    pub fn set_update_callback(&self, name: impl AsRef<str>, update_fn: BoxUpdateFn) -> bool {
-        let indexes_lock = self.indexes.read().unwrap();
-        match indexes_lock.get(name.as_ref()) {
-            Some((_, current_update_fn, _)) => {
-                let update_fn = Some(Arc::new(update_fn));
-                current_update_fn.swap(update_fn);
-                true
-            }
-            None => false,
-        }
+    pub fn set_update_callback(&self, update_fn: BoxUpdateFn) {
+        let update_fn = Some(Arc::new(update_fn));
+        self.update_fn.swap(update_fn);
     }
 
-    pub fn unset_update_callback(&self, name: impl AsRef<str>) -> bool {
-        let indexes_lock = self.indexes.read().unwrap();
-        match indexes_lock.get(name.as_ref()) {
-            Some((_, current_update_fn, _)) => {
-                current_update_fn.swap(None);
-                true
-            }
-            None => false,
-        }
+    pub fn unset_update_callback(&self) {
+        self.update_fn.swap(None);
+    }
+
+    pub fn main_read_txn(&self) -> heed::Result<heed::RoTxn<MainT>> {
+        self.env.typed_read_txn::<MainT>()
+    }
+
+    pub fn main_write_txn(&self) -> heed::Result<heed::RwTxn<MainT>> {
+        self.env.typed_write_txn::<MainT>()
+    }
+
+    pub fn update_read_txn(&self) -> heed::Result<heed::RoTxn<UpdateT>> {
+        self.update_env.typed_read_txn::<UpdateT>()
+    }
+
+    pub fn update_write_txn(&self) -> heed::Result<heed::RwTxn<UpdateT>> {
+        self.update_env.typed_write_txn::<UpdateT>()
     }
 
     pub fn copy_and_compact_to_path<P: AsRef<Path>>(&self, path: P) -> ZResult<File> {
         self.env.copy_to_path(path, CompactionOption::Enabled)
     }
 
-    pub fn indexes_names(&self) -> MResult<Vec<String>> {
+    pub fn indexes_uids(&self) -> Vec<String> {
         let indexes = self.indexes.read().unwrap();
-        Ok(indexes.keys().cloned().collect())
+        indexes.keys().cloned().collect()
     }
 
     pub fn common_store(&self) -> heed::PolyDatabase {
@@ -259,8 +333,9 @@ impl Database {
 mod tests {
     use super::*;
 
+    use crate::criterion::{self, CriteriaBuilder};
     use crate::update::{ProcessedUpdateResult, UpdateStatus};
-    use crate::DocumentId;
+    use crate::{Document, DocumentId};
     use serde::de::IgnoredAny;
     use std::sync::mpsc;
 
@@ -269,14 +344,15 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
 
         let database = Database::open_or_create(dir.path()).unwrap();
-        let env = &database.env;
+        let db = &database;
 
         let (sender, receiver) = mpsc::sync_channel(100);
-        let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
         let index = database.create_index("test").unwrap();
 
-        let done = database.set_update_callback("test", Box::new(update_fn));
-        assert!(done, "could not set the index update function");
+        database.set_update_callback(Box::new(update_fn));
 
         let schema = {
             let data = r#"
@@ -293,9 +369,9 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
-        let _update_id = index.schema_update(&mut writer, schema).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut update_writer, schema).unwrap();
+        update_writer.commit().unwrap();
 
         let mut additions = index.documents_addition();
 
@@ -314,16 +390,16 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
-        let update_id = additions.finalize(&mut writer).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let update_id = additions.finalize(&mut update_writer).unwrap();
+        update_writer.commit().unwrap();
 
         // block until the transaction is processed
         let _ = receiver.into_iter().find(|id| *id == update_id);
 
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
     }
 
     #[test]
@@ -331,14 +407,15 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
 
         let database = Database::open_or_create(dir.path()).unwrap();
-        let env = &database.env;
+        let db = &database;
 
         let (sender, receiver) = mpsc::sync_channel(100);
-        let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
         let index = database.create_index("test").unwrap();
 
-        let done = database.set_update_callback("test", Box::new(update_fn));
-        assert!(done, "could not set the index update function");
+        database.set_update_callback(Box::new(update_fn));
 
         let schema = {
             let data = r#"
@@ -355,9 +432,9 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
-        let _update_id = index.schema_update(&mut writer, schema).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut update_writer, schema).unwrap();
+        update_writer.commit().unwrap();
 
         let mut additions = index.documents_addition();
 
@@ -375,16 +452,67 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
-        let update_id = additions.finalize(&mut writer).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let update_id = additions.finalize(&mut update_writer).unwrap();
+        update_writer.commit().unwrap();
 
         // block until the transaction is processed
         let _ = receiver.into_iter().find(|id| *id == update_id);
 
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_err());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_some());
+    }
+
+    #[test]
+    fn ignored_words_too_long() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let database = Database::open_or_create(dir.path()).unwrap();
+        let db = &database;
+
+        let (sender, receiver) = mpsc::sync_channel(100);
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
+        let index = database.create_index("test").unwrap();
+
+        database.set_update_callback(Box::new(update_fn));
+
+        let schema = {
+            let data = r#"
+                identifier = "id"
+
+                [attributes."name"]
+                displayed = true
+                indexed = true
+            "#;
+            toml::from_str(data).unwrap()
+        };
+
+        let mut update_writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut update_writer, schema).unwrap();
+        update_writer.commit().unwrap();
+
+        let mut additions = index.documents_addition();
+
+        let doc1 = serde_json::json!({
+            "id": 123,
+            "name": "s̷̡̢̡̧̺̜̞͕͉͉͕̜͔̟̼̥̝͍̟̖͔͔̪͉̲̹̝̣̖͎̞̤̥͓͎̭̩͕̙̩̿̀̋̅̈́̌́̏̍̄̽͂̆̾̀̿̕̚̚͜͠͠ͅͅļ̵̨̨̨̰̦̻̳̖̳͚̬̫͚̦͖͈̲̫̣̩̥̻̙̦̱̼̠̖̻̼̘̖͉̪̜̠̙͖̙̩͔̖̯̩̲̿̽͋̔̿̍̓͂̍̿͊͆̃͗̔̎͐͌̾̆͗́̆̒̔̾̅̚̚͜͜ͅͅī̵̛̦̅̔̓͂͌̾́͂͛̎̋͐͆̽̂̋̋́̾̀̉̓̏̽́̑̀͒̇͋͛̈́̃̉̏͊̌̄̽̿̏̇͘̕̚̕p̶̧̛̛̖̯̗͕̝̗̭̱͙̖̗̟̟̐͆̊̂͐̋̓̂̈́̓͊̆͌̾̾͐͋͗͌̆̿̅͆̈́̈́̉͋̍͊͗̌̓̅̈̎̇̃̎̈́̉̐̋͑̃͘̕͘d̴̢̨̛͕̘̯͖̭̮̝̝̐̊̈̅̐̀͒̀́̈́̀͌̽͛͆͑̀̽̿͛̃̋̇̎̀́̂́͘͠͝ǫ̵̨̛̮̩̘͚̬̯̖̱͍̼͑͑̓̐́̑̿̈́̔͌̂̄͐͝ģ̶̧̜͇̣̭̺̪̺̖̻͖̮̭̣̙̻͒͊͗̓̓͒̀̀ͅ",
+        });
+
+        additions.update_document(doc1);
+
+        let mut update_writer = db.update_write_txn().unwrap();
+        let update_id = additions.finalize(&mut update_writer).unwrap();
+        update_writer.commit().unwrap();
+
+        // block until the transaction is processed
+        let _ = receiver.into_iter().find(|id| *id == update_id);
+
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
     }
 
     #[test]
@@ -392,14 +520,15 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
 
         let database = Database::open_or_create(dir.path()).unwrap();
-        let env = &database.env;
+        let db = &database;
 
         let (sender, receiver) = mpsc::sync_channel(100);
-        let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
         let index = database.create_index("test").unwrap();
 
-        let done = database.set_update_callback("test", Box::new(update_fn));
-        assert!(done, "could not set the index update function");
+        database.set_update_callback(Box::new(update_fn));
 
         let schema = {
             let data = r#"
@@ -416,9 +545,9 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
-        let _update_id = index.schema_update(&mut writer, schema).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut update_writer, schema).unwrap();
+        update_writer.commit().unwrap();
 
         let mut additions = index.documents_addition();
 
@@ -437,9 +566,9 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
-        let _update_id = additions.finalize(&mut writer).unwrap();
-        writer.commit().unwrap();
+        let mut update_writer = db.update_write_txn().unwrap();
+        let _update_id = additions.finalize(&mut update_writer).unwrap();
+        update_writer.commit().unwrap();
 
         let schema = {
             let data = r#"
@@ -464,7 +593,7 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = index.schema_update(&mut writer, schema).unwrap();
         writer.commit().unwrap();
 
@@ -472,10 +601,10 @@ mod tests {
         let _ = receiver.iter().find(|id| *id == update_id);
 
         // check if it has been accepted
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
-        reader.abort();
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
+        update_reader.abort();
 
         let mut additions = index.documents_addition();
 
@@ -498,7 +627,7 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = additions.finalize(&mut writer).unwrap();
         writer.commit().unwrap();
 
@@ -506,11 +635,13 @@ mod tests {
         let _ = receiver.iter().find(|id| *id == update_id);
 
         // check if it has been accepted
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
+        update_reader.abort();
 
         // even try to search for a document
+        let reader = db.main_read_txn().unwrap();
         let results = index.query_builder().query(&reader, "21 ", 0..20).unwrap();
         assert_matches!(results.len(), 1);
 
@@ -544,7 +675,7 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = index.schema_update(&mut writer, schema).unwrap();
         writer.commit().unwrap();
 
@@ -552,9 +683,9 @@ mod tests {
         let _ = receiver.iter().find(|id| *id == update_id);
 
         // check if it has been accepted
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_err());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_some());
     }
 
     #[test]
@@ -562,14 +693,15 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
 
         let database = Database::open_or_create(dir.path()).unwrap();
-        let env = &database.env;
+        let db = &database;
 
         let (sender, receiver) = mpsc::sync_channel(100);
-        let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
         let index = database.create_index("test").unwrap();
 
-        let done = database.set_update_callback("test", Box::new(update_fn));
-        assert!(done, "could not set the index update function");
+        database.set_update_callback(Box::new(update_fn));
 
         let schema = {
             let data = r#"
@@ -586,7 +718,7 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let _update_id = index.schema_update(&mut writer, schema).unwrap();
         writer.commit().unwrap();
 
@@ -609,17 +741,19 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = additions.finalize(&mut writer).unwrap();
         writer.commit().unwrap();
 
         // block until the transaction is processed
         let _ = receiver.into_iter().find(|id| *id == update_id);
 
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
+        update_reader.abort();
 
+        let reader = db.main_read_txn().unwrap();
         let document: Option<IgnoredAny> = index.document(&reader, None, DocumentId(25)).unwrap();
         assert!(document.is_none());
 
@@ -639,14 +773,15 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
 
         let database = Database::open_or_create(dir.path()).unwrap();
-        let env = &database.env;
+        let db = &database;
 
         let (sender, receiver) = mpsc::sync_channel(100);
-        let update_fn = move |update: ProcessedUpdateResult| sender.send(update.update_id).unwrap();
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
         let index = database.create_index("test").unwrap();
 
-        let done = database.set_update_callback("test", Box::new(update_fn));
-        assert!(done, "could not set the index update function");
+        database.set_update_callback(Box::new(update_fn));
 
         let schema = {
             let data = r#"
@@ -666,7 +801,7 @@ mod tests {
             toml::from_str(data).unwrap()
         };
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let _update_id = index.schema_update(&mut writer, schema).unwrap();
         writer.commit().unwrap();
 
@@ -689,17 +824,19 @@ mod tests {
         additions.update_document(doc1);
         additions.update_document(doc2);
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = additions.finalize(&mut writer).unwrap();
         writer.commit().unwrap();
 
         // block until the transaction is processed
         let _ = receiver.iter().find(|id| *id == update_id);
 
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
+        update_reader.abort();
 
+        let reader = db.main_read_txn().unwrap();
         let document: Option<IgnoredAny> = index.document(&reader, None, DocumentId(25)).unwrap();
         assert!(document.is_none());
 
@@ -732,17 +869,19 @@ mod tests {
         partial_additions.update_document(partial_doc1);
         partial_additions.update_document(partial_doc2);
 
-        let mut writer = env.write_txn().unwrap();
+        let mut writer = db.update_write_txn().unwrap();
         let update_id = partial_additions.finalize(&mut writer).unwrap();
         writer.commit().unwrap();
 
         // block until the transaction is processed
         let _ = receiver.iter().find(|id| *id == update_id);
 
-        let reader = env.read_txn().unwrap();
-        let result = index.update_status(&reader, update_id).unwrap();
-        assert_matches!(result, UpdateStatus::Processed(status) if status.result.is_ok());
+        let update_reader = db.update_read_txn().unwrap();
+        let result = index.update_status(&update_reader, update_id).unwrap();
+        assert_matches!(result, Some(UpdateStatus::Processed { content }) if content.error.is_none());
+        update_reader.abort();
 
+        let reader = db.main_read_txn().unwrap();
         let document: Option<serde_json::Value> = index
             .document(&reader, None, DocumentId(7900334843754999545))
             .unwrap();
@@ -770,13 +909,166 @@ mod tests {
     fn delete_index() {
         let dir = tempfile::tempdir().unwrap();
 
-        let database = Database::open_or_create(dir.path()).unwrap();
-        let _index = database.create_index("test").unwrap();
+        let database = Arc::new(Database::open_or_create(dir.path()).unwrap());
+        let db = &database;
 
+        let (sender, receiver) = mpsc::sync_channel(100);
+        let db_cloned = database.clone();
+        let update_fn = move |name: &str, update: ProcessedUpdateResult| {
+            // try to open index to trigger a lock
+            let _ = db_cloned.open_index(name);
+            sender.send(update.update_id).unwrap()
+        };
+
+        // create the index
+        let index = database.create_index("test").unwrap();
+
+        database.set_update_callback(Box::new(update_fn));
+
+        let schema = {
+            let data = r#"
+                identifier = "id"
+
+                [attributes."name"]
+                displayed = true
+                indexed = true
+
+                [attributes."description"]
+                displayed = true
+                indexed = true
+            "#;
+            toml::from_str(data).unwrap()
+        };
+
+        // add a schema to the index
+        let mut writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut writer, schema).unwrap();
+        writer.commit().unwrap();
+
+        // add documents to the index
+        let mut additions = index.documents_addition();
+
+        let doc1 = serde_json::json!({
+            "id": 123,
+            "name": "Marvin",
+            "description": "My name is Marvin",
+        });
+
+        let doc2 = serde_json::json!({
+            "id": 234,
+            "name": "Kevin",
+            "description": "My name is Kevin",
+        });
+
+        additions.update_document(doc1);
+        additions.update_document(doc2);
+
+        let mut writer = db.update_write_txn().unwrap();
+        let update_id = additions.finalize(&mut writer).unwrap();
+        writer.commit().unwrap();
+
+        // delete the index
         let deleted = database.delete_index("test").unwrap();
         assert!(deleted);
 
+        // block until the transaction is processed
+        let _ = receiver.into_iter().find(|id| *id == update_id);
+
         let result = database.open_index("test");
         assert!(result.is_none());
     }
+
+    #[test]
+    fn check_number_ordering() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let database = Database::open_or_create(dir.path()).unwrap();
+        let db = &database;
+
+        let (sender, receiver) = mpsc::sync_channel(100);
+        let update_fn = move |_name: &str, update: ProcessedUpdateResult| {
+            sender.send(update.update_id).unwrap()
+        };
+        let index = database.create_index("test").unwrap();
+
+        database.set_update_callback(Box::new(update_fn));
+
+        let schema = {
+            let data = r#"
+                identifier = "id"
+
+                [attributes."name"]
+                displayed = true
+                indexed = true
+
+                [attributes."release_date"]
+                displayed = true
+                ranked = true
+            "#;
+            toml::from_str(data).unwrap()
+        };
+
+        let mut writer = db.update_write_txn().unwrap();
+        let _update_id = index.schema_update(&mut writer, schema).unwrap();
+        writer.commit().unwrap();
+
+        let mut additions = index.documents_addition();
+
+        // DocumentId(7900334843754999545)
+        let doc1 = serde_json::json!({
+            "id": 123,
+            "name": "Kevin the first",
+            "release_date": -10000,
+        });
+
+        // DocumentId(8367468610878465872)
+        let doc2 = serde_json::json!({
+            "id": 234,
+            "name": "Kevin the second",
+            "release_date": 10000,
+        });
+
+        additions.update_document(doc1);
+        additions.update_document(doc2);
+
+        let mut writer = db.update_write_txn().unwrap();
+        let update_id = additions.finalize(&mut writer).unwrap();
+        writer.commit().unwrap();
+
+        // block until the transaction is processed
+        let _ = receiver.into_iter().find(|id| *id == update_id);
+
+        let reader = db.main_read_txn().unwrap();
+        let schema = index.main.schema(&reader).unwrap().unwrap();
+        let ranked_map = index.main.ranked_map(&reader).unwrap().unwrap();
+
+        let criteria = CriteriaBuilder::new()
+            .add(
+                criterion::SortByAttr::lower_is_better(&ranked_map, &schema, "release_date")
+                    .unwrap(),
+            )
+            .add(criterion::DocumentId)
+            .build();
+
+        let builder = index.query_builder_with_criteria(criteria);
+
+        let results = builder.query(&reader, "Kevin", 0..20).unwrap();
+        let mut iter = results.into_iter();
+
+        assert_matches!(
+            iter.next(),
+            Some(Document {
+                id: DocumentId(7900334843754999545),
+                ..
+            })
+        );
+        assert_matches!(
+            iter.next(),
+            Some(Document {
+                id: DocumentId(8367468610878465872),
+                ..
+            })
+        );
+        assert_matches!(iter.next(), None);
+    }
 }

meilisearch-core/src/lib.rs

@@ -0,0 +1,97 @@
+#[cfg(test)]
+#[macro_use]
+extern crate assert_matches;
+
+mod automaton;
+pub mod criterion;
+mod database;
+mod distinct_map;
+mod error;
+mod levenshtein;
+mod number;
+mod query_builder;
+mod ranked_map;
+mod raw_document;
+pub mod raw_indexer;
+mod reordered_attrs;
+pub mod serde;
+pub mod store;
+mod update;
+
+pub use self::database::{BoxUpdateFn, Database, MainT, UpdateT};
+pub use self::error::{Error, MResult};
+pub use self::number::{Number, ParseNumberError};
+pub use self::ranked_map::RankedMap;
+pub use self::raw_document::RawDocument;
+pub use self::store::Index;
+pub use self::update::{EnqueuedUpdateResult, ProcessedUpdateResult, UpdateStatus, UpdateType};
+pub use meilisearch_types::{DocIndex, DocumentId, Highlight};
+
+#[doc(hidden)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TmpMatch {
+    pub query_index: u32,
+    pub distance: u8,
+    pub attribute: u16,
+    pub word_index: u16,
+    pub is_exact: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Document {
+    pub id: DocumentId,
+    pub highlights: Vec<Highlight>,
+
+    #[cfg(test)]
+    pub matches: Vec<TmpMatch>,
+}
+
+impl Document {
+    #[cfg(not(test))]
+    fn from_raw(raw: RawDocument) -> Document {
+        Document {
+            id: raw.id,
+            highlights: raw.highlights,
+        }
+    }
+
+    #[cfg(test)]
+    fn from_raw(raw: RawDocument) -> Document {
+        let len = raw.query_index().len();
+        let mut matches = Vec::with_capacity(len);
+
+        let query_index = raw.query_index();
+        let distance = raw.distance();
+        let attribute = raw.attribute();
+        let word_index = raw.word_index();
+        let is_exact = raw.is_exact();
+
+        for i in 0..len {
+            let match_ = TmpMatch {
+                query_index: query_index[i],
+                distance: distance[i],
+                attribute: attribute[i],
+                word_index: word_index[i],
+                is_exact: is_exact[i],
+            };
+            matches.push(match_);
+        }
+
+        Document {
+            id: raw.id,
+            matches,
+            highlights: raw.highlights,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem;
+
+    #[test]
+    fn docindex_mem_size() {
+        assert_eq!(mem::size_of::<DocIndex>(), 16);
+    }
+}

meilisearch-core/src/number.rs

@@ -1,3 +1,4 @@
+use std::cmp::Ordering;
 use std::fmt;
 use std::num::{ParseFloatError, ParseIntError};
 use std::str::FromStr;
@@ -5,7 +6,7 @@ use std::str::FromStr;
 use ordered_float::OrderedFloat;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Serialize, Deserialize, Debug, Copy, Clone, Hash)]
 pub enum Number {
     Unsigned(u64),
     Signed(i64),
@@ -39,6 +40,50 @@ impl FromStr for Number {
     }
 }
 
+impl PartialEq for Number {
+    fn eq(&self, other: &Number) -> bool {
+        self.cmp(other) == Ordering::Equal
+    }
+}
+
+impl Eq for Number {}
+
+impl PartialOrd for Number {
+    fn partial_cmp(&self, other: &Number) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Number {
+    fn cmp(&self, other: &Self) -> Ordering {
+        use Number::{Float, Signed, Unsigned};
+
+        match (*self, *other) {
+            (Unsigned(a), Unsigned(b)) => a.cmp(&b),
+            (Unsigned(a), Signed(b)) => {
+                if b < 0 {
+                    Ordering::Greater
+                } else {
+                    a.cmp(&(b as u64))
+                }
+            }
+            (Unsigned(a), Float(b)) => (OrderedFloat(a as f64)).cmp(&b),
+            (Signed(a), Unsigned(b)) => {
+                if a < 0 {
+                    Ordering::Less
+                } else {
+                    (a as u64).cmp(&b)
+                }
+            }
+            (Signed(a), Signed(b)) => a.cmp(&b),
+            (Signed(a), Float(b)) => OrderedFloat(a as f64).cmp(&b),
+            (Float(a), Unsigned(b)) => a.cmp(&OrderedFloat(b as f64)),
+            (Float(a), Signed(b)) => a.cmp(&OrderedFloat(b as f64)),
+            (Float(a), Float(b)) => a.cmp(&b),
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ParseNumberError {
     uint_error: ParseIntError,

meilisearch-core/src/query_builder.rs

@@ -9,6 +9,7 @@ use fst::{IntoStreamer, Streamer};
 use sdset::SetBuf;
 use slice_group_by::{GroupBy, GroupByMut};
 
+use crate::database::MainT;
 use crate::automaton::{Automaton, AutomatonGroup, AutomatonProducer, QueryEnhancer};
 use crate::distinct_map::{BufferedDistinctMap, DistinctMap};
 use crate::levenshtein::prefix_damerau_levenshtein;
@@ -139,7 +140,7 @@ fn multiword_rewrite_matches(
 }
 
 fn fetch_raw_documents(
-    reader: &heed::RoTxn,
+    reader: &heed::RoTxn<MainT>,
     automatons_groups: &[AutomatonGroup],
     query_enhancer: &QueryEnhancer,
     searchables: Option<&ReorderedAttrs>,
@@ -336,7 +337,7 @@ impl<'c, 'f, 'd> QueryBuilder<'c, 'f, 'd> {
 
     pub fn query(
         self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         query: &str,
         range: Range<usize>,
     ) -> MResult<Vec<Document>> {
@@ -374,7 +375,7 @@ impl<'c, 'f, 'd> QueryBuilder<'c, 'f, 'd> {
 }
 
 fn raw_query<'c, FI>(
-    reader: &heed::RoTxn,
+    reader: &heed::RoTxn<MainT>,
 
     query: &str,
     range: Range<usize>,
@@ -510,7 +511,7 @@ where
 }
 
 fn raw_query_with_distinct<'c, FI, FD>(
-    reader: &heed::RoTxn,
+    reader: &heed::RoTxn<MainT>,
 
     query: &str,
     range: Range<usize>,
@@ -695,7 +696,7 @@ mod tests {
     use std::iter::FromIterator;
 
     use fst::{IntoStreamer, Set};
-    use meilidb_schema::SchemaAttr;
+    use meilisearch_schema::SchemaAttr;
     use sdset::SetBuf;
     use tempfile::TempDir;
 
@@ -765,8 +766,8 @@ mod tests {
         }
 
         pub fn add_synonym(&mut self, word: &str, new: SetBuf<&str>) {
-            let env = &self.database.env;
-            let mut writer = env.write_txn().unwrap();
+            let db = &self.database;
+            let mut writer = db.main_write_txn().unwrap();
 
             let word = word.to_lowercase();
 
@@ -809,8 +810,8 @@ mod tests {
             let database = Database::open_or_create(&tempdir).unwrap();
             let index = database.create_index("default").unwrap();
 
-            let env = &database.env;
-            let mut writer = env.write_txn().unwrap();
+            let db = &database;
+            let mut writer = db.main_write_txn().unwrap();
 
             let mut words_fst = BTreeSet::new();
             let mut postings_lists = HashMap::new();
@@ -872,8 +873,8 @@ mod tests {
             ("apple", &[doc_char_index(0, 2, 2)][..]),
         ]);
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "iphone from apple", 0..20).unwrap();
@@ -895,8 +896,8 @@ mod tests {
 
         store.add_synonym("bonjour", SetBuf::from_dirty(vec!["hello"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "hello", 0..20).unwrap();
@@ -928,8 +929,8 @@ mod tests {
         store.add_synonym("bonjour", SetBuf::from_dirty(vec!["hello"]));
         store.add_synonym("salut", SetBuf::from_dirty(vec!["hello"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "sal", 0..20).unwrap();
@@ -972,8 +973,8 @@ mod tests {
 
         store.add_synonym("salutation", SetBuf::from_dirty(vec!["hello"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "salutution", 0..20).unwrap();
@@ -1010,8 +1011,8 @@ mod tests {
         store.add_synonym("bonjour", SetBuf::from_dirty(vec!["hello", "salut"]));
         store.add_synonym("salut", SetBuf::from_dirty(vec!["hello", "bonjour"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "hello", 0..20).unwrap();
@@ -1098,8 +1099,8 @@ mod tests {
             SetBuf::from_dirty(vec!["NY", "new york", "new york city"]),
         );
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY subway", 0..20).unwrap();
@@ -1168,8 +1169,8 @@ mod tests {
 
         store.add_synonym("NY", SetBuf::from_dirty(vec!["york new"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY", 0..20).unwrap();
@@ -1226,8 +1227,8 @@ mod tests {
 
         store.add_synonym("new york", SetBuf::from_dirty(vec!["NY"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY subway", 0..20).unwrap();
@@ -1291,8 +1292,8 @@ mod tests {
             SetBuf::from_dirty(vec!["NY", "new york", "new york city"]),
         );
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY subway", 0..20).unwrap();
@@ -1372,8 +1373,8 @@ mod tests {
         );
         store.add_synonym("subway", SetBuf::from_dirty(vec!["underground train"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY subway broken", 0..20).unwrap();
@@ -1459,8 +1460,8 @@ mod tests {
         );
         store.add_synonym("underground train", SetBuf::from_dirty(vec!["subway"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder
@@ -1559,8 +1560,8 @@ mod tests {
         store.add_synonym("new york", SetBuf::from_dirty(vec!["new york city"]));
         store.add_synonym("new york city", SetBuf::from_dirty(vec!["new york"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "new york big ", 0..20).unwrap();
@@ -1596,8 +1597,8 @@ mod tests {
 
         store.add_synonym("NY", SetBuf::from_dirty(vec!["new york city story"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "NY subway ", 0..20).unwrap();
@@ -1646,8 +1647,8 @@ mod tests {
         store.add_synonym("new york city", SetBuf::from_dirty(vec!["NYC"]));
         store.add_synonym("subway", SetBuf::from_dirty(vec!["underground train"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder
@@ -1672,15 +1673,15 @@ mod tests {
     #[test]
     fn deunicoded_synonyms() {
         let mut store = TempDatabase::from_iter(vec![
-            ("telephone", &[doc_index(0, 0)][..]), // meilidb indexes the unidecoded
+            ("telephone", &[doc_index(0, 0)][..]), // meilisearch indexes the unidecoded
             ("téléphone", &[doc_index(0, 0)][..]), // and the original words on the same DocIndex
             ("iphone", &[doc_index(1, 0)][..]),
         ]);
 
         store.add_synonym("téléphone", SetBuf::from_dirty(vec!["iphone"]));
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "telephone", 0..20).unwrap();
@@ -1741,8 +1742,8 @@ mod tests {
             ("case", &[doc_index(0, 1)][..]),
         ]);
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "i phone case", 0..20).unwrap();
@@ -1769,8 +1770,8 @@ mod tests {
             ("engine", &[doc_index(1, 2)][..]),
         ]);
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "searchengine", 0..20).unwrap();
@@ -1801,8 +1802,8 @@ mod tests {
             ("engine", &[doc_index(1, 3)][..]),
         ]);
 
-        let env = &store.database.env;
-        let reader = env.read_txn().unwrap();
+        let db = &store.database;
+        let reader = db.main_read_txn().unwrap();
 
         let builder = store.query_builder();
         let results = builder.query(&reader, "searchengine", 0..20).unwrap();

meilisearch-core/src/ranked_map.rs

@@ -1,7 +1,7 @@
 use std::io::{Read, Write};
 
 use hashbrown::HashMap;
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 use serde::{Deserialize, Serialize};
 
 use crate::{DocumentId, Number};

meilisearch-core/src/raw_document.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 use std::sync::Arc;
 
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 use sdset::SetBuf;
 use slice_group_by::GroupBy;
 

meilisearch-core/src/raw_indexer.rs

@@ -3,10 +3,12 @@ use std::convert::TryFrom;
 
 use crate::{DocIndex, DocumentId};
 use deunicode::deunicode_with_tofu;
-use meilidb_schema::SchemaAttr;
-use meilidb_tokenizer::{is_cjk, SeqTokenizer, Token, Tokenizer};
+use meilisearch_schema::SchemaAttr;
+use meilisearch_tokenizer::{is_cjk, SeqTokenizer, Token, Tokenizer};
 use sdset::SetBuf;
 
+const WORD_LENGTH_LIMIT: usize = 80;
+
 type Word = Vec<u8>; // TODO make it be a SmallVec
 
 pub struct RawIndexer {
@@ -128,21 +130,26 @@ fn index_token(
         match token_to_docindex(id, attr, token) {
             Some(docindex) => {
                 let word = Vec::from(token.word);
-                words_doc_indexes
-                    .entry(word.clone())
-                    .or_insert_with(Vec::new)
-                    .push(docindex);
-                docs_words.entry(id).or_insert_with(Vec::new).push(word);
 
-                if !lower.contains(is_cjk) {
-                    let unidecoded = deunicode_with_tofu(&lower, "");
-                    if unidecoded != lower && !unidecoded.is_empty() {
-                        let word = Vec::from(unidecoded);
-                        words_doc_indexes
-                            .entry(word.clone())
-                            .or_insert_with(Vec::new)
-                            .push(docindex);
-                        docs_words.entry(id).or_insert_with(Vec::new).push(word);
+                if word.len() <= WORD_LENGTH_LIMIT {
+                    words_doc_indexes
+                        .entry(word.clone())
+                        .or_insert_with(Vec::new)
+                        .push(docindex);
+                    docs_words.entry(id).or_insert_with(Vec::new).push(word);
+
+                    if !lower.contains(is_cjk) {
+                        let unidecoded = deunicode_with_tofu(&lower, "");
+                        if unidecoded != lower && !unidecoded.is_empty() {
+                            let word = Vec::from(unidecoded);
+                            if word.len() <= WORD_LENGTH_LIMIT {
+                                words_doc_indexes
+                                    .entry(word.clone())
+                                    .or_insert_with(Vec::new)
+                                    .push(docindex);
+                                docs_words.entry(id).or_insert_with(Vec::new).push(word);
+                            }
+                        }
                     }
                 }
             }

meilisearch-core/src/serde/deserializer.rs

@@ -2,12 +2,13 @@ use std::collections::HashSet;
 use std::io::Cursor;
 use std::{error::Error, fmt};
 
-use meilidb_schema::{Schema, SchemaAttr};
+use meilisearch_schema::{Schema, SchemaAttr};
 use serde::{de, forward_to_deserialize_any};
 use serde_json::de::IoRead as SerdeJsonIoRead;
 use serde_json::Deserializer as SerdeJsonDeserializer;
 use serde_json::Error as SerdeJsonError;
 
+use crate::database::MainT;
 use crate::store::DocumentsFields;
 use crate::DocumentId;
 
@@ -50,7 +51,7 @@ impl From<heed::Error> for DeserializerError {
 
 pub struct Deserializer<'a> {
     pub document_id: DocumentId,
-    pub reader: &'a heed::RoTxn,
+    pub reader: &'a heed::RoTxn<MainT>,
     pub documents_fields: DocumentsFields,
     pub schema: &'a Schema,
     pub attributes: Option<&'a HashSet<SchemaAttr>>,

meilisearch-core/src/serde/indexer.rs

@@ -1,4 +1,4 @@
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 use serde::ser;
 use serde::Serialize;
 

meilisearch-core/src/serde/serializer.rs

@@ -1,6 +1,7 @@
-use meilidb_schema::{Schema, SchemaAttr, SchemaProps};
+use meilisearch_schema::{Schema, SchemaAttr, SchemaProps};
 use serde::ser;
 
+use crate::database::MainT;
 use crate::raw_indexer::RawIndexer;
 use crate::store::{DocumentsFields, DocumentsFieldsCounts};
 use crate::{DocumentId, RankedMap};
@@ -8,7 +9,7 @@ use crate::{DocumentId, RankedMap};
 use super::{ConvertToNumber, ConvertToString, Indexer, SerializerError};
 
 pub struct Serializer<'a, 'b> {
-    pub txn: &'a mut heed::RwTxn<'b>,
+    pub txn: &'a mut heed::RwTxn<'b, MainT>,
     pub schema: &'a Schema,
     pub document_store: DocumentsFields,
     pub document_fields_counts: DocumentsFieldsCounts,
@@ -191,7 +192,7 @@ impl<'a, 'b> ser::Serializer for Serializer<'a, 'b> {
 }
 
 pub struct MapSerializer<'a, 'b> {
-    txn: &'a mut heed::RwTxn<'b>,
+    txn: &'a mut heed::RwTxn<'b, MainT>,
     schema: &'a Schema,
     document_id: DocumentId,
     document_store: DocumentsFields,
@@ -254,7 +255,7 @@ impl<'a, 'b> ser::SerializeMap for MapSerializer<'a, 'b> {
 }
 
 pub struct StructSerializer<'a, 'b> {
-    txn: &'a mut heed::RwTxn<'b>,
+    txn: &'a mut heed::RwTxn<'b, MainT>,
     schema: &'a Schema,
     document_id: DocumentId,
     document_store: DocumentsFields,
@@ -297,7 +298,7 @@ impl<'a, 'b> ser::SerializeStruct for StructSerializer<'a, 'b> {
 }
 
 pub fn serialize_value<T: ?Sized>(
-    txn: &mut heed::RwTxn,
+    txn: &mut heed::RwTxn<MainT>,
     attribute: SchemaAttr,
     props: SchemaProps,
     document_id: DocumentId,

meilisearch-core/src/store/docs_words.rs

@@ -1,4 +1,5 @@
 use super::BEU64;
+use crate::database::MainT;
 use crate::DocumentId;
 use heed::types::{ByteSlice, OwnedType};
 use heed::Result as ZResult;
@@ -12,7 +13,7 @@ pub struct DocsWords {
 impl DocsWords {
     pub fn put_doc_words(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
         words: &fst::Set,
     ) -> ZResult<()> {
@@ -21,25 +22,25 @@ impl DocsWords {
         self.docs_words.put(writer, &document_id, bytes)
     }
 
-    pub fn del_doc_words(self, writer: &mut heed::RwTxn, document_id: DocumentId) -> ZResult<bool> {
+    pub fn del_doc_words(self, writer: &mut heed::RwTxn<MainT>, document_id: DocumentId) -> ZResult<bool> {
         let document_id = BEU64::new(document_id.0);
         self.docs_words.delete(writer, &document_id)
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
         self.docs_words.clear(writer)
     }
 
     pub fn doc_words(
         self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         document_id: DocumentId,
     ) -> ZResult<Option<fst::Set>> {
         let document_id = BEU64::new(document_id.0);
         match self.docs_words.get(reader, &document_id)? {
             Some(bytes) => {
                 let len = bytes.len();
-                let bytes = Arc::from(bytes);
+                let bytes = Arc::new(bytes.to_owned());
                 let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
                 Ok(Some(fst::Set::from(fst)))
             }

meilisearch-core/src/store/documents_fields.rs

@@ -1,6 +1,7 @@
 use heed::types::{ByteSlice, OwnedType};
+use crate::database::MainT;
 use heed::Result as ZResult;
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 
 use super::DocumentAttrKey;
 use crate::DocumentId;
@@ -13,7 +14,7 @@ pub struct DocumentsFields {
 impl DocumentsFields {
     pub fn put_document_field(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
         attribute: SchemaAttr,
         value: &[u8],
@@ -24,7 +25,7 @@ impl DocumentsFields {
 
     pub fn del_all_document_fields(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
     ) -> ZResult<usize> {
         let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
@@ -32,13 +33,13 @@ impl DocumentsFields {
         self.documents_fields.delete_range(writer, &(start..=end))
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
         self.documents_fields.clear(writer)
     }
 
     pub fn document_attribute<'txn>(
         self,
-        reader: &'txn heed::RoTxn,
+        reader: &'txn heed::RoTxn<MainT>,
         document_id: DocumentId,
         attribute: SchemaAttr,
     ) -> ZResult<Option<&'txn [u8]>> {
@@ -48,7 +49,7 @@ impl DocumentsFields {
 
     pub fn document_fields<'txn>(
         self,
-        reader: &'txn heed::RoTxn,
+        reader: &'txn heed::RoTxn<MainT>,
         document_id: DocumentId,
     ) -> ZResult<DocumentFieldsIter<'txn>> {
         let start = DocumentAttrKey::new(document_id, SchemaAttr::min());

meilisearch-core/src/store/documents_fields_counts.rs

@@ -1,8 +1,9 @@
 use super::DocumentAttrKey;
+use crate::database::MainT;
 use crate::DocumentId;
 use heed::types::OwnedType;
 use heed::Result as ZResult;
-use meilidb_schema::SchemaAttr;
+use meilisearch_schema::SchemaAttr;
 
 #[derive(Copy, Clone)]
 pub struct DocumentsFieldsCounts {
@@ -12,7 +13,7 @@ pub struct DocumentsFieldsCounts {
 impl DocumentsFieldsCounts {
     pub fn put_document_field_count(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
         attribute: SchemaAttr,
         value: u64,
@@ -23,7 +24,7 @@ impl DocumentsFieldsCounts {
 
     pub fn del_all_document_fields_counts(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
     ) -> ZResult<usize> {
         let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
@@ -32,13 +33,13 @@ impl DocumentsFieldsCounts {
             .delete_range(writer, &(start..=end))
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
         self.documents_fields_counts.clear(writer)
     }
 
     pub fn document_field_count(
         self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         document_id: DocumentId,
         attribute: SchemaAttr,
     ) -> ZResult<Option<u64>> {
@@ -51,7 +52,7 @@ impl DocumentsFieldsCounts {
 
     pub fn document_fields_counts<'txn>(
         self,
-        reader: &'txn heed::RoTxn,
+        reader: &'txn heed::RoTxn<MainT>,
         document_id: DocumentId,
     ) -> ZResult<DocumentFieldsCountsIter<'txn>> {
         let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
@@ -60,7 +61,7 @@ impl DocumentsFieldsCounts {
         Ok(DocumentFieldsCountsIter { iter })
     }
 
-    pub fn documents_ids<'txn>(self, reader: &'txn heed::RoTxn) -> ZResult<DocumentsIdsIter<'txn>> {
+    pub fn documents_ids<'txn>(self, reader: &'txn heed::RoTxn<MainT>) -> ZResult<DocumentsIdsIter<'txn>> {
         let iter = self.documents_fields_counts.iter(reader)?;
         Ok(DocumentsIdsIter {
             last_seen_id: None,
@@ -70,7 +71,7 @@ impl DocumentsFieldsCounts {
 
     pub fn all_documents_fields_counts<'txn>(
         self,
-        reader: &'txn heed::RoTxn,
+        reader: &'txn heed::RoTxn<MainT>,
     ) -> ZResult<AllDocumentsFieldsCountsIter<'txn>> {
         let iter = self.documents_fields_counts.iter(reader)?;
         Ok(AllDocumentsFieldsCountsIter { iter })

meilisearch-core/src/store/main.rs

@@ -0,0 +1,184 @@
+use crate::database::MainT;
+use crate::RankedMap;
+use chrono::{DateTime, Utc};
+use heed::types::{ByteSlice, OwnedType, SerdeBincode, Str};
+use heed::Result as ZResult;
+use meilisearch_schema::Schema;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+const CREATED_AT_KEY: &str = "created-at";
+const CUSTOMS_KEY: &str = "customs-key";
+const FIELDS_FREQUENCY_KEY: &str = "fields-frequency";
+const NAME_KEY: &str = "name";
+const NUMBER_OF_DOCUMENTS_KEY: &str = "number-of-documents";
+const RANKED_MAP_KEY: &str = "ranked-map";
+const SCHEMA_KEY: &str = "schema";
+const STOP_WORDS_KEY: &str = "stop-words";
+const SYNONYMS_KEY: &str = "synonyms";
+const UPDATED_AT_KEY: &str = "updated-at";
+const WORDS_KEY: &str = "words";
+
+pub type FreqsMap = HashMap<String, usize>;
+type SerdeFreqsMap = SerdeBincode<FreqsMap>;
+type SerdeDatetime = SerdeBincode<DateTime<Utc>>;
+
+#[derive(Copy, Clone)]
+pub struct Main {
+    pub(crate) main: heed::PolyDatabase,
+}
+
+impl Main {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
+        self.main.clear(writer)
+    }
+
+    pub fn put_name(self, writer: &mut heed::RwTxn<MainT>, name: &str) -> ZResult<()> {
+        self.main.put::<_, Str, Str>(writer, NAME_KEY, name)
+    }
+
+    pub fn name(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<String>> {
+        Ok(self
+            .main
+            .get::<_, Str, Str>(reader, NAME_KEY)?
+            .map(|name| name.to_owned()))
+    }
+
+    pub fn put_created_at(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
+        self.main
+            .put::<_, Str, SerdeDatetime>(writer, CREATED_AT_KEY, &Utc::now())
+    }
+
+    pub fn created_at(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<DateTime<Utc>>> {
+        self.main.get::<_, Str, SerdeDatetime>(reader, CREATED_AT_KEY)
+    }
+
+    pub fn put_updated_at(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
+        self.main
+            .put::<_, Str, SerdeDatetime>(writer, UPDATED_AT_KEY, &Utc::now())
+    }
+
+    pub fn updated_at(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<DateTime<Utc>>> {
+        self.main.get::<_, Str, SerdeDatetime>(reader, UPDATED_AT_KEY)
+    }
+
+    pub fn put_words_fst(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set) -> ZResult<()> {
+        let bytes = fst.as_fst().as_bytes();
+        self.main.put::<_, Str, ByteSlice>(writer, WORDS_KEY, bytes)
+    }
+
+    pub fn words_fst(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<fst::Set>> {
+        match self.main.get::<_, Str, ByteSlice>(reader, WORDS_KEY)? {
+            Some(bytes) => {
+                let len = bytes.len();
+                let bytes = Arc::new(bytes.to_owned());
+                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
+                Ok(Some(fst::Set::from(fst)))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_schema(self, writer: &mut heed::RwTxn<MainT>, schema: &Schema) -> ZResult<()> {
+        self.main
+            .put::<_, Str, SerdeBincode<Schema>>(writer, SCHEMA_KEY, schema)
+    }
+
+    pub fn schema(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<Schema>> {
+        self.main
+            .get::<_, Str, SerdeBincode<Schema>>(reader, SCHEMA_KEY)
+    }
+
+    pub fn put_ranked_map(self, writer: &mut heed::RwTxn<MainT>, ranked_map: &RankedMap) -> ZResult<()> {
+        self.main
+            .put::<_, Str, SerdeBincode<RankedMap>>(writer, RANKED_MAP_KEY, &ranked_map)
+    }
+
+    pub fn ranked_map(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<RankedMap>> {
+        self.main
+            .get::<_, Str, SerdeBincode<RankedMap>>(reader, RANKED_MAP_KEY)
+    }
+
+    pub fn put_synonyms_fst(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set) -> ZResult<()> {
+        let bytes = fst.as_fst().as_bytes();
+        self.main.put::<_, Str, ByteSlice>(writer, SYNONYMS_KEY, bytes)
+    }
+
+    pub fn synonyms_fst(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<fst::Set>> {
+        match self.main.get::<_, Str, ByteSlice>(reader, SYNONYMS_KEY)? {
+            Some(bytes) => {
+                let len = bytes.len();
+                let bytes = Arc::new(bytes.to_owned());
+                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
+                Ok(Some(fst::Set::from(fst)))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_stop_words_fst(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set) -> ZResult<()> {
+        let bytes = fst.as_fst().as_bytes();
+        self.main
+            .put::<_, Str, ByteSlice>(writer, STOP_WORDS_KEY, bytes)
+    }
+
+    pub fn stop_words_fst(self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<fst::Set>> {
+        match self.main.get::<_, Str, ByteSlice>(reader, STOP_WORDS_KEY)? {
+            Some(bytes) => {
+                let len = bytes.len();
+                let bytes = Arc::new(bytes.to_owned());
+                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
+                Ok(Some(fst::Set::from(fst)))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_number_of_documents<F>(self, writer: &mut heed::RwTxn<MainT>, f: F) -> ZResult<u64>
+    where
+        F: Fn(u64) -> u64,
+    {
+        let new = self.number_of_documents(&*writer).map(f)?;
+        self.main
+            .put::<_, Str, OwnedType<u64>>(writer, NUMBER_OF_DOCUMENTS_KEY, &new)?;
+        Ok(new)
+    }
+
+    pub fn number_of_documents(self, reader: &heed::RoTxn<MainT>) -> ZResult<u64> {
+        match self
+            .main
+            .get::<_, Str, OwnedType<u64>>(reader, NUMBER_OF_DOCUMENTS_KEY)?
+        {
+            Some(value) => Ok(value),
+            None => Ok(0),
+        }
+    }
+
+    pub fn put_fields_frequency(
+        self,
+        writer: &mut heed::RwTxn<MainT>,
+        fields_frequency: &FreqsMap,
+    ) -> ZResult<()> {
+        self.main
+            .put::<_, Str, SerdeFreqsMap>(writer, FIELDS_FREQUENCY_KEY, fields_frequency)
+    }
+
+    pub fn fields_frequency(&self, reader: &heed::RoTxn<MainT>) -> ZResult<Option<FreqsMap>> {
+        match self
+            .main
+            .get::<_, Str, SerdeFreqsMap>(reader, FIELDS_FREQUENCY_KEY)?
+        {
+            Some(freqs) => Ok(Some(freqs)),
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_customs(self, writer: &mut heed::RwTxn<MainT>, customs: &[u8]) -> ZResult<()> {
+        self.main
+            .put::<_, Str, ByteSlice>(writer, CUSTOMS_KEY, customs)
+    }
+
+    pub fn customs<'txn>(self, reader: &'txn heed::RoTxn<MainT>) -> ZResult<Option<&'txn [u8]>> {
+        self.main.get::<_, Str, ByteSlice>(reader, CUSTOMS_KEY)
+    }
+}

meilisearch-core/src/store/mod.rs

@@ -21,12 +21,13 @@ pub use self::updates_results::UpdatesResults;
 use std::collections::HashSet;
 
 use heed::Result as ZResult;
-use meilidb_schema::{Schema, SchemaAttr};
+use meilisearch_schema::{Schema, SchemaAttr};
 use serde::de::{self, Deserialize};
 use zerocopy::{AsBytes, FromBytes};
 
 use crate::criterion::Criteria;
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
+use crate::database::{MainT, UpdateT};
 use crate::serde::Deserializer;
 use crate::{query_builder::QueryBuilder, update, DocumentId, Error, MResult};
 
@@ -92,13 +93,13 @@ pub struct Index {
 
     pub updates: Updates,
     pub updates_results: UpdatesResults,
-    updates_notifier: UpdateEventsEmitter,
+    pub(crate) updates_notifier: UpdateEventsEmitter,
 }
 
 impl Index {
     pub fn document<T: de::DeserializeOwned>(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         attributes: Option<&HashSet<&str>>,
         document_id: DocumentId,
     ) -> MResult<Option<T>> {
@@ -126,7 +127,7 @@ impl Index {
 
     pub fn document_attribute<T: de::DeserializeOwned>(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         document_id: DocumentId,
         attribute: SchemaAttr,
     ) -> MResult<Option<T>> {
@@ -139,12 +140,12 @@ impl Index {
         }
     }
 
-    pub fn schema_update(&self, writer: &mut heed::RwTxn, schema: Schema) -> MResult<u64> {
+    pub fn schema_update(&self, writer: &mut heed::RwTxn<UpdateT>, schema: Schema) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         update::push_schema_update(writer, self.updates, self.updates_results, schema)
     }
 
-    pub fn customs_update(&self, writer: &mut heed::RwTxn, customs: Vec<u8>) -> ZResult<u64> {
+    pub fn customs_update(&self, writer: &mut heed::RwTxn<UpdateT>, customs: Vec<u8>) -> ZResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         update::push_customs_update(writer, self.updates, self.updates_results, customs)
     }
@@ -173,7 +174,7 @@ impl Index {
         )
     }
 
-    pub fn clear_all(&self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn clear_all(&self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         update::push_clear_all(writer, self.updates, self.updates_results)
     }
@@ -210,8 +211,8 @@ impl Index {
         )
     }
 
-    pub fn current_update_id(&self, reader: &heed::RoTxn) -> MResult<Option<u64>> {
-        match self.updates.last_update_id(reader)? {
+    pub fn current_update_id(&self, reader: &heed::RoTxn<UpdateT>) -> MResult<Option<u64>> {
+        match self.updates.last_update(reader)? {
             Some((id, _)) => Ok(Some(id)),
             None => Ok(None),
         }
@@ -219,32 +220,34 @@ impl Index {
 
     pub fn update_status(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<UpdateT>,
         update_id: u64,
-    ) -> MResult<update::UpdateStatus> {
+    ) -> MResult<Option<update::UpdateStatus>> {
         update::update_status(reader, self.updates, self.updates_results, update_id)
     }
 
-    pub fn all_updates_status(&self, reader: &heed::RoTxn) -> MResult<Vec<update::UpdateStatus>> {
+    pub fn all_updates_status(&self, reader: &heed::RoTxn<UpdateT>) -> MResult<Vec<update::UpdateStatus>> {
         let mut updates = Vec::new();
         let mut last_update_result_id = 0;
 
         // retrieve all updates results
-        if let Some((last_id, _)) = self.updates_results.last_update_id(reader)? {
+        if let Some((last_id, _)) = self.updates_results.last_update(reader)? {
             updates.reserve(last_id as usize);
 
             for id in 0..=last_id {
-                let update = self.update_status(reader, id)?;
-                updates.push(update);
-                last_update_result_id = id;
+                if let Some(update) = self.update_status(reader, id)? {
+                    updates.push(update);
+                    last_update_result_id = id;
+                }
             }
         }
 
         // retrieve all enqueued updates
-        if let Some((last_id, _)) = self.updates.last_update_id(reader)? {
-            for id in last_update_result_id + 1..last_id {
-                let update = self.update_status(reader, id)?;
-                updates.push(update);
+        if let Some((last_id, _)) = self.updates.last_update(reader)? {
+            for id in last_update_result_id + 1..=last_id {
+                if let Some(update) = self.update_status(reader, id)? {
+                    updates.push(update);
+                }
             }
         }
 
@@ -276,6 +279,7 @@ impl Index {
 
 pub fn create(
     env: &heed::Env,
+    update_env: &heed::Env,
     name: &str,
     updates_notifier: UpdateEventsEmitter,
 ) -> MResult<Index> {
@@ -296,8 +300,8 @@ pub fn create(
     let documents_fields_counts = env.create_database(Some(&documents_fields_counts_name))?;
     let synonyms = env.create_database(Some(&synonyms_name))?;
     let docs_words = env.create_database(Some(&docs_words_name))?;
-    let updates = env.create_database(Some(&updates_name))?;
-    let updates_results = env.create_database(Some(&updates_results_name))?;
+    let updates = update_env.create_database(Some(&updates_name))?;
+    let updates_results = update_env.create_database(Some(&updates_results_name))?;
 
     Ok(Index {
         main: Main { main },
@@ -316,6 +320,7 @@ pub fn create(
 
 pub fn open(
     env: &heed::Env,
+    update_env: &heed::Env,
     name: &str,
     updates_notifier: UpdateEventsEmitter,
 ) -> MResult<Option<Index>> {
@@ -354,11 +359,11 @@ pub fn open(
         Some(docs_words) => docs_words,
         None => return Ok(None),
     };
-    let updates = match env.open_database(Some(&updates_name))? {
+    let updates = match update_env.open_database(Some(&updates_name))? {
         Some(updates) => updates,
         None => return Ok(None),
     };
-    let updates_results = match env.open_database(Some(&updates_results_name))? {
+    let updates_results = match update_env.open_database(Some(&updates_results_name))? {
         Some(updates_results) => updates_results,
         None => return Ok(None),
     };
@@ -378,10 +383,11 @@ pub fn open(
     }))
 }
 
-pub fn clear(writer: &mut heed::RwTxn, index: &Index) -> MResult<()> {
-    // send a stop event to the update loop of the index
-    index.updates_notifier.send(UpdateEvent::MustStop).unwrap();
-
+pub fn clear(
+    writer: &mut heed::RwTxn<MainT>,
+    update_writer: &mut heed::RwTxn<UpdateT>,
+    index: &Index,
+) -> MResult<()> {
     // clear all the stores
     index.main.clear(writer)?;
     index.postings_lists.clear(writer)?;
@@ -389,7 +395,7 @@ pub fn clear(writer: &mut heed::RwTxn, index: &Index) -> MResult<()> {
     index.documents_fields_counts.clear(writer)?;
     index.synonyms.clear(writer)?;
     index.docs_words.clear(writer)?;
-    index.updates.clear(writer)?;
-    index.updates_results.clear(writer)?;
+    index.updates.clear(update_writer)?;
+    index.updates_results.clear(update_writer)?;
     Ok(())
 }

meilisearch-core/src/store/postings_lists.rs

@@ -1,4 +1,5 @@
 use crate::DocIndex;
+use crate::database::MainT;
 use heed::types::{ByteSlice, CowSlice};
 use heed::Result as ZResult;
 use sdset::{Set, SetBuf};
@@ -12,24 +13,24 @@ pub struct PostingsLists {
 impl PostingsLists {
     pub fn put_postings_list(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         word: &[u8],
         words_indexes: &Set<DocIndex>,
     ) -> ZResult<()> {
         self.postings_lists.put(writer, word, words_indexes)
     }
 
-    pub fn del_postings_list(self, writer: &mut heed::RwTxn, word: &[u8]) -> ZResult<bool> {
+    pub fn del_postings_list(self, writer: &mut heed::RwTxn<MainT>, word: &[u8]) -> ZResult<bool> {
         self.postings_lists.delete(writer, word)
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
         self.postings_lists.clear(writer)
     }
 
     pub fn postings_list<'txn>(
         self,
-        reader: &'txn heed::RoTxn,
+        reader: &'txn heed::RoTxn<MainT>,
         word: &[u8],
     ) -> ZResult<Option<Cow<'txn, Set<DocIndex>>>> {
         match self.postings_lists.get(reader, word)? {

meilisearch-core/src/store/synonyms.rs

@@ -1,4 +1,5 @@
 use heed::types::ByteSlice;
+use crate::database::MainT;
 use heed::Result as ZResult;
 use std::sync::Arc;
 
@@ -10,7 +11,7 @@ pub struct Synonyms {
 impl Synonyms {
     pub fn put_synonyms(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         word: &[u8],
         synonyms: &fst::Set,
     ) -> ZResult<()> {
@@ -18,19 +19,19 @@ impl Synonyms {
         self.synonyms.put(writer, word, bytes)
     }
 
-    pub fn del_synonyms(self, writer: &mut heed::RwTxn, word: &[u8]) -> ZResult<bool> {
+    pub fn del_synonyms(self, writer: &mut heed::RwTxn<MainT>, word: &[u8]) -> ZResult<bool> {
         self.synonyms.delete(writer, word)
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
         self.synonyms.clear(writer)
     }
 
-    pub fn synonyms(self, reader: &heed::RoTxn, word: &[u8]) -> ZResult<Option<fst::Set>> {
+    pub fn synonyms(self, reader: &heed::RoTxn<MainT>, word: &[u8]) -> ZResult<Option<fst::Set>> {
         match self.synonyms.get(reader, word)? {
             Some(bytes) => {
                 let len = bytes.len();
-                let bytes = Arc::from(bytes);
+                let bytes = Arc::new(bytes.to_owned());
                 let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
                 Ok(Some(fst::Set::from(fst)))
             }

meilisearch-core/src/store/updates.rs

@@ -1,4 +1,5 @@
 use super::BEU64;
+use crate::database::UpdateT;
 use crate::update::Update;
 use heed::types::{OwnedType, SerdeJson};
 use heed::Result as ZResult;
@@ -10,7 +11,7 @@ pub struct Updates {
 
 impl Updates {
     // TODO do not trigger deserialize if possible
-    pub fn last_update_id(self, reader: &heed::RoTxn) -> ZResult<Option<(u64, Update)>> {
+    pub fn last_update(self, reader: &heed::RoTxn<UpdateT>) -> ZResult<Option<(u64, Update)>> {
         match self.updates.last(reader)? {
             Some((key, data)) => Ok(Some((key.get(), data))),
             None => Ok(None),
@@ -18,7 +19,7 @@ impl Updates {
     }
 
     // TODO do not trigger deserialize if possible
-    fn first_update_id(self, reader: &heed::RoTxn) -> ZResult<Option<(u64, Update)>> {
+    pub fn first_update(self, reader: &heed::RoTxn<UpdateT>) -> ZResult<Option<(u64, Update)>> {
         match self.updates.first(reader)? {
             Some((key, data)) => Ok(Some((key.get(), data))),
             None => Ok(None),
@@ -26,14 +27,14 @@ impl Updates {
     }
 
     // TODO do not trigger deserialize if possible
-    pub fn get(self, reader: &heed::RoTxn, update_id: u64) -> ZResult<Option<Update>> {
+    pub fn get(self, reader: &heed::RoTxn<UpdateT>, update_id: u64) -> ZResult<Option<Update>> {
         let update_id = BEU64::new(update_id);
         self.updates.get(reader, &update_id)
     }
 
     pub fn put_update(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<UpdateT>,
         update_id: u64,
         update: &Update,
     ) -> ZResult<()> {
@@ -42,8 +43,13 @@ impl Updates {
         self.updates.put(writer, &update_id, update)
     }
 
-    pub fn pop_front(self, writer: &mut heed::RwTxn) -> ZResult<Option<(u64, Update)>> {
-        match self.first_update_id(writer)? {
+    pub fn del_update(self, writer: &mut heed::RwTxn<UpdateT>, update_id: u64) -> ZResult<bool> {
+        let update_id = BEU64::new(update_id);
+        self.updates.delete(writer, &update_id)
+    }
+
+    pub fn pop_front(self, writer: &mut heed::RwTxn<UpdateT>) -> ZResult<Option<(u64, Update)>> {
+        match self.first_update(writer)? {
             Some((update_id, update)) => {
                 let key = BEU64::new(update_id);
                 self.updates.delete(writer, &key)?;
@@ -53,7 +59,7 @@ impl Updates {
         }
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<UpdateT>) -> ZResult<()> {
         self.updates.clear(writer)
     }
 }

meilisearch-core/src/store/updates_results.rs

@@ -1,18 +1,18 @@
 use super::BEU64;
+use crate::database::UpdateT;
 use crate::update::ProcessedUpdateResult;
-use heed::types::{OwnedType, SerdeBincode};
+use heed::types::{OwnedType, SerdeJson};
 use heed::Result as ZResult;
 
 #[derive(Copy, Clone)]
 pub struct UpdatesResults {
-    pub(crate) updates_results:
-        heed::Database<OwnedType<BEU64>, SerdeBincode<ProcessedUpdateResult>>,
+    pub(crate) updates_results: heed::Database<OwnedType<BEU64>, SerdeJson<ProcessedUpdateResult>>,
 }
 
 impl UpdatesResults {
-    pub fn last_update_id(
+    pub fn last_update(
         self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<UpdateT>,
     ) -> ZResult<Option<(u64, ProcessedUpdateResult)>> {
         match self.updates_results.last(reader)? {
             Some((key, data)) => Ok(Some((key.get(), data))),
@@ -22,7 +22,7 @@ impl UpdatesResults {
 
     pub fn put_update_result(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<UpdateT>,
         update_id: u64,
         update_result: &ProcessedUpdateResult,
     ) -> ZResult<()> {
@@ -32,14 +32,14 @@ impl UpdatesResults {
 
     pub fn update_result(
         self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<UpdateT>,
         update_id: u64,
     ) -> ZResult<Option<ProcessedUpdateResult>> {
         let update_id = BEU64::new(update_id);
         self.updates_results.get(reader, &update_id)
     }
 
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+    pub fn clear(self, writer: &mut heed::RwTxn<UpdateT>) -> ZResult<()> {
         self.updates_results.clear(writer)
     }
 }

meilisearch-core/src/update/clear_all.rs

@@ -1,8 +1,9 @@
+use crate::database::{MainT, UpdateT};
 use crate::update::{next_update_id, Update};
 use crate::{store, MResult, RankedMap};
 
 pub fn apply_clear_all(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,
@@ -21,12 +22,12 @@ pub fn apply_clear_all(
 }
 
 pub fn push_clear_all(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
-    let update = Update::ClearAll;
+    let update = Update::clear_all();
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)

meilisearch-core/src/update/customs_update.rs

@@ -1,9 +1,11 @@
-use crate::store;
-use crate::update::{next_update_id, Update};
 use heed::Result as ZResult;
 
+use crate::database::{MainT, UpdateT};
+use crate::store;
+use crate::update::{next_update_id, Update};
+
 pub fn apply_customs_update(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     customs: &[u8],
 ) -> ZResult<()> {
@@ -11,14 +13,14 @@ pub fn apply_customs_update(
 }
 
 pub fn push_customs_update(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     customs: Vec<u8>,
 ) -> ZResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::Customs(customs);
+    let update = Update::customs(customs);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)

meilisearch-core/src/update/documents_addition.rs

@@ -4,6 +4,7 @@ use fst::{set::OpBuilder, SetBuilder};
 use sdset::{duo::Union, SetOperation};
 use serde::{Deserialize, Serialize};
 
+use crate::database::{MainT, UpdateT};
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::raw_indexer::RawIndexer;
 use crate::serde::{extract_document_id, serialize_value, Deserializer, Serializer};
@@ -52,7 +53,7 @@ impl<D> DocumentsAddition<D> {
         self.documents.push(document);
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64>
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64>
     where
         D: serde::Serialize,
     {
@@ -75,7 +76,7 @@ impl<D> Extend<D> for DocumentsAddition<D> {
 }
 
 pub fn push_documents_addition<D: serde::Serialize>(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     addition: Vec<D>,
@@ -91,9 +92,9 @@ pub fn push_documents_addition<D: serde::Serialize>(
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
     let update = if is_partial {
-        Update::DocumentsPartial(values)
+        Update::documents_partial(values)
     } else {
-        Update::DocumentsAddition(values)
+        Update::documents_addition(values)
     };
 
     updates_store.put_update(writer, last_update_id, &update)?;
@@ -102,7 +103,7 @@ pub fn push_documents_addition<D: serde::Serialize>(
 }
 
 pub fn apply_documents_addition<'a, 'b>(
-    writer: &'a mut heed::RwTxn<'b>,
+    writer: &'a mut heed::RwTxn<'b, MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,
@@ -181,7 +182,7 @@ pub fn apply_documents_addition<'a, 'b>(
 }
 
 pub fn apply_documents_partial_addition<'a, 'b>(
-    writer: &'a mut heed::RwTxn<'b>,
+    writer: &'a mut heed::RwTxn<'b, MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,
@@ -277,7 +278,7 @@ pub fn apply_documents_partial_addition<'a, 'b>(
 }
 
 pub fn reindex_all_documents(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,
@@ -354,7 +355,7 @@ pub fn reindex_all_documents(
 }
 
 pub fn write_documents_addition_index(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     postings_lists_store: store::PostingsLists,
     docs_words_store: store::DocsWords,

meilisearch-core/src/update/documents_deletion.rs

@@ -1,9 +1,10 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
 
 use fst::{SetBuilder, Streamer};
-use meilidb_schema::Schema;
+use meilisearch_schema::Schema;
 use sdset::{duo::DifferenceByKey, SetBuf, SetOperation};
 
+use crate::database::{MainT, UpdateT};
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::serde::extract_document_id;
 use crate::store;
@@ -50,7 +51,7 @@ impl DocumentsDeletion {
         Ok(())
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         let update_id = push_documents_deletion(
             writer,
@@ -69,21 +70,21 @@ impl Extend<DocumentId> for DocumentsDeletion {
 }
 
 pub fn push_documents_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     deletion: Vec<DocumentId>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::DocumentsDeletion(deletion);
+    let update = Update::documents_deletion(deletion);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_documents_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,

meilisearch-core/src/update/mod.rs

@@ -22,17 +22,97 @@ pub use self::synonyms_deletion::{apply_synonyms_deletion, SynonymsDeletion};
 
 use std::cmp;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
+use chrono::{DateTime, Utc};
 use heed::Result as ZResult;
 use log::debug;
 use serde::{Deserialize, Serialize};
 
 use crate::{store, DocumentId, MResult};
-use meilidb_schema::Schema;
+use crate::database::{MainT, UpdateT};
+use meilisearch_schema::Schema;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum Update {
+pub struct Update {
+    data: UpdateData,
+    enqueued_at: DateTime<Utc>,
+}
+
+impl Update {
+    fn clear_all() -> Update {
+        Update {
+            data: UpdateData::ClearAll,
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn schema(data: Schema) -> Update {
+        Update {
+            data: UpdateData::Schema(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn customs(data: Vec<u8>) -> Update {
+        Update {
+            data: UpdateData::Customs(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn documents_addition(data: Vec<HashMap<String, serde_json::Value>>) -> Update {
+        Update {
+            data: UpdateData::DocumentsAddition(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn documents_partial(data: Vec<HashMap<String, serde_json::Value>>) -> Update {
+        Update {
+            data: UpdateData::DocumentsPartial(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn documents_deletion(data: Vec<DocumentId>) -> Update {
+        Update {
+            data: UpdateData::DocumentsDeletion(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn synonyms_addition(data: BTreeMap<String, Vec<String>>) -> Update {
+        Update {
+            data: UpdateData::SynonymsAddition(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn synonyms_deletion(data: BTreeMap<String, Option<Vec<String>>>) -> Update {
+        Update {
+            data: UpdateData::SynonymsDeletion(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn stop_words_addition(data: BTreeSet<String>) -> Update {
+        Update {
+            data: UpdateData::StopWordsAddition(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+
+    fn stop_words_deletion(data: BTreeSet<String>) -> Update {
+        Update {
+            data: UpdateData::StopWordsDeletion(data),
+            enqueued_at: Utc::now(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UpdateData {
     ClearAll,
     Schema(Schema),
     Customs(Vec<u8>),
@@ -45,33 +125,31 @@ pub enum Update {
     StopWordsDeletion(BTreeSet<String>),
 }
 
-impl Update {
+impl UpdateData {
     pub fn update_type(&self) -> UpdateType {
         match self {
-            Update::ClearAll => UpdateType::ClearAll,
-            Update::Schema(schema) => UpdateType::Schema {
-                schema: schema.clone(),
-            },
-            Update::Customs(_) => UpdateType::Customs,
-            Update::DocumentsAddition(addition) => UpdateType::DocumentsAddition {
+            UpdateData::ClearAll => UpdateType::ClearAll,
+            UpdateData::Schema(_) => UpdateType::Schema,
+            UpdateData::Customs(_) => UpdateType::Customs,
+            UpdateData::DocumentsAddition(addition) => UpdateType::DocumentsAddition {
                 number: addition.len(),
             },
-            Update::DocumentsPartial(addition) => UpdateType::DocumentsPartial {
+            UpdateData::DocumentsPartial(addition) => UpdateType::DocumentsPartial {
                 number: addition.len(),
             },
-            Update::DocumentsDeletion(deletion) => UpdateType::DocumentsDeletion {
+            UpdateData::DocumentsDeletion(deletion) => UpdateType::DocumentsDeletion {
                 number: deletion.len(),
             },
-            Update::SynonymsAddition(addition) => UpdateType::SynonymsAddition {
+            UpdateData::SynonymsAddition(addition) => UpdateType::SynonymsAddition {
                 number: addition.len(),
             },
-            Update::SynonymsDeletion(deletion) => UpdateType::SynonymsDeletion {
+            UpdateData::SynonymsDeletion(deletion) => UpdateType::SynonymsDeletion {
                 number: deletion.len(),
             },
-            Update::StopWordsAddition(addition) => UpdateType::StopWordsAddition {
+            UpdateData::StopWordsAddition(addition) => UpdateType::StopWordsAddition {
                 number: addition.len(),
             },
-            Update::StopWordsDeletion(deletion) => UpdateType::StopWordsDeletion {
+            UpdateData::StopWordsDeletion(deletion) => UpdateType::StopWordsDeletion {
                 number: deletion.len(),
             },
         }
@@ -79,9 +157,10 @@ impl Update {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "name")]
 pub enum UpdateType {
     ClearAll,
-    Schema { schema: Schema },
+    Schema,
     Customs,
     DocumentsAddition { number: usize },
     DocumentsPartial { number: usize },
@@ -92,80 +171,88 @@ pub enum UpdateType {
     StopWordsDeletion { number: usize },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DetailedDuration {
-    pub main: Duration,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProcessedUpdateResult {
     pub update_id: u64,
+    #[serde(rename = "type")]
     pub update_type: UpdateType,
-    pub result: Result<(), String>,
-    pub detailed_duration: DetailedDuration,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+    pub duration: f64, // in seconds
+    pub enqueued_at: DateTime<Utc>,
+    pub processed_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EnqueuedUpdateResult {
     pub update_id: u64,
     pub update_type: UpdateType,
+    pub enqueued_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", tag = "status")]
 pub enum UpdateStatus {
-    Enqueued(EnqueuedUpdateResult),
-    Processed(ProcessedUpdateResult),
-    Unknown,
+    Enqueued {
+        #[serde(flatten)]
+        content: EnqueuedUpdateResult,
+    },
+    Processed {
+        #[serde(flatten)]
+        content: ProcessedUpdateResult,
+    },
 }
 
 pub fn update_status(
-    reader: &heed::RoTxn,
+    update_reader: &heed::RoTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     update_id: u64,
-) -> MResult<UpdateStatus> {
-    match updates_results_store.update_result(reader, update_id)? {
-        Some(result) => Ok(UpdateStatus::Processed(result)),
-        None => {
-            if let Some(update) = updates_store.get(reader, update_id)? {
-                Ok(UpdateStatus::Enqueued(EnqueuedUpdateResult {
+) -> MResult<Option<UpdateStatus>> {
+    match updates_results_store.update_result(update_reader, update_id)? {
+        Some(result) => Ok(Some(UpdateStatus::Processed { content: result })),
+        None => match updates_store.get(update_reader, update_id)? {
+            Some(update) => Ok(Some(UpdateStatus::Enqueued {
+                content: EnqueuedUpdateResult {
                     update_id,
-                    update_type: update.update_type(),
-                }))
-            } else {
-                Ok(UpdateStatus::Unknown)
-            }
-        }
+                    update_type: update.data.update_type(),
+                    enqueued_at: update.enqueued_at,
+                },
+            })),
+            None => Ok(None),
+        },
     }
 }
 
 pub fn next_update_id(
-    writer: &mut heed::RwTxn,
+    update_writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
 ) -> ZResult<u64> {
-    let last_update_id = updates_store.last_update_id(writer)?;
-    let last_update_id = last_update_id.map(|(n, _)| n);
+    let last_update = updates_store.last_update(update_writer)?;
+    let last_update = last_update.map(|(n, _)| n);
 
-    let last_update_results_id = updates_results_store.last_update_id(writer)?;
+    let last_update_results_id = updates_results_store.last_update(update_writer)?;
     let last_update_results_id = last_update_results_id.map(|(n, _)| n);
 
-    let max_update_id = cmp::max(last_update_id, last_update_results_id);
+    let max_update_id = cmp::max(last_update, last_update_results_id);
     let new_update_id = max_update_id.map_or(0, |n| n + 1);
 
     Ok(new_update_id)
 }
 
 pub fn update_task<'a, 'b>(
-    writer: &'a mut heed::RwTxn<'b>,
-    index: store::Index,
+    writer: &'a mut heed::RwTxn<'b, MainT>,
+    index: &store::Index,
     update_id: u64,
     update: Update,
 ) -> MResult<ProcessedUpdateResult> {
     debug!("Processing update number {}", update_id);
 
-    let (update_type, result, duration) = match update {
-        Update::ClearAll => {
+    let Update { enqueued_at, data } = update;
+
+    let (update_type, result, duration) = match data {
+        UpdateData::ClearAll => {
             let start = Instant::now();
 
             let update_type = UpdateType::ClearAll;
@@ -180,12 +267,10 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::Schema(schema) => {
+        UpdateData::Schema(schema) => {
             let start = Instant::now();
 
-            let update_type = UpdateType::Schema {
-                schema: schema.clone(),
-            };
+            let update_type = UpdateType::Schema;
             let result = apply_schema_update(
                 writer,
                 &schema,
@@ -198,7 +283,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::Customs(customs) => {
+        UpdateData::Customs(customs) => {
             let start = Instant::now();
 
             let update_type = UpdateType::Customs;
@@ -206,7 +291,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::DocumentsAddition(documents) => {
+        UpdateData::DocumentsAddition(documents) => {
             let start = Instant::now();
 
             let update_type = UpdateType::DocumentsAddition {
@@ -225,7 +310,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::DocumentsPartial(documents) => {
+        UpdateData::DocumentsPartial(documents) => {
             let start = Instant::now();
 
             let update_type = UpdateType::DocumentsPartial {
@@ -244,7 +329,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::DocumentsDeletion(documents) => {
+        UpdateData::DocumentsDeletion(documents) => {
             let start = Instant::now();
 
             let update_type = UpdateType::DocumentsDeletion {
@@ -263,7 +348,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::SynonymsAddition(synonyms) => {
+        UpdateData::SynonymsAddition(synonyms) => {
             let start = Instant::now();
 
             let update_type = UpdateType::SynonymsAddition {
@@ -274,7 +359,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::SynonymsDeletion(synonyms) => {
+        UpdateData::SynonymsDeletion(synonyms) => {
             let start = Instant::now();
 
             let update_type = UpdateType::SynonymsDeletion {
@@ -285,7 +370,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::StopWordsAddition(stop_words) => {
+        UpdateData::StopWordsAddition(stop_words) => {
             let start = Instant::now();
 
             let update_type = UpdateType::StopWordsAddition {
@@ -297,7 +382,7 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        Update::StopWordsDeletion(stop_words) => {
+        UpdateData::StopWordsDeletion(stop_words) => {
             let start = Instant::now();
 
             let update_type = UpdateType::StopWordsDeletion {
@@ -323,12 +408,13 @@ pub fn update_task<'a, 'b>(
         update_id, update_type, result
     );
 
-    let detailed_duration = DetailedDuration { main: duration };
     let status = ProcessedUpdateResult {
         update_id,
         update_type,
-        result: result.map_err(|e| e.to_string()),
-        detailed_duration,
+        error: result.map_err(|e| e.to_string()).err(),
+        duration: duration.as_secs_f64(),
+        enqueued_at,
+        processed_at: Utc::now(),
     };
 
     Ok(status)

meilisearch-core/src/update/schema_update.rs

@@ -1,11 +1,12 @@
-use meilidb_schema::{Diff, Schema};
+use meilisearch_schema::{Diff, Schema};
 
+use crate::database::{MainT, UpdateT};
 use crate::update::documents_addition::reindex_all_documents;
 use crate::update::{next_update_id, Update};
 use crate::{error::UnsupportedOperation, store, MResult};
 
 pub fn apply_schema_update(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     new_schema: &Schema,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
@@ -21,7 +22,7 @@ pub fn apply_schema_update(
     let mut need_full_reindexing = false;
 
     if let Some(old_schema) = main_store.schema(writer)? {
-        for diff in meilidb_schema::diff(&old_schema, new_schema) {
+        for diff in meilisearch_schema::diff(&old_schema, new_schema) {
             match diff {
                 Diff::IdentChange { .. } => return Err(CannotUpdateSchemaIdentifier.into()),
                 Diff::AttrMove { .. } => return Err(CannotReorderSchemaAttribute.into()),
@@ -61,14 +62,14 @@ pub fn apply_schema_update(
 }
 
 pub fn push_schema_update(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     schema: Schema,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::Schema(schema);
+    let update = Update::schema(schema);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)

meilisearch-core/src/update/stop_words_addition.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeSet;
 
 use fst::{set::OpBuilder, SetBuilder};
 
+use crate::database::{MainT, UpdateT};
 use crate::automaton::normalize_str;
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::update::{next_update_id, Update};
@@ -33,7 +34,7 @@ impl StopWordsAddition {
         self.stop_words.insert(stop_word);
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         let update_id = push_stop_words_addition(
             writer,
@@ -46,21 +47,21 @@ impl StopWordsAddition {
 }
 
 pub fn push_stop_words_addition(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     addition: BTreeSet<String>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::StopWordsAddition(addition);
+    let update = Update::stop_words_addition(addition);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_stop_words_addition(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     postings_lists_store: store::PostingsLists,
     addition: BTreeSet<String>,

meilisearch-core/src/update/stop_words_deletion.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeSet;
 
 use fst::{set::OpBuilder, SetBuilder};
 
+use crate::database::{MainT, UpdateT};
 use crate::automaton::normalize_str;
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::update::documents_addition::reindex_all_documents;
@@ -34,7 +35,7 @@ impl StopWordsDeletion {
         self.stop_words.insert(stop_word);
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         let update_id = push_stop_words_deletion(
             writer,
@@ -47,21 +48,21 @@ impl StopWordsDeletion {
 }
 
 pub fn push_stop_words_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     deletion: BTreeSet<String>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::StopWordsDeletion(deletion);
+    let update = Update::stop_words_deletion(deletion);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_stop_words_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     documents_fields_store: store::DocumentsFields,
     documents_fields_counts_store: store::DocumentsFieldsCounts,

meilisearch-core/src/update/synonyms_addition.rs

@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 use fst::{set::OpBuilder, SetBuilder};
 use sdset::SetBuf;
 
+use crate::database::{MainT, UpdateT};
 use crate::automaton::normalize_str;
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::update::{next_update_id, Update};
@@ -43,7 +44,7 @@ impl SynonymsAddition {
             .extend(alternatives);
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         let update_id = push_synonyms_addition(
             writer,
@@ -56,21 +57,21 @@ impl SynonymsAddition {
 }
 
 pub fn push_synonyms_addition(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     addition: BTreeMap<String, Vec<String>>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::SynonymsAddition(addition);
+    let update = Update::synonyms_addition(addition);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_synonyms_addition(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     synonyms_store: store::Synonyms,
     addition: BTreeMap<String, Vec<String>>,

meilisearch-core/src/update/synonyms_deletion.rs

@@ -4,6 +4,7 @@ use std::iter::FromIterator;
 use fst::{set::OpBuilder, SetBuilder};
 use sdset::SetBuf;
 
+use crate::database::{MainT, UpdateT};
 use crate::automaton::normalize_str;
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::update::{next_update_id, Update};
@@ -50,7 +51,7 @@ impl SynonymsDeletion {
         }
     }
 
-    pub fn finalize(self, writer: &mut heed::RwTxn) -> MResult<u64> {
+    pub fn finalize(self, writer: &mut heed::RwTxn<UpdateT>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
         let update_id = push_synonyms_deletion(
             writer,
@@ -63,21 +64,21 @@ impl SynonymsDeletion {
 }
 
 pub fn push_synonyms_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<UpdateT>,
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     deletion: BTreeMap<String, Option<Vec<String>>>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::SynonymsDeletion(deletion);
+    let update = Update::synonyms_deletion(deletion);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_synonyms_deletion(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     synonyms_store: store::Synonyms,
     deletion: BTreeMap<String, Option<Vec<String>>>,

meilisearch-http/Cargo.toml

@@ -1,39 +1,45 @@
 [package]
-name = "meilidb-http"
-version = "0.1.1"
+name = "meilisearch-http"
+version = "0.8.2"
 authors = [
     "Quentin de Quelen <quentin@dequelen.me>",
     "Clément Renault <clement@meilisearch.com>",
 ]
 edition = "2018"
 
+[[bin]]
+name = "meilisearch"
+path = "src/main.rs"
+
 [dependencies]
 bincode = "1.2.0"
 chrono = { version = "0.4.9", features = ["serde"] }
-crossbeam-channel = "0.3.9"
-envconfig = "0.5.1"
-envconfig_derive = "0.5.1"
-heed = "0.5.0"
+crossbeam-channel = "0.4.0"
+env_logger = "0.7.1"
+heed = "0.6.0"
 http = "0.1.19"
 indexmap = { version = "1.3.0", features = ["serde-1"] }
-jemallocator = "0.3.2"
 log = "0.4.8"
 main_error = "0.1.0"
-meilidb-core = { path = "../meilidb-core", version = "0.6.0" }
-meilidb-schema = { path = "../meilidb-schema", version = "0.6.0" }
+meilisearch-core = { path = "../meilisearch-core", version = "0.8.2" }
+meilisearch-schema = { path = "../meilisearch-schema", version = "0.8.2" }
 pretty-bytes = "0.2.2"
 rand = "0.7.2"
 rayon = "1.2.0"
 serde = { version = "1.0.101", features = ["derive"] }
 serde_json = { version = "1.0.41", features = ["preserve_order"] }
+serde_qs = "0.5.1"
+siphasher = "0.3.1"
 structopt = "0.3.3"
 sysinfo = "0.9.5"
+ureq = { version = "0.11.2", features = ["tls"], default-features = false }
 walkdir = "2.2.9"
+whoami = "0.6"
 
 [dependencies.async-compression]
 default-features = false
 features = ["stream", "gzip", "zlib", "brotli", "zstd"]
-version = "0.1.0-alpha.7"
+version = "=0.1.0-alpha.7"
 
 [dependencies.tide]
 git = "https://github.com/rustasync/tide"
@@ -53,3 +59,6 @@ rev = "e77709370bb24cf776fe6da902467c35131535b1"
 
 [build-dependencies]
 vergen = "3.0.4"
+
+[target.'cfg(unix)'.dependencies]
+jemallocator = "0.3.2"

meilisearch-http/src/analytics.rs

@@ -0,0 +1,69 @@
+use std::hash::{Hash, Hasher};
+use std::thread;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use log::error;
+use serde::Serialize;
+use serde_qs as qs;
+use siphasher::sip::SipHasher;
+
+const AMPLITUDE_API_KEY: &str = "f7fba398780e06d8fe6666a9be7e3d47";
+
+#[derive(Debug, Serialize)]
+struct Event<'a> {
+    user_id: &'a str,
+    event_type: &'a str,
+    device_id: &'a str,
+    time: u64,
+}
+
+#[derive(Debug, Serialize)]
+struct AmplitudeRequest<'a> {
+    api_key: &'a str,
+    event: &'a str,
+}
+
+pub fn analytics_sender() {
+    let username = whoami::username();
+    let hostname = whoami::hostname();
+    let platform = whoami::platform();
+
+    let uid = username + &hostname + &platform.to_string();
+
+    let mut hasher = SipHasher::new();
+    uid.hash(&mut hasher);
+    let hash = hasher.finish();
+
+    let uid = format!("{:X}", hash);
+    let platform = platform.to_string();
+
+    loop {
+        let n = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+        let user_id = &uid;
+        let device_id = &platform;
+        let time = n.as_secs();
+        let event_type = "runtime_tick";
+
+        let event = Event {
+            user_id,
+            event_type,
+            device_id,
+            time,
+        };
+        let event = serde_json::to_string(&event).unwrap();
+
+        let request = AmplitudeRequest {
+            api_key: AMPLITUDE_API_KEY,
+            event: &event,
+        };
+
+        let body = qs::to_string(&request).unwrap();
+        let response = ureq::post("https://api.amplitude.com/httpapi").send_string(&body);
+        if !response.ok() {
+            let body = response.into_string().unwrap();
+            error!("Unsuccessful call to Amplitude: {}", body);
+        }
+
+        thread::sleep(Duration::from_secs(86_400)) // one day
+    }
+}

meilisearch-http/src/data.rs

@@ -0,0 +1,129 @@
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::sync::Arc;
+
+use chrono::{DateTime, Utc};
+use heed::types::{SerdeBincode, Str};
+use log::error;
+use meilisearch_core::{Database, MainT, UpdateT, Error as MError, MResult};
+use sysinfo::Pid;
+
+use crate::option::Opt;
+use crate::routes::index::index_update_callback;
+
+const LAST_UPDATE_KEY: &str = "last-update";
+
+type SerdeDatetime = SerdeBincode<DateTime<Utc>>;
+
+#[derive(Clone)]
+pub struct Data {
+    inner: Arc<DataInner>,
+}
+
+impl Deref for Data {
+    type Target = DataInner;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+#[derive(Clone)]
+pub struct DataInner {
+    pub db: Arc<Database>,
+    pub db_path: String,
+    pub api_key: Option<String>,
+    pub server_pid: Pid,
+}
+
+impl DataInner {
+    pub fn is_indexing(&self, reader: &heed::RoTxn<UpdateT>, index: &str) -> MResult<Option<bool>> {
+        match self.db.open_index(&index) {
+            Some(index) => index.current_update_id(&reader).map(|u| Some(u.is_some())),
+            None => Ok(None),
+        }
+    }
+
+    pub fn last_update(&self, reader: &heed::RoTxn<MainT>) -> MResult<Option<DateTime<Utc>>> {
+        match self
+            .db
+            .common_store()
+            .get::<_, Str, SerdeDatetime>(reader, LAST_UPDATE_KEY)?
+        {
+            Some(datetime) => Ok(Some(datetime)),
+            None => Ok(None),
+        }
+    }
+
+    pub fn set_last_update(&self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
+        self.db
+            .common_store()
+            .put::<_, Str, SerdeDatetime>(writer, LAST_UPDATE_KEY, &Utc::now())
+            .map_err(Into::into)
+    }
+
+    pub fn compute_stats(&self, writer: &mut heed::RwTxn<MainT>, index_uid: &str) -> MResult<()> {
+        let index = match self.db.open_index(&index_uid) {
+            Some(index) => index,
+            None => {
+                error!("Impossible to retrieve index {}", index_uid);
+                return Ok(());
+            }
+        };
+
+        let schema = match index.main.schema(&writer)? {
+            Some(schema) => schema,
+            None => return Ok(()),
+        };
+
+        let all_documents_fields = index
+            .documents_fields_counts
+            .all_documents_fields_counts(&writer)?;
+
+        // count fields frequencies
+        let mut fields_frequency = HashMap::<_, usize>::new();
+        for result in all_documents_fields {
+            let (_, attr, _) = result?;
+            *fields_frequency.entry(attr).or_default() += 1;
+        }
+
+        // convert attributes to their names
+        let frequency: HashMap<_, _> = fields_frequency
+            .into_iter()
+            .map(|(a, c)| (schema.attribute_name(a).to_owned(), c))
+            .collect();
+
+        index
+            .main
+            .put_fields_frequency(writer, &frequency)
+            .map_err(MError::Zlmdb)
+    }
+}
+
+impl Data {
+    pub fn new(opt: Opt) -> Data {
+        let db_path = opt.db_path.clone();
+        let api_key = opt.api_key.clone();
+        let server_pid = sysinfo::get_current_pid().unwrap();
+
+        let db = Arc::new(Database::open_or_create(opt.db_path.clone()).unwrap());
+
+        let inner_data = DataInner {
+            db: db.clone(),
+            db_path,
+            api_key,
+            server_pid,
+        };
+
+        let data = Data {
+            inner: Arc::new(inner_data),
+        };
+
+        let callback_context = data.clone();
+        db.set_update_callback(Box::new(move |index_uid, status| {
+            index_update_callback(&index_uid, &callback_context, status);
+        }));
+
+        data
+    }
+}

meilisearch-http/src/error.rs

@@ -17,6 +17,7 @@ pub enum ResponseError {
     DocumentNotFound(String),
     MissingHeader(String),
     BadParameter(String, String),
+    OpenIndex(String),
     CreateIndex(String),
     Maintenance,
 }
@@ -54,6 +55,10 @@ impl ResponseError {
         ResponseError::BadParameter(name.to_string(), message.to_string())
     }
 
+    pub fn open_index(message: impl Display) -> ResponseError {
+        ResponseError::OpenIndex(message.to_string())
+    }
+
     pub fn create_index(message: impl Display) -> ResponseError {
         ResponseError::CreateIndex(message.to_string())
     }
@@ -96,6 +101,10 @@ impl IntoResponse for ResponseError {
                 format!("Impossible to create index; {}", err),
                 StatusCode::BAD_REQUEST,
             ),
+            ResponseError::OpenIndex(err) => error(
+                format!("Impossible to open index; {}", err),
+                StatusCode::BAD_REQUEST,
+            ),
             ResponseError::Maintenance => error(
                 String::from("Server is in maintenance, please try again later"),
                 StatusCode::SERVICE_UNAVAILABLE,

meilisearch-http/src/helpers/meilisearch.rs

@@ -1,10 +1,11 @@
 use crate::routes::setting::{RankingOrdering, SettingBody};
 use indexmap::IndexMap;
-use log::*;
-use meilidb_core::criterion::*;
-use meilidb_core::Highlight;
-use meilidb_core::{Index, RankedMap};
-use meilidb_schema::{Schema, SchemaAttr};
+use log::error;
+use meilisearch_core::criterion::*;
+use meilisearch_core::Highlight;
+use meilisearch_core::{Index, RankedMap};
+use meilisearch_core::MainT;
+use meilisearch_schema::{Schema, SchemaAttr};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::cmp::Ordering;
@@ -57,8 +58,8 @@ impl fmt::Display for Error {
     }
 }
 
-impl From<meilidb_core::Error> for Error {
-    fn from(error: meilidb_core::Error) -> Self {
+impl From<meilisearch_core::Error> for Error {
+    fn from(error: meilisearch_core::Error) -> Self {
         Error::Internal(error.to_string())
     }
 }
@@ -131,6 +132,12 @@ impl<'a> SearchBuilder<'a> {
         self
     }
 
+    pub fn add_attribute_to_search_in(&mut self, value: String) -> &SearchBuilder {
+        let attributes_to_search_in = self.attributes_to_search_in.get_or_insert(HashSet::new());
+        attributes_to_search_in.insert(value);
+        self
+    }
+
     pub fn attributes_to_highlight(&mut self, value: HashSet<String>) -> &SearchBuilder {
         self.attributes_to_highlight = Some(value);
         self
@@ -151,7 +158,7 @@ impl<'a> SearchBuilder<'a> {
         self
     }
 
-    pub fn search(&self, reader: &heed::RoTxn) -> Result<SearchResult, Error> {
+    pub fn search(&self, reader: &heed::RoTxn<MainT>) -> Result<SearchResult, Error> {
         let schema = self.index.main.schema(reader);
         let schema = schema.map_err(|e| Error::Internal(e.to_string()))?;
         let schema = match schema {
@@ -229,43 +236,35 @@ impl<'a> SearchBuilder<'a> {
                 }
                 fields = Some(set);
             }
-            let mut document: IndexMap<String, Value> = self
+
+            let document: IndexMap<String, Value> = self
                 .index
                 .document(reader, fields.as_ref(), doc.id)
                 .map_err(|e| Error::RetrieveDocument(doc.id.0, e.to_string()))?
                 .ok_or(Error::DocumentNotFound(doc.id.0))?;
 
+            let mut formatted = document.clone();
             let mut matches = doc.highlights.clone();
 
             // Crops fields if needed
-            if let Some(fields) = self.attributes_to_crop.clone() {
-                for (field, length) in fields {
-                    let _ = crop_document(&mut document, &mut matches, &schema, &field, length);
-                }
+            if let Some(fields) = &self.attributes_to_crop {
+                crop_document(&mut formatted, &mut matches, &schema, fields);
             }
 
             // Transform to readable matches
             let matches = calculate_matches(matches, self.attributes_to_retrieve.clone(), &schema);
 
             if !self.matches {
-                if let Some(attributes_to_highlight) = self.attributes_to_highlight.clone() {
-                    let highlights = calculate_highlights(
-                        document.clone(),
-                        matches.clone(),
-                        attributes_to_highlight,
-                    );
-                    for (key, value) in highlights {
-                        if let Some(content) = document.get_mut(&key) {
-                            *content = value;
-                        }
-                    }
+                if let Some(attributes_to_highlight) = &self.attributes_to_highlight {
+                    formatted = calculate_highlights(&formatted, &matches, attributes_to_highlight);
                 }
             }
 
             let matches_info = if self.matches { Some(matches) } else { None };
 
             let hit = SearchHit {
-                hit: document,
+                document,
+                formatted,
                 matches_info,
             };
 
@@ -287,7 +286,7 @@ impl<'a> SearchBuilder<'a> {
 
     pub fn get_criteria(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         ranked_map: &'a RankedMap,
         schema: &Schema,
     ) -> Result<Option<Criteria<'a>>, Error> {
@@ -382,7 +381,9 @@ pub type MatchesInfos = HashMap<String, Vec<MatchPosition>>;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SearchHit {
     #[serde(flatten)]
-    pub hit: IndexMap<String, Value>,
+    pub document: IndexMap<String, Value>,
+    #[serde(rename = "_formatted", skip_serializing_if = "IndexMap::is_empty")]
+    pub formatted: IndexMap<String, Value>,
     #[serde(rename = "_matchesInfo", skip_serializing_if = "Option::is_none")]
     pub matches_info: Option<MatchesInfos>,
 }
@@ -425,32 +426,31 @@ fn crop_document(
     document: &mut IndexMap<String, Value>,
     matches: &mut Vec<Highlight>,
     schema: &Schema,
-    field: &str,
-    length: usize,
-) -> Result<(), Error> {
+    fields: &HashMap<String, usize>,
+) {
     matches.sort_unstable_by_key(|m| (m.char_index, m.char_length));
 
-    let attribute = schema
-        .attribute(field)
-        .ok_or(Error::AttributeNotFoundOnSchema(field.to_string()))?;
-    let selected_matches = matches
-        .iter()
-        .filter(|m| SchemaAttr::new(m.attribute) == attribute)
-        .cloned();
-    let original_text = match document.get(field) {
-        Some(Value::String(text)) => text,
-        Some(_) => return Err(Error::CropFieldWrongType(field.to_string())),
-        None => return Err(Error::AttributeNotFoundOnDocument(field.to_string())),
-    };
-    let (cropped_text, cropped_matches) = crop_text(&original_text, selected_matches, length);
+    for (field, length) in fields {
+        let attribute = match schema.attribute(field) {
+            Some(attribute) => attribute,
+            None => continue,
+        };
 
-    document.insert(
-        field.to_string(),
-        serde_json::value::Value::String(cropped_text),
-    );
-    matches.retain(|m| SchemaAttr::new(m.attribute) != attribute);
-    matches.extend_from_slice(&cropped_matches);
-    Ok(())
+        let selected_matches = matches
+            .iter()
+            .filter(|m| SchemaAttr::new(m.attribute) == attribute)
+            .cloned();
+
+        if let Some(Value::String(ref mut original_text)) = document.get_mut(field) {
+            let (cropped_text, cropped_matches) =
+                crop_text(original_text, selected_matches, *length);
+
+            *original_text = cropped_text;
+
+            matches.retain(|m| SchemaAttr::new(m.attribute) != attribute);
+            matches.extend_from_slice(&cropped_matches);
+        }
+    }
 }
 
 fn calculate_matches(
@@ -490,13 +490,14 @@ fn calculate_matches(
 }
 
 fn calculate_highlights(
-    document: IndexMap<String, Value>,
-    matches: MatchesInfos,
-    attributes_to_highlight: HashSet<String>,
-) -> HighlightInfos {
-    let mut highlight_result: HashMap<String, Value> = HashMap::new();
+    document: &IndexMap<String, Value>,
+    matches: &MatchesInfos,
+    attributes_to_highlight: &HashSet<String>,
+) -> IndexMap<String, Value> {
+    let mut highlight_result = IndexMap::new();
+
     for (attribute, matches) in matches.iter() {
-        if attributes_to_highlight.contains("*") || attributes_to_highlight.contains(attribute) {
+        if attributes_to_highlight.contains(attribute) {
             if let Some(Value::String(value)) = document.get(attribute) {
                 let value: Vec<_> = value.chars().collect();
                 let mut highlighted_value = String::new();
@@ -521,6 +522,7 @@ fn calculate_highlights(
             };
         }
     }
+
     highlight_result
 }
 
@@ -537,9 +539,10 @@ mod tests {
 
         let document: IndexMap<String, Value> = serde_json::from_str(data).unwrap();
         let mut attributes_to_highlight = HashSet::new();
-        attributes_to_highlight.insert("*".to_string());
+        attributes_to_highlight.insert("title".to_string());
+        attributes_to_highlight.insert("description".to_string());
 
-        let mut matches: HashMap<String, Vec<MatchPosition>> = HashMap::new();
+        let mut matches = HashMap::new();
 
         let mut m = Vec::new();
         m.push(MatchPosition {
@@ -554,9 +557,9 @@ mod tests {
             length: 9,
         });
         matches.insert("description".to_string(), m);
-        let result = super::calculate_highlights(document, matches, attributes_to_highlight);
+        let result = super::calculate_highlights(&document, &matches, &attributes_to_highlight);
 
-        let mut result_expected = HashMap::new();
+        let mut result_expected = IndexMap::new();
         result_expected.insert(
             "title".to_string(),
             Value::String("<em>Fondation</em> (Isaac ASIMOV)".to_string()),

meilisearch-http/src/helpers/mod.rs

@@ -0,0 +1,2 @@
+pub mod meilisearch;
+pub mod tide;

meilisearch-http/src/helpers/tide.rs

@@ -3,7 +3,7 @@ use crate::models::token::*;
 use crate::Data;
 use chrono::Utc;
 use heed::types::{SerdeBincode, Str};
-use meilidb_core::Index;
+use meilisearch_core::Index;
 use serde_json::Value;
 use tide::Context;
 
@@ -17,30 +17,29 @@ pub trait ContextExt {
 
 impl ContextExt for Context<Data> {
     fn is_allowed(&self, acl: ACL) -> SResult<()> {
-        let admin_token = match &self.state().admin_token {
-            Some(admin_token) => admin_token,
+        let api_key = match &self.state().api_key {
+            Some(api_key) => api_key,
             None => return Ok(()),
         };
 
         let user_api_key = self.header("X-Meili-API-Key")?;
-        if user_api_key == *admin_token {
+        if user_api_key == *api_key {
             return Ok(());
         }
         let request_index: Option<String> = None; //self.param::<String>("index").ok();
 
         let db = &self.state().db;
-        let env = &db.env;
-        let reader = env.read_txn().map_err(ResponseError::internal)?;
+        let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
         let token_key = format!("{}{}", TOKEN_PREFIX_KEY, user_api_key);
 
         let token_config = db
             .common_store()
-            .get::<Str, SerdeBincode<Token>>(&reader, &token_key)
+            .get::<_, Str, SerdeBincode<Token>>(&reader, &token_key)
             .map_err(ResponseError::internal)?
-            .ok_or(ResponseError::not_found(format!(
-                "token key: {}",
-                token_key
+            .ok_or(ResponseError::invalid_token(format!(
+                "Api key does not exist: {}",
+                user_api_key
             )))?;
 
         if token_config.revoked {
@@ -93,12 +92,12 @@ impl ContextExt for Context<Data> {
     }
 
     fn index(&self) -> Result<Index, ResponseError> {
-        let index_name = self.url_param("index")?;
+        let index_uid = self.url_param("index")?;
         let index = self
             .state()
             .db
-            .open_index(&index_name)
-            .ok_or(ResponseError::index_not_found(index_name))?;
+            .open_index(&index_uid)
+            .ok_or(ResponseError::index_not_found(index_uid))?;
         Ok(index)
     }
 
@@ -106,7 +105,7 @@ impl ContextExt for Context<Data> {
         let name = self
             .param::<Value>("identifier")
             .as_ref()
-            .map(meilidb_core::serde::value_to_string)
+            .map(meilisearch_core::serde::value_to_string)
             .map_err(|e| ResponseError::bad_parameter("identifier", e))?
             .ok_or(ResponseError::bad_parameter(
                 "identifier",

meilisearch-http/src/lib.rs

@@ -1,6 +1,3 @@
-#[macro_use]
-extern crate envconfig_derive;
-
 pub mod data;
 pub mod error;
 pub mod helpers;
@@ -8,4 +5,4 @@ pub mod models;
 pub mod option;
 pub mod routes;
 
-use self::data::Data;
+pub use self::data::Data;

meilisearch-http/src/main.rs

@@ -1,21 +1,39 @@
+use std::env::VarError::NotPresent;
+use std::{env, thread};
+
 use http::header::HeaderValue;
 use log::info;
 use main_error::MainError;
+use structopt::StructOpt;
 use tide::middleware::{CorsMiddleware, CorsOrigin};
 use tide_log::RequestLogger;
 
-use meilidb_http::data::Data;
-use meilidb_http::option::Opt;
-use meilidb_http::routes;
+use meilisearch_http::data::Data;
+use meilisearch_http::option::Opt;
+use meilisearch_http::routes;
+use meilisearch_http::routes::index::index_update_callback;
 
-#[cfg(not(target_os = "macos"))]
+mod analytics;
+
+#[cfg(target_os = "linux")]
 #[global_allocator]
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
 pub fn main() -> Result<(), MainError> {
-    let opt = Opt::new();
+    env_logger::init();
 
+    let opt = Opt::from_args();
     let data = Data::new(opt.clone());
+
+    if env::var("MEILI_NO_ANALYTICS") == Err(NotPresent) {
+        thread::spawn(|| analytics::analytics_sender());
+    }
+
+    let data_cloned = data.clone();
+    data.db.set_update_callback(Box::new(move |name, status| {
+        index_update_callback(name, &data_cloned, status);
+    }));
+
     let mut app = tide::App::with_state(data);
 
     app.middleware(

meilisearch-http/src/models/schema.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use indexmap::IndexMap;
-use meilidb_schema::{Schema, SchemaBuilder, SchemaProps};
+use meilisearch_schema::{Schema, SchemaBuilder, SchemaProps};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]

meilisearch-http/src/option.rs

@@ -0,0 +1,20 @@
+use structopt::StructOpt;
+
+#[derive(Debug, Clone, StructOpt)]
+pub struct Opt {
+    /// The destination where the database must be created.
+    #[structopt(long, env = "MEILI_DB_PATH", default_value = "/tmp/meilisearch")]
+    pub db_path: String,
+
+    /// The address on which the http server will listen.
+    #[structopt(long, env = "MEILI_HTTP_ADDR", default_value = "127.0.0.1:8080")]
+    pub http_addr: String,
+
+    /// The master key allowing you to do everything on the server.
+    #[structopt(long, env = "MEILI_API_KEY")]
+    pub api_key: Option<String>,
+
+    /// Do not send analytics to Meili.
+    #[structopt(long, env = "MEILI_NO_ANALYTICS")]
+    pub no_analytics: bool,
+}

meilisearch-http/src/routes/document.rs

@@ -19,10 +19,10 @@ pub async fn get_document(ctx: Context<Data>) -> SResult<Response> {
     let index = ctx.index()?;
 
     let identifier = ctx.identifier()?;
-    let document_id = meilidb_core::serde::compute_document_id(identifier.clone());
+    let document_id = meilisearch_core::serde::compute_document_id(identifier.clone());
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let response = index
         .document::<IndexMap<String, Value>>(&reader, None, document_id)
@@ -45,24 +45,20 @@ pub struct IndexUpdateResponse {
 pub async fn delete_document(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(DocumentsWrite)?;
 
-    if !ctx.state().accept_updates() {
-        return Err(ResponseError::Maintenance);
-    }
-
     let index = ctx.index()?;
     let identifier = ctx.identifier()?;
-    let document_id = meilidb_core::serde::compute_document_id(identifier.clone());
+    let document_id = meilisearch_core::serde::compute_document_id(identifier.clone());
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut update_writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut documents_deletion = index.documents_deletion();
     documents_deletion.delete_document_by_id(document_id);
     let update_id = documents_deletion
-        .finalize(&mut writer)
+        .finalize(&mut update_writer)
         .map_err(ResponseError::internal)?;
 
-    writer.commit().map_err(ResponseError::internal)?;
+    update_writer.commit().map_err(ResponseError::internal)?;
 
     let response_body = IndexUpdateResponse { update_id };
     Ok(tide::response::json(response_body)
@@ -78,7 +74,7 @@ struct BrowseQuery {
     attributes_to_retrieve: Option<String>,
 }
 
-pub async fn browse_documents(ctx: Context<Data>) -> SResult<Response> {
+pub async fn get_all_documents(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(DocumentsRead)?;
 
     let index = ctx.index()?;
@@ -87,8 +83,8 @@ pub async fn browse_documents(ctx: Context<Data>) -> SResult<Response> {
     let offset = query.offset.unwrap_or(0);
     let limit = query.limit.unwrap_or(20);
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let documents_ids: Result<BTreeSet<_>, _> =
         match index.documents_fields_counts.documents_ids(&reader) {
@@ -118,19 +114,11 @@ pub async fn browse_documents(ctx: Context<Data>) -> SResult<Response> {
         }
     }
 
-    if response_body.is_empty() {
-        Ok(tide::response::json(response_body)
-            .with_status(StatusCode::NO_CONTENT)
-            .into_response())
-    } else {
-        Ok(tide::response::json(response_body)
-            .with_status(StatusCode::OK)
-            .into_response())
-    }
+    Ok(tide::response::json(response_body))
 }
 
-fn infered_schema(document: &IndexMap<String, Value>) -> Option<meilidb_schema::Schema> {
-    use meilidb_schema::{SchemaBuilder, DISPLAYED, INDEXED};
+fn infered_schema(document: &IndexMap<String, Value>) -> Option<meilisearch_schema::Schema> {
+    use meilisearch_schema::{SchemaBuilder, DISPLAYED, INDEXED};
 
     let mut identifier = None;
     for key in document.keys() {
@@ -154,25 +142,23 @@ fn infered_schema(document: &IndexMap<String, Value>) -> Option<meilidb_schema::
 async fn update_multiple_documents(mut ctx: Context<Data>, is_partial: bool) -> SResult<Response> {
     ctx.is_allowed(DocumentsWrite)?;
 
-    if !ctx.state().accept_updates() {
-        return Err(ResponseError::Maintenance);
-    }
     let data: Vec<IndexMap<String, Value>> =
         ctx.body_json().await.map_err(ResponseError::bad_request)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+    let mut update_writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let current_schema = index
         .main
-        .schema(&writer)
+        .schema(&reader)
         .map_err(ResponseError::internal)?;
     if current_schema.is_none() {
         match data.first().and_then(infered_schema) {
             Some(schema) => {
                 index
-                    .schema_update(&mut writer, schema)
+                    .schema_update(&mut update_writer, schema)
                     .map_err(ResponseError::internal)?;
             }
             None => return Err(ResponseError::bad_request("Could not infer a schema")),
@@ -190,10 +176,10 @@ async fn update_multiple_documents(mut ctx: Context<Data>, is_partial: bool) ->
     }
 
     let update_id = document_addition
-        .finalize(&mut writer)
+        .finalize(&mut update_writer)
         .map_err(ResponseError::internal)?;
 
-    writer.commit().map_err(ResponseError::internal)?;
+    update_writer.commit().map_err(ResponseError::internal)?;
 
     let response_body = IndexUpdateResponse { update_id };
     Ok(tide::response::json(response_body)
@@ -211,21 +197,19 @@ pub async fn add_or_update_multiple_documents(ctx: Context<Data>) -> SResult<Res
 
 pub async fn delete_multiple_documents(mut ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(DocumentsWrite)?;
-    if !ctx.state().accept_updates() {
-        return Err(ResponseError::Maintenance);
-    }
+
     let data: Vec<Value> = ctx.body_json().await.map_err(ResponseError::bad_request)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut documents_deletion = index.documents_deletion();
 
     for identifier in data {
-        if let Some(identifier) = meilidb_core::serde::value_to_string(&identifier) {
+        if let Some(identifier) = meilisearch_core::serde::value_to_string(&identifier) {
             documents_deletion
-                .delete_document_by_id(meilidb_core::serde::compute_document_id(identifier));
+                .delete_document_by_id(meilisearch_core::serde::compute_document_id(identifier));
         }
     }
 
@@ -243,13 +227,12 @@ pub async fn delete_multiple_documents(mut ctx: Context<Data>) -> SResult<Respon
 
 pub async fn clear_all_documents(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(DocumentsWrite)?;
-    if !ctx.state().accept_updates() {
-        return Err(ResponseError::Maintenance);
-    }
+
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
+
     let update_id = index
         .clear_all(&mut writer)
         .map_err(ResponseError::internal)?;

meilisearch-http/src/routes/health.rs

@@ -11,12 +11,11 @@ const UNHEALTHY_KEY: &str = "_is_unhealthy";
 
 pub async fn get_health(ctx: Context<Data>) -> SResult<()> {
     let db = &ctx.state().db;
-    let env = &db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let common_store = ctx.state().db.common_store();
 
-    if let Ok(Some(_)) = common_store.get::<Str, Unit>(&reader, UNHEALTHY_KEY) {
+    if let Ok(Some(_)) = common_store.get::<_, Str, Unit>(&reader, UNHEALTHY_KEY) {
         return Err(ResponseError::Maintenance);
     }
 
@@ -27,11 +26,10 @@ pub async fn set_healthy(ctx: Context<Data>) -> SResult<()> {
     ctx.is_allowed(Admin)?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
 
     let common_store = ctx.state().db.common_store();
-    match common_store.delete::<Str>(&mut writer, UNHEALTHY_KEY) {
+    match common_store.delete::<_, Str>(&mut writer, UNHEALTHY_KEY) {
         Ok(_) => (),
         Err(e) => return Err(ResponseError::internal(e)),
     }
@@ -47,12 +45,11 @@ pub async fn set_unhealthy(ctx: Context<Data>) -> SResult<()> {
     ctx.is_allowed(Admin)?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
 
     let common_store = ctx.state().db.common_store();
 
-    if let Err(e) = common_store.put::<Str, Unit>(&mut writer, UNHEALTHY_KEY, &()) {
+    if let Err(e) = common_store.put::<_, Str, Unit>(&mut writer, UNHEALTHY_KEY, &()) {
         return Err(ResponseError::internal(e));
     }
 

meilisearch-http/src/routes/index.rs

@@ -0,0 +1,439 @@
+use chrono::{DateTime, Utc};
+use http::StatusCode;
+use log::error;
+use meilisearch_core::ProcessedUpdateResult;
+use meilisearch_schema::{Schema, SchemaBuilder};
+use rand::seq::SliceRandom;
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use tide::querystring::ContextExt as QSContextExt;
+use tide::response::IntoResponse;
+use tide::{Context, Response};
+
+use crate::error::{ResponseError, SResult};
+use crate::helpers::tide::ContextExt;
+use crate::models::schema::SchemaBody;
+use crate::models::token::ACL::*;
+use crate::routes::document::IndexUpdateResponse;
+use crate::Data;
+
+fn generate_uid() -> String {
+    let mut rng = rand::thread_rng();
+    let sample = b"abcdefghijklmnopqrstuvwxyz0123456789";
+    sample
+        .choose_multiple(&mut rng, 8)
+        .map(|c| *c as char)
+        .collect()
+}
+
+pub async fn list_indexes(ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesRead)?;
+
+    let indexes_uids = ctx.state().db.indexes_uids();
+
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+
+    let mut response_body = Vec::new();
+
+    for index_uid in indexes_uids {
+        let index = ctx.state().db.open_index(&index_uid);
+
+        match index {
+            Some(index) => {
+                let name = index
+                    .main
+                    .name(&reader)
+                    .map_err(ResponseError::internal)?
+                    .ok_or(ResponseError::internal("'name' not found"))?;
+                let created_at = index
+                    .main
+                    .created_at(&reader)
+                    .map_err(ResponseError::internal)?
+                    .ok_or(ResponseError::internal("'created_at' date not found"))?;
+                let updated_at = index
+                    .main
+                    .updated_at(&reader)
+                    .map_err(ResponseError::internal)?
+                    .ok_or(ResponseError::internal("'updated_at' date not found"))?;
+
+                let index_reponse = IndexResponse {
+                    name,
+                    uid: index_uid,
+                    created_at,
+                    updated_at,
+                };
+                response_body.push(index_reponse);
+            }
+            None => error!(
+                "Index {} is referenced in the indexes list but cannot be found",
+                index_uid
+            ),
+        }
+    }
+
+    Ok(tide::response::json(response_body))
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct IndexResponse {
+    name: String,
+    uid: String,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+pub async fn get_index(ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesRead)?;
+
+    let index = ctx.index()?;
+
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+
+    let uid = ctx.url_param("index")?;
+    let name = index
+        .main
+        .name(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::internal("'name' not found"))?;
+    let created_at = index
+        .main
+        .created_at(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::internal("'created_at' date not found"))?;
+    let updated_at = index
+        .main
+        .updated_at(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::internal("'updated_at' date not found"))?;
+
+    let response_body = IndexResponse {
+        name,
+        uid,
+        created_at,
+        updated_at,
+    };
+
+    Ok(tide::response::json(response_body))
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct IndexCreateRequest {
+    name: String,
+    uid: Option<String>,
+    schema: Option<SchemaBody>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct IndexCreateResponse {
+    name: String,
+    uid: String,
+    schema: Option<SchemaBody>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    update_id: Option<u64>,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+pub async fn create_index(mut ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesWrite)?;
+
+    let body = ctx
+        .body_json::<IndexCreateRequest>()
+        .await
+        .map_err(ResponseError::bad_request)?;
+
+    let db = &ctx.state().db;
+
+    let uid = match body.uid {
+        Some(uid) => uid,
+        None => loop {
+            let uid = generate_uid();
+            if db.open_index(&uid).is_none() {
+                break uid;
+            }
+        },
+    };
+
+    let created_index = match db.create_index(&uid) {
+        Ok(index) => index,
+        Err(e) => return Err(ResponseError::create_index(e)),
+    };
+
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
+    let mut update_writer = db.update_write_txn().map_err(ResponseError::internal)?;
+
+    created_index
+        .main
+        .put_name(&mut writer, &body.name)
+        .map_err(ResponseError::internal)?;
+    created_index
+        .main
+        .put_created_at(&mut writer)
+        .map_err(ResponseError::internal)?;
+    created_index
+        .main
+        .put_updated_at(&mut writer)
+        .map_err(ResponseError::internal)?;
+
+    let schema: Option<Schema> = body.schema.clone().map(Into::into);
+    let mut response_update_id = None;
+    if let Some(schema) = schema {
+        let update_id = created_index
+            .schema_update(&mut update_writer, schema)
+            .map_err(ResponseError::internal)?;
+        response_update_id = Some(update_id)
+    }
+
+    writer.commit().map_err(ResponseError::internal)?;
+    update_writer.commit().map_err(ResponseError::internal)?;
+
+    let response_body = IndexCreateResponse {
+        name: body.name,
+        uid,
+        schema: body.schema,
+        update_id: response_update_id,
+        created_at: Utc::now(),
+        updated_at: Utc::now(),
+    };
+
+    Ok(tide::response::json(response_body)
+        .with_status(StatusCode::CREATED)
+        .into_response())
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct UpdateIndexRequest {
+    name: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct UpdateIndexResponse {
+    name: String,
+    uid: String,
+    created_at: DateTime<Utc>,
+    updated_at: DateTime<Utc>,
+}
+
+pub async fn update_index(mut ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesWrite)?;
+
+    let body = ctx
+        .body_json::<UpdateIndexRequest>()
+        .await
+        .map_err(ResponseError::bad_request)?;
+
+    let index_uid = ctx.url_param("index")?;
+    let index = ctx.index()?;
+
+    let db = &ctx.state().db;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
+
+    index
+        .main
+        .put_name(&mut writer, &body.name)
+        .map_err(ResponseError::internal)?;
+
+    index
+        .main
+        .put_updated_at(&mut writer)
+        .map_err(ResponseError::internal)?;
+
+    writer.commit().map_err(ResponseError::internal)?;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+
+    let created_at = index
+        .main
+        .created_at(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::internal("'created_at' date not found"))?;
+    let updated_at = index
+        .main
+        .updated_at(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::internal("'updated_at' date not found"))?;
+
+    let response_body = UpdateIndexResponse {
+        name: body.name,
+        uid: index_uid,
+        created_at,
+        updated_at,
+    };
+
+    Ok(tide::response::json(response_body)
+        .with_status(StatusCode::ACCEPTED)
+        .into_response())
+}
+
+#[derive(Default, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct SchemaParams {
+    raw: bool,
+}
+
+pub async fn get_index_schema(ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesRead)?;
+
+    let index = ctx.index()?;
+
+    // Tide doesn't support "no query param"
+    let params: SchemaParams = ctx.url_query().unwrap_or_default();
+
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+
+    let schema = index
+        .main
+        .schema(&reader)
+        .map_err(ResponseError::open_index)?;
+
+    match schema {
+        Some(schema) => {
+            if params.raw {
+                Ok(tide::response::json(schema))
+            } else {
+                Ok(tide::response::json(SchemaBody::from(schema)))
+            }
+        }
+        None => Err(ResponseError::not_found("missing index schema")),
+    }
+}
+
+pub async fn update_schema(mut ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesWrite)?;
+
+    let index_uid = ctx.url_param("index")?;
+
+    let params: SchemaParams = ctx.url_query().unwrap_or_default();
+
+    let schema = if params.raw {
+        ctx.body_json::<SchemaBuilder>()
+            .await
+            .map_err(ResponseError::bad_request)?
+            .build()
+    } else {
+        ctx.body_json::<SchemaBody>()
+            .await
+            .map_err(ResponseError::bad_request)?
+            .into()
+    };
+
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
+
+    let index = db
+        .open_index(&index_uid)
+        .ok_or(ResponseError::index_not_found(index_uid))?;
+
+    let update_id = index
+        .schema_update(&mut writer, schema.clone())
+        .map_err(ResponseError::internal)?;
+
+    writer.commit().map_err(ResponseError::internal)?;
+
+    let response_body = IndexUpdateResponse { update_id };
+    Ok(tide::response::json(response_body)
+        .with_status(StatusCode::ACCEPTED)
+        .into_response())
+}
+
+pub async fn get_update_status(ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesRead)?;
+
+    let db = &ctx.state().db;
+    let reader = db.update_read_txn().map_err(ResponseError::internal)?;
+
+    let update_id = ctx
+        .param::<u64>("update_id")
+        .map_err(|e| ResponseError::bad_parameter("update_id", e))?;
+
+    let index = ctx.index()?;
+    let status = index
+        .update_status(&reader, update_id)
+        .map_err(ResponseError::internal)?;
+
+    let response = match status {
+        Some(status) => tide::response::json(status)
+            .with_status(StatusCode::OK)
+            .into_response(),
+        None => tide::response::json(json!({ "message": "unknown update id" }))
+            .with_status(StatusCode::NOT_FOUND)
+            .into_response(),
+    };
+
+    Ok(response)
+}
+
+pub async fn get_all_updates_status(ctx: Context<Data>) -> SResult<Response> {
+    ctx.is_allowed(IndexesRead)?;
+
+    let db = &ctx.state().db;
+    let reader = db.update_read_txn().map_err(ResponseError::internal)?;
+
+    let index = ctx.index()?;
+    let all_status = index
+        .all_updates_status(&reader)
+        .map_err(ResponseError::internal)?;
+
+    let response = tide::response::json(all_status)
+        .with_status(StatusCode::OK)
+        .into_response();
+
+    Ok(response)
+}
+
+pub async fn delete_index(ctx: Context<Data>) -> SResult<StatusCode> {
+    ctx.is_allowed(IndexesWrite)?;
+    let index_uid = ctx.url_param("index")?;
+
+    let found = ctx
+        .state()
+        .db
+        .delete_index(&index_uid)
+        .map_err(ResponseError::internal)?;
+
+    if found {
+        Ok(StatusCode::NO_CONTENT)
+    } else {
+        Ok(StatusCode::NOT_FOUND)
+    }
+}
+
+pub fn index_update_callback(index_uid: &str, data: &Data, status: ProcessedUpdateResult) {
+    if status.error.is_some() {
+        return;
+    }
+
+    if let Some(index) = data.db.open_index(&index_uid) {
+        let db = &data.db;
+        let mut writer = match db.main_write_txn() {
+            Ok(writer) => writer,
+            Err(e) => {
+                error!("Impossible to get write_txn; {}", e);
+                return;
+            }
+        };
+
+        if let Err(e) = data.compute_stats(&mut writer, &index_uid) {
+            error!("Impossible to compute stats; {}", e)
+        }
+
+        if let Err(e) = data.set_last_update(&mut writer) {
+            error!("Impossible to update last_update; {}", e)
+        }
+
+        if let Err(e) = index.main.put_updated_at(&mut writer) {
+            error!("Impossible to update updated_at; {}", e)
+        }
+
+        if let Err(e) = writer.commit() {
+            error!("Impossible to get write_txn; {}", e);
+        }
+    }
+}

meilisearch-http/src/routes/key.rs

@@ -26,15 +26,14 @@ pub async fn list(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(Admin)?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let common_store = db.common_store();
 
     let mut response: Vec<Token> = Vec::new();
 
     let iter = common_store
-        .prefix_iter::<Str, SerdeBincode<Token>>(&reader, TOKEN_PREFIX_KEY)
+        .prefix_iter::<_, Str, SerdeBincode<Token>>(&reader, TOKEN_PREFIX_KEY)
         .map_err(ResponseError::internal)?;
 
     for result in iter {
@@ -50,14 +49,13 @@ pub async fn get(ctx: Context<Data>) -> SResult<Response> {
     let request_key = ctx.url_param("key")?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let token_key = format!("{}{}", TOKEN_PREFIX_KEY, request_key);
 
     let token_config = db
         .common_store()
-        .get::<Str, SerdeBincode<Token>>(&reader, &token_key)
+        .get::<_, Str, SerdeBincode<Token>>(&reader, &token_key)
         .map_err(ResponseError::internal)?
         .ok_or(ResponseError::not_found(format!(
             "token key: {}",
@@ -97,11 +95,10 @@ pub async fn create(mut ctx: Context<Data>) -> SResult<Response> {
     };
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
 
     db.common_store()
-        .put::<Str, SerdeBincode<Token>>(&mut writer, &token_key, &token_definition)
+        .put::<_, Str, SerdeBincode<Token>>(&mut writer, &token_key, &token_definition)
         .map_err(ResponseError::internal)?;
 
     writer.commit().map_err(ResponseError::internal)?;
@@ -117,6 +114,8 @@ pub struct UpdatedRequest {
     description: Option<String>,
     acl: Option<Vec<ACL>>,
     indexes: Option<Vec<Wildcard>>,
+    expires_at: Option<DateTime<Utc>>,
+    revoked: Option<bool>,
 }
 
 pub async fn update(mut ctx: Context<Data>) -> SResult<Response> {
@@ -126,15 +125,14 @@ pub async fn update(mut ctx: Context<Data>) -> SResult<Response> {
     let data: UpdatedRequest = ctx.body_json().await.map_err(ResponseError::bad_request)?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
 
     let common_store = db.common_store();
 
     let token_key = format!("{}{}", TOKEN_PREFIX_KEY, request_key);
 
     let mut token_config = common_store
-        .get::<Str, SerdeBincode<Token>>(&writer, &token_key)
+        .get::<_, Str, SerdeBincode<Token>>(&writer, &token_key)
         .map_err(ResponseError::internal)?
         .ok_or(ResponseError::not_found(format!(
             "token key: {}",
@@ -154,16 +152,24 @@ pub async fn update(mut ctx: Context<Data>) -> SResult<Response> {
         token_config.indexes = indexes;
     }
 
+    if let Some(expires_at) = data.expires_at {
+        token_config.expires_at = expires_at;
+    }
+
+    if let Some(revoked) = data.revoked {
+        token_config.revoked = revoked;
+    }
+
     token_config.updated_at = Utc::now();
 
     common_store
-        .put::<Str, SerdeBincode<Token>>(&mut writer, &token_key, &token_config)
+        .put::<_, Str, SerdeBincode<Token>>(&mut writer, &token_key, &token_config)
         .map_err(ResponseError::internal)?;
 
     writer.commit().map_err(ResponseError::internal)?;
 
     Ok(tide::response::json(token_config)
-        .with_status(StatusCode::ACCEPTED)
+        .with_status(StatusCode::OK)
         .into_response())
 }
 
@@ -172,18 +178,17 @@ pub async fn delete(ctx: Context<Data>) -> SResult<StatusCode> {
     let request_key = ctx.url_param("key")?;
 
     let db = &ctx.state().db;
-    let env = &db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.main_write_txn().map_err(ResponseError::internal)?;
 
     let common_store = db.common_store();
 
     let token_key = format!("{}{}", TOKEN_PREFIX_KEY, request_key);
 
     common_store
-        .delete::<Str>(&mut writer, &token_key)
+        .delete::<_, Str>(&mut writer, &token_key)
         .map_err(ResponseError::internal)?;
 
     writer.commit().map_err(ResponseError::internal)?;
 
-    Ok(StatusCode::ACCEPTED)
+    Ok(StatusCode::NO_CONTENT)
 }

meilisearch-http/src/routes/mod.rs

@@ -13,7 +13,10 @@ pub mod synonym;
 pub fn load_routes(app: &mut tide::App<Data>) {
     app.at("").nest(|router| {
         router.at("/indexes").nest(|router| {
-            router.at("/").get(index::list_indexes);
+            router
+                .at("/")
+                .get(index::list_indexes)
+                .post(index::create_index);
 
             router.at("/search").post(search::search_multi_index);
 
@@ -28,15 +31,19 @@ pub fn load_routes(app: &mut tide::App<Data>) {
 
                 router
                     .at("/")
-                    .get(index::get_index_schema)
-                    .post(index::create_index)
-                    .put(index::update_schema)
+                    .get(index::get_index)
+                    .put(index::update_index)
                     .delete(index::delete_index);
 
+                router
+                    .at("/schema")
+                    .get(index::get_index_schema)
+                    .put(index::update_schema);
+
                 router.at("/documents").nest(|router| {
                     router
                         .at("/")
-                        .get(document::browse_documents)
+                        .get(document::get_all_documents)
                         .post(document::add_or_replace_multiple_documents)
                         .put(document::add_or_update_multiple_documents)
                         .delete(document::clear_all_documents);
@@ -53,8 +60,12 @@ pub fn load_routes(app: &mut tide::App<Data>) {
                         .post(document::delete_multiple_documents);
                 });
 
-                router.at("/synonym").nest(|router| {
-                    router.at("/").get(synonym::list).post(synonym::create);
+                router.at("/synonyms").nest(|router| {
+                    router
+                        .at("/")
+                        .get(synonym::list)
+                        .post(synonym::create)
+                        .delete(synonym::clear);
 
                     router
                         .at("/:synonym")
@@ -63,14 +74,13 @@ pub fn load_routes(app: &mut tide::App<Data>) {
                         .delete(synonym::delete);
 
                     router.at("/batch").post(synonym::batch_write);
-                    router.at("/clear").post(synonym::clear);
                 });
 
                 router.at("/stop-words").nest(|router| {
                     router
                         .at("/")
                         .get(stop_words::list)
-                        .put(stop_words::add)
+                        .patch(stop_words::add)
                         .delete(stop_words::delete);
                 });
 

meilisearch-http/src/routes/search.rs

@@ -2,14 +2,14 @@ use std::collections::HashMap;
 use std::collections::HashSet;
 use std::time::Duration;
 
-use meilidb_core::Index;
+use meilisearch_core::Index;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use serde::{Deserialize, Serialize};
 use tide::querystring::ContextExt as QSContextExt;
 use tide::{Context, Response};
 
 use crate::error::{ResponseError, SResult};
-use crate::helpers::meilidb::{Error, IndexSearchExt, SearchHit};
+use crate::helpers::meilisearch::{Error, IndexSearchExt, SearchHit};
 use crate::helpers::tide::ContextExt;
 use crate::Data;
 
@@ -33,8 +33,14 @@ pub async fn search_with_url_query(ctx: Context<Data>) -> SResult<Response> {
     // ctx.is_allowed(DocumentsRead)?;
 
     let index = ctx.index()?;
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+
+    let schema = index
+        .main
+        .schema(&reader)
+        .map_err(ResponseError::internal)?
+        .ok_or(ResponseError::open_index("No Schema found"))?;
 
     let query: SearchQuery = ctx
         .url_query()
@@ -56,23 +62,36 @@ pub async fn search_with_url_query(ctx: Context<Data>) -> SResult<Response> {
     }
     if let Some(attributes_to_search_in) = query.attributes_to_search_in {
         for attr in attributes_to_search_in.split(',') {
-            search_builder.add_retrievable_field(attr.to_string());
+            search_builder.add_attribute_to_search_in(attr.to_string());
         }
     }
     if let Some(attributes_to_crop) = query.attributes_to_crop {
         let crop_length = query.crop_length.unwrap_or(200);
-        let attributes_to_crop = attributes_to_crop
-            .split(',')
-            .map(|r| (r.to_string(), crop_length))
-            .collect();
-        search_builder.attributes_to_crop(attributes_to_crop);
+        if attributes_to_crop == "*" {
+            let attributes_to_crop = schema
+                .iter()
+                .map(|(attr, ..)| (attr.to_string(), crop_length))
+                .collect();
+            search_builder.attributes_to_crop(attributes_to_crop);
+        } else {
+            let attributes_to_crop = attributes_to_crop
+                .split(',')
+                .map(|r| (r.to_string(), crop_length))
+                .collect();
+            search_builder.attributes_to_crop(attributes_to_crop);
+        }
     }
 
     if let Some(attributes_to_highlight) = query.attributes_to_highlight {
-        let attributes_to_highlight = attributes_to_highlight
-            .split(',')
-            .map(ToString::to_string)
-            .collect();
+        let attributes_to_highlight = if attributes_to_highlight == "*" {
+            schema.iter().map(|(attr, ..)| attr.to_string()).collect()
+        } else {
+            attributes_to_highlight
+                .split(',')
+                .map(ToString::to_string)
+                .collect()
+        };
+
         search_builder.attributes_to_highlight(attributes_to_highlight);
     }
 
@@ -136,13 +155,8 @@ pub async fn search_multi_index(mut ctx: Context<Data>) -> SResult<Response> {
 
     for index in index_list.clone() {
         if index == "*" {
-            index_list = ctx
-                .state()
-                .db
-                .indexes_names()
-                .map_err(ResponseError::internal)?
-                .into_iter()
-                .collect();
+            index_list = ctx.state().db.indexes_uids().into_iter().collect();
+            break;
         }
     }
 
@@ -162,10 +176,10 @@ pub async fn search_multi_index(mut ctx: Context<Data>) -> SResult<Response> {
     let par_body = body.clone();
     let responses_per_index: Vec<SResult<_>> = index_list
         .into_par_iter()
-        .map(move |index_name| {
+        .map(move |index_uid| {
             let index: Index = db
-                .open_index(&index_name)
-                .ok_or(ResponseError::index_not_found(&index_name))?;
+                .open_index(&index_uid)
+                .ok_or(ResponseError::index_not_found(&index_uid))?;
 
             let mut search_builder = index.new_search(par_body.query.clone());
 
@@ -188,7 +202,7 @@ pub async fn search_multi_index(mut ctx: Context<Data>) -> SResult<Response> {
                 search_builder.filters(filters);
             }
             if let Some(timeout_ms) = par_body.timeout_ms {
-                search_builder.timeout(Duration::from_secs(timeout_ms));
+                search_builder.timeout(Duration::from_millis(timeout_ms));
             }
             if let Some(matches) = par_body.matches {
                 if matches {
@@ -196,13 +210,11 @@ pub async fn search_multi_index(mut ctx: Context<Data>) -> SResult<Response> {
                 }
             }
 
-            let env = &db.env;
-            let reader = env.read_txn().map_err(ResponseError::internal)?;
-
+            let reader = db.main_read_txn().map_err(ResponseError::internal)?;
             let response = search_builder
                 .search(&reader)
                 .map_err(ResponseError::internal)?;
-            Ok((index_name, response))
+            Ok((index_uid, response))
         })
         .collect();
 
@@ -211,11 +223,11 @@ pub async fn search_multi_index(mut ctx: Context<Data>) -> SResult<Response> {
     let mut max_query_time = 0;
 
     for response in responses_per_index {
-        if let Ok((index_name, response)) = response {
+        if let Ok((index_uid, response)) = response {
             if response.processing_time_ms > max_query_time {
                 max_query_time = response.processing_time_ms;
             }
-            hits_map.insert(index_name, response.hits);
+            hits_map.insert(index_uid, response.hits);
         }
     }
 

meilisearch-http/src/routes/setting.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 use http::StatusCode;
 use serde::{Deserialize, Serialize};
@@ -14,7 +14,6 @@ use crate::Data;
 #[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct SettingBody {
-    pub stop_words: Option<StopWords>,
     pub ranking_order: Option<RankingOrder>,
     pub distinct_field: Option<DistinctField>,
     pub ranking_rules: Option<RankingRules>,
@@ -27,7 +26,6 @@ pub enum RankingOrdering {
     Dsc,
 }
 
-pub type StopWords = HashSet<String>;
 pub type RankingOrder = Vec<String>;
 pub type DistinctField = String;
 pub type RankingRules = HashMap<String, RankingOrdering>;
@@ -36,8 +34,8 @@ pub async fn get(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(SettingsRead)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let settings = match index.main.customs(&reader).unwrap() {
         Some(bytes) => bincode::deserialize(bytes).unwrap(),
@@ -54,18 +52,15 @@ pub async fn update(mut ctx: Context<Data>) -> SResult<Response> {
 
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_write_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
-    let mut current_settings = match index.main.customs(&writer).unwrap() {
+    let mut current_settings = match index.main.customs(&reader).unwrap() {
         Some(bytes) => bincode::deserialize(bytes).unwrap(),
         None => SettingBody::default(),
     };
 
-    if let Some(stop_words) = settings.stop_words {
-        current_settings.stop_words = Some(stop_words);
-    }
-
     if let Some(ranking_order) = settings.ranking_order {
         current_settings.ranking_order = Some(ranking_order);
     }

meilisearch-http/src/routes/stats.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use chrono::{DateTime, Utc};
+use log::error;
 use pretty_bytes::converter::convert;
 use serde::Serialize;
 use sysinfo::{NetworkExt, Pid, ProcessExt, ProcessorExt, System, SystemExt};
@@ -17,44 +18,38 @@ use crate::Data;
 struct IndexStatsResponse {
     number_of_documents: u64,
     is_indexing: bool,
-    last_update: Option<DateTime<Utc>>,
     fields_frequency: HashMap<String, usize>,
 }
 
 pub async fn index_stat(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(Admin)?;
-    let index_name = ctx.url_param("index")?;
+    let index_uid = ctx.url_param("index")?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+    let update_reader = db.update_read_txn().map_err(ResponseError::internal)?;
 
     let number_of_documents = index
         .main
         .number_of_documents(&reader)
         .map_err(ResponseError::internal)?;
 
-    let fields_frequency = ctx
-        .state()
-        .fields_frequency(&reader, &index_name)
+    let fields_frequency = index
+        .main
+        .fields_frequency(&reader)
         .map_err(ResponseError::internal)?
         .unwrap_or_default();
 
     let is_indexing = ctx
         .state()
-        .is_indexing(&reader, &index_name)
+        .is_indexing(&update_reader, &index_uid)
         .map_err(ResponseError::internal)?
-        .ok_or(ResponseError::not_found("Index not found"))?;
-
-    let last_update = ctx
-        .state()
-        .last_update(&reader, &index_name)
-        .map_err(ResponseError::internal)?;
+        .ok_or(ResponseError::internal("'is_indexing' date not found"))?;
 
     let response = IndexStatsResponse {
         number_of_documents,
         is_indexing,
-        last_update,
         fields_frequency,
     };
     Ok(tide::response::json(response))
@@ -64,50 +59,53 @@ pub async fn index_stat(ctx: Context<Data>) -> SResult<Response> {
 #[serde(rename_all = "camelCase")]
 struct StatsResult {
     database_size: u64,
+    last_update: Option<DateTime<Utc>>,
     indexes: HashMap<String, IndexStatsResponse>,
 }
 
 pub async fn get_stats(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(Admin)?;
+
     let mut index_list = HashMap::new();
 
-    if let Ok(indexes_set) = ctx.state().db.indexes_names() {
-        for index_name in indexes_set {
-            let db = &ctx.state().db;
-            let env = &db.env;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+    let update_reader = db.update_read_txn().map_err(ResponseError::internal)?;
 
-            let index = db.open_index(&index_name).unwrap();
-            let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let indexes_set = ctx.state().db.indexes_uids();
+    for index_uid in indexes_set {
+        let index = ctx.state().db.open_index(&index_uid);
 
-            let number_of_documents = index
-                .main
-                .number_of_documents(&reader)
-                .map_err(ResponseError::internal)?;
+        match index {
+            Some(index) => {
+                let number_of_documents = index
+                    .main
+                    .number_of_documents(&reader)
+                    .map_err(ResponseError::internal)?;
 
-            let fields_frequency = ctx
-                .state()
-                .fields_frequency(&reader, &index_name)
-                .map_err(ResponseError::internal)?
-                .unwrap_or_default();
+                let fields_frequency = index
+                    .main
+                    .fields_frequency(&reader)
+                    .map_err(ResponseError::internal)?
+                    .unwrap_or_default();
 
-            let is_indexing = ctx
-                .state()
-                .is_indexing(&reader, &index_name)
-                .map_err(ResponseError::internal)?
-                .ok_or(ResponseError::not_found("Index not found"))?;
+                let is_indexing = ctx
+                    .state()
+                    .is_indexing(&update_reader, &index_uid)
+                    .map_err(ResponseError::internal)?
+                    .ok_or(ResponseError::internal("'is_indexing' date not found"))?;
 
-            let last_update = ctx
-                .state()
-                .last_update(&reader, &index_name)
-                .map_err(ResponseError::internal)?;
-
-            let response = IndexStatsResponse {
-                number_of_documents,
-                is_indexing,
-                last_update,
-                fields_frequency,
-            };
-            index_list.insert(index_name, response);
+                let response = IndexStatsResponse {
+                    number_of_documents,
+                    is_indexing,
+                    fields_frequency,
+                };
+                index_list.insert(index_uid, response);
+            }
+            None => error!(
+                "Index {:?} is referenced in the indexes list but cannot be found",
+                index_uid
+            ),
         }
     }
 
@@ -118,8 +116,14 @@ pub async fn get_stats(ctx: Context<Data>) -> SResult<Response> {
         .filter(|metadata| metadata.is_file())
         .fold(0, |acc, m| acc + m.len());
 
+    let last_update = ctx
+        .state()
+        .last_update(&reader)
+        .map_err(ResponseError::internal)?;
+
     let response = StatsResult {
         database_size,
+        last_update,
         indexes: index_list,
     };
 

meilisearch-http/src/routes/stop_words.rs

@@ -12,8 +12,8 @@ pub async fn list(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(SettingsRead)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let stop_words_fst = index
         .main
@@ -35,8 +35,8 @@ pub async fn add(mut ctx: Context<Data>) -> SResult<Response> {
 
     let data: Vec<String> = ctx.body_json().await.map_err(ResponseError::bad_request)?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut stop_words_addition = index.stop_words_addition();
     for stop_word in data {
@@ -61,8 +61,8 @@ pub async fn delete(mut ctx: Context<Data>) -> SResult<Response> {
 
     let data: Vec<String> = ctx.body_json().await.map_err(ResponseError::bad_request)?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut stop_words_deletion = index.stop_words_deletion();
     for stop_word in data {

meilisearch-http/src/routes/synonym.rs

@@ -31,8 +31,8 @@ pub async fn list(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(SettingsRead)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let synonyms_fst = index
         .main
@@ -65,8 +65,8 @@ pub async fn get(ctx: Context<Data>) -> SResult<Response> {
     let synonym = ctx.url_param("synonym")?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let reader = env.read_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
 
     let synonym_list = index
         .synonyms
@@ -87,8 +87,8 @@ pub async fn create(mut ctx: Context<Data>) -> SResult<Response> {
 
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut synonyms_addition = index.synonyms_addition();
 
@@ -115,7 +115,7 @@ pub async fn create(mut ctx: Context<Data>) -> SResult<Response> {
 
     let response_body = IndexUpdateResponse { update_id };
     Ok(tide::response::json(response_body)
-        .with_status(StatusCode::CREATED)
+        .with_status(StatusCode::ACCEPTED)
         .into_response())
 }
 
@@ -125,8 +125,8 @@ pub async fn update(mut ctx: Context<Data>) -> SResult<Response> {
     let index = ctx.index()?;
     let data: Vec<String> = ctx.body_json().await.map_err(ResponseError::bad_request)?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut synonyms_addition = index.synonyms_addition();
     synonyms_addition.add_synonym(synonym.clone(), data.clone().into_iter());
@@ -147,8 +147,8 @@ pub async fn delete(ctx: Context<Data>) -> SResult<Response> {
     let synonym = ctx.url_param("synonym")?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut synonyms_deletion = index.synonyms_deletion();
     synonyms_deletion.delete_all_alternatives_of(synonym);
@@ -171,8 +171,8 @@ pub async fn batch_write(mut ctx: Context<Data>) -> SResult<Response> {
 
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let mut synonyms_addition = index.synonyms_addition();
     for raw in data {
@@ -207,12 +207,13 @@ pub async fn clear(ctx: Context<Data>) -> SResult<Response> {
     ctx.is_allowed(SettingsWrite)?;
     let index = ctx.index()?;
 
-    let env = &ctx.state().db.env;
-    let mut writer = env.write_txn().map_err(ResponseError::internal)?;
+    let db = &ctx.state().db;
+    let reader = db.main_read_txn().map_err(ResponseError::internal)?;
+    let mut writer = db.update_write_txn().map_err(ResponseError::internal)?;
 
     let synonyms_fst = index
         .main
-        .synonyms_fst(&writer)
+        .synonyms_fst(&reader)
         .map_err(ResponseError::internal)?;
 
     let synonyms_fst = synonyms_fst.unwrap_or_default();