Merge branch 'release-v0.19.0' into stable

1224: fix synonyms normalization r=MarinPostma a=LegendreM

Synonyms needs to be indexed in ascendant order,
and the new normalization step for synonyms potentially changes this order
which break the indexation process
because "Harry Potter" > "HP"  but "harry potter" < "hp"

Co-authored-by: many <maxime@meilisearch.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/tracking-issue.md

@@ -0,0 +1,40 @@
+---
+name: Tracking issue
+about: Template for a tracking issue
+title: ''
+labels: tracking-issue
+assignees: ''
+
+---
+
+# Summary
+
+One paragraph to explain the feature.
+
+# Motivations
+
+Why are we doing this? What use cases does it support? What is the expected outcome?
+
+# Explanation
+
+Explain the proposal like it was the final documentation of this proposal.
+
+- What is changing for end-users.
+- How it works.
+- What is breaking?
+- Examples.
+
+# Implementation
+
+Explain the technical specificities that will need to be known or done in order to implement this proposal.
+
+## Steps
+
+Describe each step to create the feature with it's associated issue/PR.
+
+# Related
+
+- [ ] Validated by the team (@people needed)
+- [ ] Test added
+- [ ] [Documentation](https://github.com/meilisearch/documentation/issues/#xxx) //Change xxx or remove the line
+- [ ] [SDK/Integrations](https://github.com/meilisearch/integration-guides/issues/#xxx) //Change xxx or remove the line

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "monthly"

.github/is-latest-release.sh

@@ -0,0 +1,132 @@
+#!/bin/sh
+
+# Checks if the current tag should be the latest (in terms of semver and not of release date).
+# Ex: previous tag -> v0.10.1
+#     new tag -> v0.8.12
+#     The new tag should not be the latest
+#     So it returns "false", the CI should not run for the release v0.8.2
+
+# Used in GHA in publish-docker-latest.yml
+# Returns "true" or "false" (as a string) to be used in the `if` in GHA
+
+# GLOBAL
+GREP_SEMVER_REGEXP='v\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)$' # i.e. v[number].[number].[number]
+
+# FUNCTIONS
+
+# semverParseInto and semverLT from https://github.com/cloudflare/semver_bash/blob/master/semver.sh
+
+# usage: semverParseInto version major minor patch special
+# version: the string version
+# major, minor, patch, special: will be assigned by the function
+semverParseInto() {
+    local RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z-]*\)'
+    #MAJOR
+    eval $2=`echo $1 | sed -e "s#$RE#\1#"`
+    #MINOR
+    eval $3=`echo $1 | sed -e "s#$RE#\2#"`
+    #MINOR
+    eval $4=`echo $1 | sed -e "s#$RE#\3#"`
+    #SPECIAL
+    eval $5=`echo $1 | sed -e "s#$RE#\4#"`
+}
+
+# usage: semverLT version1 version2
+semverLT() {
+    local MAJOR_A=0
+    local MINOR_A=0
+    local PATCH_A=0
+    local SPECIAL_A=0
+
+    local MAJOR_B=0
+    local MINOR_B=0
+    local PATCH_B=0
+    local SPECIAL_B=0
+
+    semverParseInto $1 MAJOR_A MINOR_A PATCH_A SPECIAL_A
+    semverParseInto $2 MAJOR_B MINOR_B PATCH_B SPECIAL_B
+
+    if [ $MAJOR_A -lt $MAJOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -lt $MINOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -le $MINOR_B ] && [ $PATCH_A -lt $PATCH_B ]; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  != "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  != "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A" < "_$SPECIAL_B" ]; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Returns the tag of the latest stable release (in terms of semver and not of release date)
+get_latest() {
+    temp_file='temp_file' # temp_file needed because the grep would start before the download is over
+    curl -s 'https://api.github.com/repos/meilisearch/MeiliSearch/releases' > "$temp_file"
+    releases=$(cat "$temp_file" | \
+        grep -E "tag_name|draft|prerelease" \
+        | tr -d ',"' | cut -d ':' -f2 | tr -d ' ')
+        # Returns a list of [tag_name draft_boolean prerelease_boolean ...]
+        # Ex: v0.10.1 false false v0.9.1-rc.1 false true v0.9.0 false false...
+
+    i=0
+    latest=""
+    current_tag=""
+    for release_info in $releases; do
+        if [ $i -eq 0 ]; then # Cheking tag_name
+            if echo "$release_info" | grep -q "$GREP_SEMVER_REGEXP"; then # If it's not an alpha or beta release
+                current_tag=$release_info
+            else
+                current_tag=""
+            fi
+            i=1
+        elif [ $i -eq 1 ]; then # Checking draft boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=2
+        elif [ $i -eq 2 ]; then # Checking prerelease boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=0
+            if [ "$current_tag" != "" ]; then # If the current_tag is valid
+                if [ "$latest" = "" ]; then # If there is no latest yet
+                    latest="$current_tag"
+                else
+                    semverLT $current_tag $latest # Comparing latest and the current tag
+                    if [ $? -eq 1 ]; then
+                        latest="$current_tag"
+                    fi
+                fi
+            fi
+        fi
+    done
+
+    rm -f "$temp_file"
+    echo $latest
+}
+
+# MAIN
+current_tag="$(echo $GITHUB_REF | tr -d 'refs/tags/')"
+latest="$(get_latest)"
+
+if [ "$current_tag" != "$latest" ]; then
+    # The current release tag is not the latest
+    echo "false"
+else
+    # The current release tag is the latest
+    echo "true"
+fi

.github/workflows/README.md

@@ -1,4 +1,4 @@
-# GitHub actions workflow for MeiliDB
+# GitHub Actions Workflow for MeiliSearch
 
 > **Note:**
 
@@ -6,6 +6,15 @@
 
 ## 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.
+- On each pull request, we trigger `cargo test`.
+- On each tag, we build:
+    - the tagged Docker image and publish it to Docker Hub
+    - the binaries for MacOS, Ubuntu, and Windows
+    - the Debian package
+- On each stable release (`v*.*.*` tag):
+    - we build the `latest` Docker image and publish it to Docker Hub
+    - we publish the binary to Hombrew and Gemfury
+
+## Problems
+
+- We do not test on Windows because we are unable to make it work, there is a disk space problem.

.github/workflows/coverage.yml

@@ -0,0 +1,34 @@
+---
+on:
+  pull_request:
+    types: [review_requested, ready_for_review]
+
+name: Execute code coverage
+
+jobs:
+  nightly-coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clean
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features --no-fail-fast
+        env:
+          CARGO_INCREMENTAL: "0"
+          RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Cpanic=unwind -Zpanic_abort_tests"
+      - uses: actions-rs/grcov@v0.1
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          file: ${{ steps.coverage.outputs.report }}
+          yml: ./codecov.yml
+          fail_ci_if_error: true

.github/workflows/publish-binaries.yml

@@ -1,9 +1,8 @@
-name: Publish binaries to GitHub release
-
 on:
-  push:
-    tags:
-      - '*'
+  release:
+    types: [published]
+
+name: Publish binaries to release
 
 jobs:
   publish:
@@ -11,7 +10,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         include:
           - os: ubuntu-latest
             artifact_name: meilisearch
@@ -19,6 +18,9 @@ jobs:
           - os: macos-latest
             artifact_name: meilisearch
             asset_name: meilisearch-macos-amd64
+          - os: windows-latest
+            artifact_name: meilisearch.exe
+            asset_name: meilisearch-windows-amd64.exe
 
     steps:
     - uses: hecrj/setup-rust-action@master
@@ -30,7 +32,55 @@ jobs:
     - name: Upload binaries to release
       uses: svenstaro/upload-release-action@v1-release
       with:
-        repo_token: ${{ secrets.GITHUB_TOKEN }}
+        repo_token: ${{ secrets.PUBLISH_TOKEN }}
         file: target/release/${{ matrix.artifact_name }}
         asset_name: ${{ matrix.asset_name }}
         tag: ${{ github.ref }}
+
+  publish-armv7:
+    name: Publish for ARMv7
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v1.0.0
+      - uses: uraimo/run-on-arch-action@v1.0.7
+        id: runcmd
+        with:
+          architecture: armv7
+          distribution: ubuntu18.04
+          run: |
+            apt update
+            apt install -y curl gcc make
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
+            source $HOME/.cargo/env
+            cargo build --release --locked
+      - name: Upload the binary to release
+        uses: svenstaro/upload-release-action@v1-release
+        with:
+          repo_token: ${{ secrets.PUBLISH_TOKEN }}
+          file: target/release/meilisearch
+          asset_name: meilisearch-linux-armv7
+          tag: ${{ github.ref }}
+
+  publish-armv8:
+    name: Publish for ARMv8
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v1.0.0
+      - uses: uraimo/run-on-arch-action@v1.0.7
+        id: runcmd
+        with:
+          architecture: aarch64 # aka ARMv8
+          distribution: ubuntu18.04
+          run: |
+            apt update
+            apt install -y curl gcc make
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
+            source $HOME/.cargo/env
+            cargo build --release --locked
+      - name: Upload the binary to release
+        uses: svenstaro/upload-release-action@v1-release
+        with:
+          repo_token: ${{ secrets.PUBLISH_TOKEN }}
+          file: target/release/meilisearch
+          asset_name: meilisearch-linux-armv8
+          tag: ${{ github.ref }}

.github/workflows/publish-deb-brew-pkg.yml

@@ -0,0 +1,39 @@
+name: Publish deb pkg to GitHub release & APT repository & Homebrew
+
+on:
+  release:
+    types: [released]
+
+jobs:
+  debian:
+    name: Publish debian packagge
+    runs-on: ubuntu-latest
+    steps:
+    - uses: hecrj/setup-rust-action@master
+      with:
+        rust-version: stable
+    - name: Install cargo-deb
+      run: cargo install cargo-deb
+    - uses: actions/checkout@v1
+    - name: Build deb package
+      run: cargo deb -p meilisearch-http -o target/debian/meilisearch.deb
+    - name: Upload debian pkg to release
+      uses: svenstaro/upload-release-action@v1-release
+      with:
+        repo_token: ${{ secrets.GITHUB_TOKEN }}
+        file: target/debian/meilisearch.deb
+        asset_name: meilisearch.deb
+        tag: ${{ github.ref }}
+    - name: Upload debian pkg to apt repository
+      run: curl -F package=@target/debian/meilisearch.deb https://${{ secrets.GEMFURY_PUSH_TOKEN }}@push.fury.io/meilisearch/
+
+  homebrew:
+    name: Bump Homebrew formula
+    runs-on: ubuntu-latest
+    steps:
+      - name: Create PR to Homebrew
+        uses: mislav/bump-homebrew-formula-action@v1
+        with:
+          formula-name: meilisearch
+        env:
+          COMMITTER_TOKEN: ${{ secrets.HOMEBREW_COMMITTER_TOKEN }}

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

@@ -1,8 +1,7 @@
 ---
 on:
-  push:
-    branches:
-      - master
+  release:
+    types: [released]
 
 name: Publish latest image to Docker Hub
 
@@ -10,8 +9,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
+      - name: Check if current release is latest
+        run: echo "##[set-output name=is_latest;]$(sh .github/is-latest-release.sh)"
+        id: release
       - name: Publish to Registry
+        if: steps.release.outputs.is_latest == 'true'
         uses: elgohr/Publish-Docker-Github-Action@master
         with:
           name: getmeili/meilisearch

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

@@ -17,4 +17,4 @@ jobs:
           name: getmeili/meilisearch
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
-          tags: true
+          tag_names: true

.github/workflows/test.yml

@@ -1,20 +1,93 @@
 ---
-on: [pull_request]
+on:
+  push:
+    branches:
+      - release-v*
+      - trying
+      - staging
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+' # this only concerns tags on stable
 
-name: Cargo test
+name: Test binaries with cargo test
 
 jobs:
   check:
-    name: MeiliSearch
+    name: Test on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        override: true
+        components: clippy
+    - name: Run cargo test
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --locked --release
+    - name: Run cargo clippy
+      uses: actions-rs/cargo@v1
+      with:
+        command: clippy
+
+  build-image:
+    name: Test the build of Docker image
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/toolchain@v1
+    - uses: actions/checkout@v1
+    - run: docker build . --file Dockerfile -t meilisearch
+      name: Docker build
+
+  ## A push occurred on a release branch, a prerelease is created and assets are generated
+  prerelease:
+    name: create prerelease
+    needs: [check, build-image]
+    if: ${{ contains(github.ref, 'release-') && github.event_name == 'push' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
         with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
+          fetch-depth: 0
+      - name: Get version number
+        id: version-number
+        run: echo "##[set-output name=number;]$(echo ${{ github.ref }} | sed 's/.*\(v.*\)/\1/')"
+      - name: Get commit count
+        id: commit-count
+        run: echo "##[set-output name=count;]$(git rev-list remotes/origin/master..remotes/origin/release-${{ steps.version-number.outputs.number }} --count)"
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.PUBLISH_TOKEN }} # Personal Access Token
         with:
-          command: test
+          tag_name: ${{ steps.version-number.outputs.number }}rc${{ steps.commit-count.outputs.count }}
+          release_name: Pre-release ${{ steps.version-number.outputs.number }}-rc${{ steps.commit-count.outputs.count }}
+          prerelease: true
+
+  ## If a tag is pushed, a release is created for this tag, and assets will be generated
+  release:
+    name: create release
+    needs: [check, build-image]
+    if:  ${{ contains(github.ref, 'tags/v') }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Get version number
+        id: version-number
+        run: echo "##[set-output name=number;]$(echo ${{ github.ref }} | sed 's/.*\(v.*\)/\1/')" 
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.PUBLISH_TOKEN }} # PAT
+        with:
+          tag_name: ${{ steps.version-number.outputs.number }}
+          release_name: Meilisearch ${{ steps.version-number.outputs.number }}
+          prerelease: false

.gitignore

@@ -1,6 +1,8 @@
 /target
+meilisearch-core/target
 **/*.csv
 **/*.json_lines
 **/*.rs.bk
 /*.mdb
 /query-history.txt
+/data.ms

CHANGELOG.md

@@ -0,0 +1,119 @@
+## v0.19.0
+
+  - The snapshots are now created and then renamed in atomically (#1172)
+  - Fix a race condition when an update and a document addition are processed immediately one after the other (#1176)
+  - Latin synonyms are normalized during indexation (#1174)
+
+## v0.18.1
+
+  - Fix unexpected CORS error (#1185)
+
+## v0.18.0
+
+  - Integration with the new tokenizer (#1091)
+  - Fix setting consistency bug (#1128)
+  - Fix attributes to retrieve bug (#1131)
+  - Increase default payload size (#1147)
+  - Improvements to code quality (#1167, #1165, #1126, #1151)
+
+## v0.17.0
+  - Fix corrupted data during placeholder search (#1089)
+  - Remove maintenance error from http (#1082)
+  - Disable frontend in production (#1097)
+  - Update nbHits count with filtered documents (#849)
+  - Remove update changelog ci check (#1090)
+  - Add deploy on Platform.sh option to README (#1087)
+  - Change movie gifs in README (#1077)
+  - Remove some clippy warnings (#1100)
+  - Improve script `download-latest.sh` (#1054)
+  - Bump dependencies version (#1056, #1057, #1059)
+
+## v0.16.0
+
+  - Automatically create index on document push if index doesn't exist (#914)
+  - Sort displayedAttributes and facetDistribution (#946)
+
+## v0.15.0
+
+  - Update actix-web dependency to 3.0.0 (#963)
+  - Consider an empty query to be a placeholder search (#916)
+
+## v0.14.1
+
+  - Fix version mismatch in snapshot importation (#959)
+
+## v0.14.0
+
+  - Sort displayedAttributes (#943)
+  - Fix facet distribution case (#797)
+  - Snapshotting (#839)
+  - Fix bucket-sort unwrap bug (#915)
+
+## v0.13.0
+
+  - placeholder search (#771)
+  - Add database version mismatch check (#794)
+  - Displayed and searchable attributes wildcard (#846)
+  - Remove sys-info route (#810)
+  - Check database version mismatch (#794)
+  - Fix unique docid bug (#841)
+  - Error codes in updates (#792)
+  - Sentry disable argument (#813)
+  - Log analytics if enabled (#825)
+  - Fix default values displayed on web interface (#874)
+
+## v0.12.0
+
+  - Fix long documents not being indexed completely bug (#816)
+  - Fix distinct attribute returning id instead of name (#800)
+  - error code rename (#805)
+
+## v0.11.1
+
+  - Fix facet cache on document update (#789)
+  - Improvements on settings consistency (#778)
+
+## v0.11.0
+
+  - Change the HTTP framework, moving from tide to actix-web (#601)
+  - Bump sentry version to 0.18.1 (#690)
+  - Enable max payload size override (#684)
+  - Disable sentry in debug (#681)
+  - Better terminal greeting (#680)
+  - Fix highlight misalignment (#679)
+  - Add support for facet count (#676)
+  - Add support for faceted search (#631)
+  - Add support for configuring the lmdb map size (#646, #647)
+  - Add exposed port for Dockerfile (#654)
+  - Add sentry probe (#664)
+  - Fix url trailing slash and double slash issues (#659)
+  - Fix accept all Content-Type by default (#653)
+  - Return the error message from Serde when a deserialization error is encountered (#661)
+  - Fix NormalizePath middleware to make the dashboard accessible (#695)
+  - Update sentry features to remove openssl (#702)
+  - Add SSL support (#669)
+  - Rename fieldsFrequency into fieldsDistribution in stats (#719)
+  - Add support for error code reporting (#703)
+  - Allow the dashboard to query private servers (#732)
+  - Add telemetry (#720)
+  - Add post route for search (#735)
+
+## v0.10.1
+
+  - Add support for floating points in filters (#640)
+  - Add '@' character as tokenizer separator (#607)
+  - Add support for filtering on arrays of strings (#611)
+
+## v0.10.0
+
+  - Refined filtering (#592)
+  - Add the number of hits in search result (#541)
+  - Add support for aligned crop in search result (#543)
+  - Sanitize the content displayed in the web interface (#539)
+  - Add support of nested null, boolean and seq values (#571 and #568, #574)
+  - Fixed the core benchmark (#576)
+  - Publish an ARMv7 and ARMv8 binaries on releases (#540 and #581)
+  - Fixed a bug where the result of the update status after the first update was empty (#542)
+  - Fixed a bug where stop words were not handled correctly (#594)
+  - Fix CORS issues (#602)
+  - Support wildcard on attributes to retrieve, highlight, and crop (#549, #565, and #598)

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at bonjour@meilisearch.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,112 @@
+# Contributing
+
+First, thank you for contributing to MeiliSearch! The goal of this document is to
+provide everything you need to start contributing to MeiliSearch. The
+following TOC is sorted progressively, starting with the basics and
+expanding into more specifics.
+
+<!-- MarkdownTOC autolink="true" style="ordered" indent="   " -->
+
+1. [Assumptions](#assumptions)
+1. [Your First Contribution](#your-first-contribution)
+1. [Change Control](#change-control)
+   1. [Git Branches](#git-branches)
+   1. [Git Commits](#git-commits)
+      1. [Style](#style)
+   1. [Github Pull Requests](#github-pull-requests)
+      1. [Reviews & Approvals](#reviews--approvals)
+      1. [Merge Style](#merge-style)
+   1. [CI](#ci)
+1. [Development](#development)
+   1. [Setup](#setup)
+   1. [Testing](#testing)
+   1. [Benchmarking](#benchmarking--profiling)
+1. [Humans](#humans)
+   1. [Documentation](#documentation)
+   1. [Changelog](#changelog)
+
+<!-- /MarkdownTOC -->
+
+## Assumptions
+
+1. **You're familiar with [Github](https://github.com) and the [pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
+   workflow.**
+2. **You've read the MeiliSearch [docs](https://docs.meilisearch.com).**
+3. **You know about the [MeiliSearch community](https://docs.meilisearch.com/resources/contact.html).
+   Please use this for help.**
+
+## Your First Contribution
+
+1. Ensure your change has an issue! Find an
+   [existing issue](https://github.com/meilisearch/meilisearch/issues/) or [open a new issue](https://github.com/meilisearch/meilisearch/issues/new).
+   * This is where you can get a feel if the change will be accepted or not.
+2. Once approved, [fork the MeiliSearch repository](https://help.github.com/en/github/getting-started-with-github/fork-a-repo) in your own
+   Github account.
+3. [Create a new Git branch](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-and-deleting-branches-within-your-repository)
+4. Review the MeiliSearch [workflow](#workflow) and [development](#development).
+5. Make your changes.
+6. [Submit the branch as a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork) to the main MeiliSearch
+   repo. A MeiliSearch team member should comment and/or review your pull request
+   with a few days. Although, depending on the circumstances, it may take
+   longer.
+
+## Change Control
+
+### Git Branches
+
+_All_ changes must be made in a branch and submitted as [pull requests](#pull-requests).
+MeiliSearch does not adopt any type of branch naming style, but please use something
+descriptive of your changes.
+
+### Git Commits
+
+#### Style
+
+Please ensure your commits are small and focused; they should tell a story of
+your change. This helps reviewers to follow your changes, especially for more
+complex changes.
+
+Familiarise yourself with [How to Write a Git Commit Message](https://chris.beams.io/posts/git-commit/).
+
+### Github Pull Requests
+
+Once your changes are ready you must submit your branch as a pull request.
+
+#### Reviews & Approvals
+
+All pull requests must be reviewed and approved by at least one MeiliSearch team
+member.
+
+#### Merge Style
+
+All pull requests are squashed and merged. We generally discourage large pull
+requests that are over 300-500 lines of diff. If you would like to propose
+a change that is larger we suggest coming onto our chat channel and
+discuss it with one of our engineers. This way we can talk through the
+solution and discuss if a change that large is even needed! This overall
+will produce a quicker response to the change and likely produce code that
+aligns better with our process.
+
+## Development
+
+### Setup
+
+See the [MeiliSearch Docs](https://docs.meilisearch.com/guides/advanced_guides/installation.html) for how to set up a development environment.
+
+### Benchmarking & Profiling
+
+We do not yet do any benchmarking, nor have we formalised our profiling. If you'd like to work on this please get in touch!
+
+## Humans
+
+After making your change, you'll want to prepare it for MeiliSearch users (mostly humans). This usually entails updating documentation and announcing your feature.
+
+### Documentation
+
+Documentation is very important to MeiliSearch. All contributions that
+alter user-facing behavior MUST include documentation changes. Please see
+[GitHub.com/meilisearch/documentation](https://github.com/meilisearch/documentation) for more info.
+
+### Changelog
+
+Until we have guidelines in place, updating the [`Changelog`](/CHANGELOG.md) is solely the responsibility of MeiliSearch team members.

Cargo.toml

@@ -3,7 +3,6 @@ members = [
     "meilisearch-core",
     "meilisearch-http",
     "meilisearch-schema",
-    "meilisearch-tokenizer",
     "meilisearch-types",
 ]
 

Dockerfile

@@ -4,7 +4,6 @@ FROM    alpine:3.10 AS compiler
 RUN     apk update --quiet
 RUN     apk add curl
 RUN     apk add build-base
-RUN     apk add libressl-dev
 
 RUN     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 
@@ -19,11 +18,12 @@ RUN     $HOME/.cargo/bin/cargo build --release
 # Run
 FROM    alpine:3.10
 
-RUN     apk update --quiet
-RUN     apk add libressl
-RUN     apk add build-base
+RUN     apk add -q --no-cache libgcc tini
 
 COPY    --from=compiler /meilisearch/target/release/meilisearch .
 
-ENV     MEILI_HTTP_ADDR 0.0.0.0:8080
+ENV     MEILI_HTTP_ADDR 0.0.0.0:7700
+EXPOSE  7700/tcp
+
+ENTRYPOINT ["tini", "--"]
 CMD     ./meilisearch

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [year] [fullname]
+Copyright (c) 2019-2021 Meili SAS
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,165 +1,203 @@
-# MeiliSearch
+<p align="center">
+  <img src="assets/logo.svg" alt="MeiliSearch" width="200" height="200" />
+</p>
 
-[![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-commons%20clause-lightgrey)](https://commonsclause.com/)
+<h1 align="center">MeiliSearch</h1>
 
-Ultra relevant and instant full-text search API.
+<h4 align="center">
+  <a href="https://www.meilisearch.com">Website</a> |
+  <a href="https://roadmap.meilisearch.com/tabs/1-under-consideration">Roadmap</a> |
+  <a href="https://blog.meilisearch.com">Blog</a> |
+  <a href="https://fr.linkedin.com/company/meilisearch">LinkedIn</a> |
+  <a href="https://twitter.com/meilisearch">Twitter</a> |
+  <a href="https://docs.meilisearch.com">Documentation</a> |
+  <a href="https://docs.meilisearch.com/faq/">FAQ</a>
+</h4>
 
-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 ranking.
+<p align="center">
+  <a href="https://github.com/meilisearch/MeiliSearch/actions"><img src="https://github.com/meilisearch/MeiliSearch/workflows/Cargo%20test/badge.svg" alt="Build Status"></a>
+  <a href="https://deps.rs/repo/github/meilisearch/MeiliSearch"><img src="https://deps.rs/repo/github/meilisearch/MeiliSearch/status.svg" alt="Dependency status"></a>
+  <a href="https://github.com/meilisearch/MeiliSearch/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-informational" alt="License"></a>
+  <a href="https://slack.meilisearch.com"><img src="https://img.shields.io/badge/slack-MeiliSearch-blue.svg?logo=slack" alt="Slack"></a>
+  <a href="https://github.com/meilisearch/MeiliSearch/discussions" alt="Discussions"><img src="https://img.shields.io/badge/github-discussions-red" /></a>
+  <a href="https://app.bors.tech/repositories/26457"><img src="https://bors.tech/images/badge_small.svg" alt="Bors enabled"></a>
+</p>
 
-## Features
+<p align="center">⚡ Lightning Fast, Ultra Relevant, and Typo-Tolerant Search Engine 🔍</p>
 
-- 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)
+**MeiliSearch** is a powerful, fast, open-source, easy to use and deploy search engine. Both searching and indexing are highly customizable. Features such as typo-tolerance, filters, and synonyms are provided out-of-the-box.
+For more information about features go to [our documentation](https://docs.meilisearch.com/).
 
+<p align="center">
+  <img src="assets/trumen_quick_loop.gif" alt="Web interface gif" />
+</p>
 
+## ✨ Features
+* Search as-you-type experience (answers < 50 milliseconds)
+* Full-text search
+* Typo tolerant (understands typos and miss-spelling)
+* Faceted search and filters
+* Supports Kanji characters
+* Supports Synonym
+* Easy to install, deploy, and maintain
+* Whole documents are returned
+* Highly customizable
+* RESTful API
 
-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/MeiliSearch/issues/82) and provides great performances.
-
-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.
-
-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!
-
-[![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)
-
-
-
-## Quick Start
-
-You can deploy your own instant, relevant and typo-tolerant MeiliSearch search engine by yourself too.
-Something similar to the demo above can be achieve by following these little three steps first.
-You will need to create your own web front display to make it pretty though.
+## Getting started
 
 ### Deploy the Server
 
-If you have not installed Rust and its package manager `cargo` yet, go to [the installation page](https://www.rust-lang.org/tools/install).<br/>
-You can deploy the server on your own machine, it will listen to HTTP requests on the 8080 port by default.
+#### Homebrew (Mac OS)
 
 ```bash
-cargo run --release
+brew update && brew install meilisearch
+meilisearch
 ```
 
-For more logs during the execution, run:
+#### Docker
+
 ```bash
-RUST_LOG=info cargo run --release
+docker run -p 7700:7700 -v $(pwd)/data.ms:/data.ms getmeili/meilisearch
+```
+
+#### Try MeiliSearch in our Sandbox
+
+Create a MeiliSearch instance in [MeiliSearch Sandbox](https://sandbox.meilisearch.com/). This instance is free, and will be active for 72 hours.
+
+#### Run on Digital Ocean
+
+[![DigitalOcean Marketplace](assets/do-btn-blue.svg)](https://marketplace.digitalocean.com/apps/meilisearch?action=deploy&refcode=7c67bd97e101)
+
+#### Deploy on Platform.sh
+
+<a href="https://console.platform.sh/projects/create-project?template=https://raw.githubusercontent.com/platformsh/template-builder/master/templates/meilisearch/.platform.template.yaml&utm_content=meilisearch&utm_source=github&utm_medium=button&utm_campaign=deploy_on_platform">
+    <img src="https://platform.sh/images/deploy/lg-blue.svg" alt="Deploy on Platform.sh" width="180px" />
+</a>
+
+#### APT (Debian & Ubuntu)
+
+```bash
+echo "deb [trusted=yes] https://apt.fury.io/meilisearch/ /" > /etc/apt/sources.list.d/fury.list
+apt update && apt install meilisearch-http
+meilisearch
+```
+
+#### Download the binary (Linux & Mac OS)
+
+```bash
+curl -L https://install.meilisearch.com | sh
+./meilisearch
+```
+
+#### Compile and run it from sources
+
+If you have the latest stable Rust toolchain installed on your local system, clone the repository and change it to your working directory.
+
+```bash
+git clone https://github.com/meilisearch/MeiliSearch.git
+cd MeiliSearch
+```
+
+In the cloned repository, compile MeiliSearch.
+
+```bash
+rustup override set stable
+rustup update stable
+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.
+Let's create an index! If you need a sample dataset, use [this movie database](https://www.notion.so/meilisearch/A-movies-dataset-to-test-Meili-1cbf7c9cfa4247249c40edfa22d7ca87#b5ae399b81834705ba5420ac70358a65). You can also find it in the `datasets/` directory.
 
 ```bash
-curl -i -X POST 'http://127.0.0.1:8080/indexes' --data '{ "name": "Movies", "uid": "movies" }'
+curl -L 'https://bit.ly/2PAcw9l' -o movies.json
 ```
 
-Now that the server knows about our brand new index, we can send it data.
-We provided you a little dataset, it is available in the `datasets/` directory.
+MeiliSearch can serve multiple indexes, with different kinds of documents.
+It is required to create an index before sending documents to it.
 
 ```bash
-curl -i -X POST 'http://127.0.0.1:8080/indexes/movies/documents' \
+curl -i -X POST 'http://127.0.0.1:7700/indexes' --data '{ "name": "Movies", "uid": "movies" }'
+```
+
+Now that the server knows about your brand new index, you're ready to send it some data.
+
+```bash
+curl -i -X POST 'http://127.0.0.1:7700/indexes/movies/documents' \
   --header 'content-type: application/json' \
-  --data @datasets/movies/movies.json
+  --data-binary @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 greatly help you read the server responses.
+#### In command line
+
+The search engine is now aware of your documents and can serve those via an HTTP server.
+
+The [`jq` command-line tool](https://stedolan.github.io/jq/) can greatly help you read the server responses.
 
 ```bash
-curl 'http://127.0.0.1:8080/indexes/movies/search?q=botman'
+curl 'http://127.0.0.1:7700/indexes/movies/search?q=botman+robin&limit=2' | jq
 ```
 
 ```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": "415",
+      "title": "Batman & Robin",
+      "poster": "https://image.tmdb.org/t/p/w1280/79AYCcxw3kSKbhGpx1LiqaCAbwo.jpg",
+      "overview": "Along with crime-fighting partner Robin and new recruit Batgirl...",
+      "release_date": "1997-06-20",
     },
     {
-      "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"
+      "id": "411736",
+      "title": "Batman: Return of the Caped Crusaders",
+      "poster": "https://image.tmdb.org/t/p/w1280/GW3IyMW5Xgl0cgCN8wu96IlNpD.jpg",
+      "overview": "Adam West and Burt Ward returns to their iconic roles of Batman and Robin...",
+      "release_date": "2016-10-08",
     }
   ],
   "offset": 0,
   "limit": 2,
   "processingTimeMs": 1,
-  "query": "botman"
+  "query": "botman robin"
 }
 ```
 
+#### Use the Web Interface
 
+We also deliver an **out-of-the-box web interface** in which you can test MeiliSearch interactively.
 
-## Performances
+You can access the web interface in your web browser at the root of the server. The default URL is [http://127.0.0.1:7700](http://127.0.0.1:7700). All you need to do is open your web browser and enter MeiliSearch’s address to visit it. This will lead you to a web page with a search bar that will allow you to search in the selected index.
 
-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.
+| [See the gif above](#demo)
 
-Requests are made using [wrk](https://github.com/wg/wrk) and scripted to simulate real users queries.
+## Documentation
 
-```
-Running 10s test @ http://localhost:2230
-  2 threads and 25 connections
-  Thread Stats   Avg      Stdev     Max   +/- Stdev
-    Latency     9.52ms    7.61ms  99.25ms   84.58%
-    Req/Sec     1.41k   119.11     1.78k    64.50%
-  28080 requests in 10.01s, 7.42MB read
-Requests/sec:   2806.46
-Transfer/sec:    759.17KB
-```
+Now that your MeiliSearch server is up and running, you can learn more about how to tune your search engine in [the documentation](https://docs.meilisearch.com).
 
-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.
+## Contributing
 
-### Notes
+Hey! We're glad you're thinking about contributing to MeiliSearch! If you think something is missing or could be improved, please open issues and pull requests. If you'd like to help this project grow, we'd love to have you! To start contributing, checking [issues tagged as "good-first-issue"](https://github.com/meilisearch/MeiliSearch/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) is a good start!
 
-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).
+## Telemetry
 
-## Usage and Examples
+MeiliSearch collects anonymous data regarding general usage.
+This helps us better understand developers usage of MeiliSearch features.<br/>
+To see what information we're retrieving, please see the complete list [on the dedicated issue](https://github.com/meilisearch/MeiliSearch/issues/720).<br/>
+We also use Sentry to make us crash and error reports. If you want to know more about what Sentry collects, please visit their [privacy policy website](https://sentry.io/privacy/).<br/>
+This program is optional, you can disable these analytics by using the `MEILI_NO_ANALYTICS` env variable.
 
-MeiliSearch also provides an example binary that is mostly used for features testing.
-Notice that the example binary is faster to index data as it does read direct CSV files and not JSON HTTP payloads.
+## 💌 Contact
 
-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 MeiliSearch.
+Feel free to contact us about any questions you may have:
+* At [bonjour@meilisearch.com](mailto:bonjour@meilisearch.com)
+* Via the chat box available on every page of [our documentation](https://docs.meilisearch.com/) and on [our landing page](https://www.meilisearch.com/).
+* 🆕 Join our [GitHub Discussions forum](https://github.com/meilisearch/MeiliSearch/discussions)
+* Join our [Slack community](https://slack.meilisearch.com/).
+* By opening an issue.
 
-```bash
-cargo run --release --example from_file -- \
-    index example.mdb datasets/movies/movies.csv \
-    --schema datasets/movies/schema.toml
-```
-
-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.
-
-```bash
-cargo run --release --example from_file -- \
-    search example.mdb \
-    --number-results 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.
+MeiliSearch is developed by [Meili](https://www.meilisearch.com), a young company. To know more about us, you can [read our blog](https://blog.meilisearch.com). Any suggestion or feedback is highly appreciated. Thank you for your support!

assets/do-btn-blue.svg

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="200px" height="42px" viewBox="0 0 200 42" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: Sketch 52.5 (67469) - http://www.bohemiancoding.com/sketch -->
+    <title>do-btn-blue</title>
+    <desc>Created with Sketch.</desc>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="Partner-welcome-kit-Copy-3" transform="translate(-651.000000, -762.000000)">
+            <g id="do-btn-blue" transform="translate(651.000000, 763.000000)">
+                <rect id="Rectangle-Copy" fill="#0069FF" x="0" y="0" width="200" height="40" rx="6"></rect>
+                <path d="M45,0 L45,40" id="Line-2" stroke="#FFFFFF" stroke-linecap="square"></path>
+                <g id="DO_Logo_horizontal_blue-Copy" transform="translate(13.000000, 11.000000)" fill="#FFFFFF">
+                    <path d="M10.0098493,20 L10.0098493,16.1262429 C14.12457,16.1262429 17.2897398,12.0548452 15.7269372,7.74627862 C15.1334679,6.14538921 13.8674,4.86072487 12.2650328,4.28756693 C7.952489,2.72620566 3.87733294,5.88845634 3.87733294,9.99938223 C3.87733294,9.99938223 3.87733294,9.99938223 3.87733294,9.99938223 L0,9.99938223 C0,3.45747613 6.3303395,-1.64165309 13.1948014,0.492866119 C16.2017127,1.42177726 18.57559,3.81322933 19.5053586,6.79760341 C21.6418482,13.6754986 16.5577943,20 10.0098493,20 Z" id="XMLID_49_"></path>
+                    <polygon id="XMLID_47_" points="9.56521739 15.6521739 6.08695652 15.6521739 6.08695652 12.173913 6.08695652 12.173913 9.56521739 12.173913 9.56521739 12.173913"></polygon>
+                    <polygon id="XMLID_46_" points="6.08695652 19.1304348 3.47826087 19.1304348 3.47826087 19.1304348 3.47826087 16.5217391 6.08695652 16.5217391"></polygon>
+                    <polygon id="XMLID_45_" points="3.47826087 16.5217391 0.869565217 16.5217391 0.869565217 16.5217391 0.869565217 13.9130435 0.869565217 13.9130435 3.47826087 13.9130435 3.47826087 13.9130435"></polygon>
+                </g>
+                <text id="Create-a-Droplet-Copy" font-family="Sailec-Medium, Sailec" font-size="16" font-weight="400" fill="#FFFFFF">
+                    <tspan x="58" y="26">Create a Droplet</tspan>
+                </text>
+            </g>
+        </g>
+    </g>
+</svg>

assets/logo.svg

@@ -0,0 +1,17 @@
+<svg width="360" height="360" viewBox="0 0 360 360" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g id="logo_main">
+<rect id="Rectangle" x="107.333" y="0.150146" width="274.315" height="274.315" rx="98.8334" transform="rotate(23 107.333 0.150146)" fill="url(#paint0_linear)"/>
+<path id="Rectangle_2" fill-rule="evenodd" clip-rule="evenodd" d="M61.3296 230.199C46.2224 194.608 38.6688 176.813 38.208 160.329C37.5286 136.025 47.0175 112.539 64.3891 95.5282C76.1718 83.9904 93.9669 76.4368 129.557 61.3296C165.147 46.2224 182.943 38.6688 199.427 38.208C223.731 37.5286 247.217 47.0175 264.228 64.3891C275.766 76.1718 283.319 93.9669 298.426 129.557C313.534 165.147 321.087 182.943 321.548 199.427C322.227 223.731 312.738 247.217 295.367 264.228C283.584 275.766 265.789 283.319 230.199 298.426C194.608 313.534 176.813 321.087 160.329 321.548C136.025 322.227 112.539 312.738 95.5282 295.367C83.9903 283.584 76.4368 265.789 61.3296 230.199Z" fill="url(#paint1_linear)"/>
+<path id="m" fill-rule="evenodd" clip-rule="evenodd" d="M219.568 130.748C242.363 130.748 259.263 147.451 259.263 174.569V229.001H227.232V179.678C227.232 166.119 220.747 159.634 210.136 159.634C205.223 159.634 200.311 161.796 195.595 167.494C195.791 169.852 195.988 172.21 195.988 174.569V229.001H164.154V179.678C164.154 166.119 157.472 159.634 147.057 159.634C142.145 159.634 137.429 161.992 132.712 168.084V229.001H100.878V133.695H132.712V139.394C139.197 133.892 145.878 130.748 156.49 130.748C168.477 130.748 178.695 135.267 185.769 143.52C195.791 134.678 205.42 130.748 219.568 130.748Z" fill="white"/>
+</g>
+<defs>
+<linearGradient id="paint0_linear" x1="-13.6248" y1="129.208" x2="244.49" y2="403.522" gradientUnits="userSpaceOnUse">
+<stop stop-color="#E41359"/>
+<stop offset="1" stop-color="#F23C79"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="11.0088" y1="111.65" x2="111.65" y2="348.747" gradientUnits="userSpaceOnUse">
+<stop stop-color="#24222F"/>
+<stop offset="1" stop-color="#2B2937"/>
+</linearGradient>
+</defs>
+</svg>

bors.toml

@@ -0,0 +1,3 @@
+status = ["Test on macos-latest", "Test on ubuntu-latest"]
+# 4 hours timeout
+timeout-sec = 14400

bump.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/bash
+
+NEW_VERSION=$1
+
+if [ -z "$NEW_VERSION" ]
+then
+	echo "error: a version number must be provided"
+	exit 1
+fi
+
+# find current version
+CURRENT_VERSION=$(cat **/*.toml | grep meilisearch | grep version | sed 's/.*\([0-9]\+\.[0-9]\+\.[0-9]\+\).*/\1/' | sed "1q;d")
+
+# bump all version in .toml
+echo "bumping from version $CURRENT_VERSION to version $NEW_VERSION"
+while true
+do
+	read -r -p "Continue (y/n)?" choice
+	case "$choice" in
+		y|Y ) break;;
+		n|N ) echo "aborting bump" && exit 0;;
+		* ) echo "invalid choice";;
+	esac
+done
+# update all crate version
+sed -i "s/version = \"$CURRENT_VERSION\"/version = \"$NEW_VERSION\"/" **/*.toml
+
+printf "running cargo check: "
+
+CARGO_CHECK=$(cargo check 2>&1)
+
+if [ $? != "0" ]
+then
+	printf "\033[31;1m FAIL \033[0m\n"
+	printf "$CARGO_CHECK"
+	exit 1
+fi
+printf "\033[32;1m OK \033[0m\n"

datasets/movies/README.md

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

datasets/movies/schema.toml

@@ -1,21 +0,0 @@
-# This schema has been generated ...
-# The order in which the attributes are declared is important,
-# it specify the attribute xxx...
-identifier = "id"
-
-[attributes.id]
-displayed = true
-
-[attributes.title]
-displayed = true
-indexed = true
-
-[attributes.overview]
-displayed = true
-indexed = true
-
-[attributes.release_date]
-displayed = true
-
-[attributes.poster]
-displayed = true

deep-dive.md

@@ -1,95 +0,0 @@
-# A deep dive in MeiliSearch
-
-On the 15 of May 2019.
-
-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" -->
-
-- [Where is the data stored?](#where-is-the-data-stored)
-- [What does the key-value store contains?](#what-does-the-key-value-store-contains)
-    - [The inverted word index](#the-inverted-word-index)
-        - [A final state transducer](#a-final-state-transducer)
-        - [Document indexes](#document-indexes)
-    - [The schema](#the-schema)
-    - [Document attributes](#document-attributes)
-- [How is a request processed?](#how-is-a-request-processed)
-    - [Query lexemes](#query-lexemes)
-    - [Automatons and query index](#automatons-and-query-index)
-    - [Sort by criteria](#sort-by-criteria)
-
-<!-- /MarkdownTOC -->
-
-## Where is the data stored?
-
-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.
-
-
-
-## What does the key-value store contains?
-
-It contain the inverted word index, the schema and the documents fields.
-
-### The inverted word index
-
-[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
-
-_...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 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/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/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/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/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-core/src/lib.rs#L62-L88) associated to it, fields of the original document must be returned too.
-
-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.
-
-
-
-## How is a request processed?
-
-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/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 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/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/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/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/MeiliSearch/blob/3db823de002243004612e36a19b4578d800dab97/meilisearch-data/src/database/index.rs#L86).
-
-At this point, MeiliSearch work is over 🎉

download-latest.sh

@@ -0,0 +1,188 @@
+#!/bin/sh
+
+# COLORS
+RED='\033[31m'
+GREEN='\033[32m'
+DEFAULT='\033[0m'
+
+# GLOBALS
+BINARY_NAME='meilisearch'
+GREP_SEMVER_REGEXP='v\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)$' # i.e. v[number].[number].[number]
+
+# FUNCTIONS
+
+# semverParseInto and semverLT from https://github.com/cloudflare/semver_bash/blob/master/semver.sh
+
+# usage: semverParseInto version major minor patch special
+# version: the string version
+# major, minor, patch, special: will be assigned by the function
+semverParseInto() {
+    local RE='[^0-9]*\([0-9]*\)[.]\([0-9]*\)[.]\([0-9]*\)\([0-9A-Za-z-]*\)'
+    #MAJOR
+    eval $2=`echo $1 | sed -e "s#$RE#\1#"`
+    #MINOR
+    eval $3=`echo $1 | sed -e "s#$RE#\2#"`
+    #MINOR
+    eval $4=`echo $1 | sed -e "s#$RE#\3#"`
+    #SPECIAL
+    eval $5=`echo $1 | sed -e "s#$RE#\4#"`
+}
+
+# usage: semverLT version1 version2
+semverLT() {
+    local MAJOR_A=0
+    local MINOR_A=0
+    local PATCH_A=0
+    local SPECIAL_A=0
+
+    local MAJOR_B=0
+    local MINOR_B=0
+    local PATCH_B=0
+    local SPECIAL_B=0
+
+    semverParseInto $1 MAJOR_A MINOR_A PATCH_A SPECIAL_A
+    semverParseInto $2 MAJOR_B MINOR_B PATCH_B SPECIAL_B
+
+    if [ $MAJOR_A -lt $MAJOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -lt $MINOR_B ]; then
+        return 0
+    fi
+    if [ $MAJOR_A -le $MAJOR_B ] && [ $MINOR_A -le $MINOR_B ] && [ $PATCH_A -lt $PATCH_B ]; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  == "_" ] && [ "_$SPECIAL_B"  != "_" ] ; then
+        return 1
+    fi
+    if [ "_$SPECIAL_A"  != "_" ] && [ "_$SPECIAL_B"  == "_" ] ; then
+        return 0
+    fi
+    if [ "_$SPECIAL_A" < "_$SPECIAL_B" ]; then
+        return 0
+    fi
+
+    return 1
+}
+
+# Returns the tag of the latest stable release (in terms of semver and not of release date)
+get_latest() {
+    temp_file='temp_file' # temp_file needed because the grep would start before the download is over
+    curl -s 'https://api.github.com/repos/meilisearch/MeiliSearch/releases' > "$temp_file" || return 1
+    releases=$(cat "$temp_file" | \
+        grep -E "tag_name|draft|prerelease" \
+        | tr -d ',"' | cut -d ':' -f2 | tr -d ' ')
+        # Returns a list of [tag_name draft_boolean prerelease_boolean ...]
+        # Ex: v0.10.1 false false v0.9.1-rc.1 false true v0.9.0 false false...
+
+    i=0
+    latest=""
+    current_tag=""
+    for release_info in $releases; do
+        if [ $i -eq 0 ]; then # Cheking tag_name
+            if echo "$release_info" | grep -q "$GREP_SEMVER_REGEXP"; then # If it's not an alpha or beta release
+                current_tag=$release_info
+            else
+                current_tag=""
+            fi
+            i=1
+        elif [ $i -eq 1 ]; then # Checking draft boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=2
+        elif [ $i -eq 2 ]; then # Checking prerelease boolean
+            if [ "$release_info" = "true" ]; then
+                current_tag=""
+            fi
+            i=0
+            if [ "$current_tag" != "" ]; then # If the current_tag is valid
+                if [ "$latest" = "" ]; then # If there is no latest yet
+                    latest="$current_tag"
+                else
+                    semverLT $current_tag $latest # Comparing latest and the current tag
+                    if [ $? -eq 1 ]; then
+                        latest="$current_tag"
+                    fi
+                fi
+            fi
+        fi
+    done
+
+    rm -f "$temp_file"
+    echo $latest
+}
+
+# Gets the OS by setting the $os variable
+# Returns 0 in case of success, 1 otherwise.
+get_os() {
+    os_name=$(uname -s)
+    case "$os_name" in
+    'Darwin')
+        os='macos'
+        ;;
+    'Linux')
+        os='linux'
+        ;;
+    *)
+        return 1
+    esac
+    return 0
+}
+
+# Gets the architecture by setting the $archi variable
+# Returns 0 in case of success, 1 otherwise.
+get_archi() {
+    architecture=$(uname -m)
+    case "$architecture" in
+    'x86_64' | 'amd64')
+        archi='amd64'
+        ;;
+    'aarch64')
+        archi='armv8'
+        ;;
+    *)
+        return 1
+    esac
+    return 0
+}
+
+success_usage() {
+    printf "$GREEN%s\n$DEFAULT" "MeiliSearch binary successfully downloaded as '$BINARY_NAME' file."
+    echo ''
+    echo 'Run it:'
+    echo '    $ ./meilisearch'
+    echo 'Usage:'
+    echo '    $ ./meilisearch --help'
+}
+
+failure_usage() {
+    printf "$RED%s\n$DEFAULT" 'ERROR: MeiliSearch binary is not available for your OS distribution or your architecture yet.'
+    echo ''
+    echo 'However, you can easily compile the binary from the source files.'
+    echo 'Follow the steps at the page ("Source" tab): https://docs.meilisearch.com/guides/advanced_guides/installation.html'
+}
+
+# MAIN
+latest="$(get_latest)"
+
+if ! get_os; then
+    failure_usage
+    exit 1
+fi
+
+if ! get_archi; then
+    failure_usage
+    exit 1
+fi
+
+echo "Downloading MeiliSearch binary $latest for $os, architecture $archi..."
+release_file="meilisearch-$os-$archi"
+link="https://github.com/meilisearch/MeiliSearch/releases/download/$latest/$release_file"
+curl -OL "$link"
+mv "$release_file" "$BINARY_NAME"
+chmod 744 "$BINARY_NAME"
+success_usage

meilisearch-core/Cargo.toml

@@ -1,40 +1,53 @@
 [package]
 name = "meilisearch-core"
-version = "0.8.0"
+version = "0.19.0"
+license = "MIT"
 authors = ["Kerollmops <clement@meilisearch.com>"]
 edition = "2018"
 
 [dependencies]
-arc-swap = "0.4.3"
-bincode = "1.1.4"
-byteorder = "1.3.2"
-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"
-levenshtein_automata = { version = "0.1.1", features = ["fst_automaton"] }
-log = "0.4.8"
-meilisearch-schema = { path = "../meilisearch-schema", version = "0.8.0" }
-meilisearch-tokenizer = { path = "../meilisearch-tokenizer", version = "0.8.0" }
-meilisearch-types = { path = "../meilisearch-types", version = "0.8.0" }
-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.1"
+arc-swap = "1.2.0"
+bincode = "1.3.1"
+byteorder = "1.3.4"
+chrono = { version = "0.4.19", features = ["serde"] }
+compact_arena = "0.4.1"
+cow-utils = "0.1.2"
+crossbeam-channel = "0.5.0"
+deunicode = "1.1.1"
+either = "1.6.1"
+env_logger = "0.8.2"
+fst = "0.4.5"
+hashbrown = { version = "0.9.1", features = ["serde"] }
+heed = "0.10.6"
+indexmap = { version = "1.6.1", features = ["serde-1"] }
+intervaltree = "0.2.6"
+itertools = "0.10.0"
+levenshtein_automata = { version = "0.2.0", features = ["fst_automaton"] }
+log = "0.4.11"
+meilisearch-error = { path = "../meilisearch-error", version = "0.19.0" }
+meilisearch-schema = { path = "../meilisearch-schema", version = "0.19.0" }
+meilisearch-tokenizer = { git = "https://github.com/meilisearch/Tokenizer.git", tag = "v0.1.3" }
+meilisearch-types = { path = "../meilisearch-types", version = "0.19.0" }
+once_cell = "1.5.2"
+ordered-float = { version = "2.0.1", features = ["serde"] }
+pest = { git = "https://github.com/pest-parser/pest.git", rev = "51fd1d49f1041f7839975664ef71fe15c7dcaf67" }
+pest_derive = "2.1.0"
+regex = "1.4.2"
+sdset = "0.4.0"
+serde = { version = "1.0.118", features = ["derive"] }
+serde_json = { version = "1.0.61", features = ["preserve_order"] }
 slice-group-by = "0.2.6"
-zerocopy = "0.2.8"
+unicase = "2.6.0"
+zerocopy = "0.3.0"
 
 [dev-dependencies]
-assert_matches = "1.3"
-csv = "1.0.7"
-indexmap = { version = "1.2.0", features = ["serde-1"] }
-rustyline = { version = "5.0.0", default-features = false }
-structopt = "0.3.2"
+assert_matches = "1.4.0"
+criterion = "0.3.3"
+csv = "1.1.5"
+rustyline = { version = "7.1.0", default-features = false }
+structopt = "0.3.21"
 tempfile = "3.1.0"
-termcolor = "1.0.4"
-toml = "0.5.3"
+termcolor = "1.1.2"
+
+[target.'cfg(unix)'.dev-dependencies]
+jemallocator = "0.3.2"

meilisearch-core/examples/from_file.rs

@@ -1,7 +1,7 @@
-use std::collections::btree_map::{BTreeMap, Entry};
 use std::collections::HashSet;
+use std::collections::btree_map::{BTreeMap, Entry};
 use std::error::Error;
-use std::io::Write;
+use std::io::{Read, Write};
 use std::iter::FromIterator;
 use std::path::{Path, PathBuf};
 use std::time::{Duration, Instant};
@@ -12,8 +12,13 @@ use serde::{Deserialize, Serialize};
 use structopt::StructOpt;
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
-use meilisearch_core::{Database, Highlight, ProcessedUpdateResult};
-use meilisearch_schema::SchemaAttr;
+use meilisearch_core::{Database, DatabaseOptions, Highlight, ProcessedUpdateResult};
+use meilisearch_core::settings::Settings;
+use meilisearch_schema::FieldId;
+
+#[cfg(target_os = "linux")]
+#[global_allocator]
+static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 
 #[derive(Debug, StructOpt)]
 struct IndexCommand {
@@ -24,13 +29,13 @@ struct IndexCommand {
     #[structopt(long, default_value = "default")]
     index_uid: String,
 
-    /// The csv file to index.
+    /// The csv file path to index, you can also use `-` to specify the standard input.
     #[structopt(parse(from_os_str))]
     csv_data_path: PathBuf,
 
-    /// The path to the schema.
+    /// The path to the settings.
     #[structopt(long, parse(from_os_str))]
-    schema: PathBuf,
+    settings: PathBuf,
 
     #[structopt(long)]
     update_group_size: Option<usize>,
@@ -113,28 +118,23 @@ fn index_command(command: IndexCommand, database: Database) -> Result<(), Box<dy
 
     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 settings = {
+        let string = fs::read_to_string(&command.settings)?;
+        let settings: Settings = serde_json::from_str(&string).unwrap();
+        settings.to_update().unwrap()
     };
 
-    let mut writer = env.write_txn().unwrap();
-    match index.main.schema(&writer)? {
-        Some(current_schema) => {
-            if current_schema != schema {
-                return Err(meilisearch_core::Error::SchemaDiffer.into());
-            }
-            writer.abort();
-        }
-        None => {
-            index.schema_update(&mut writer, schema)?;
-            writer.commit().unwrap();
-        }
-    }
+    db.update_write(|w| index.settings_update(w, settings))?;
+
+    let mut rdr = if command.csv_data_path.as_os_str() == "-" {
+        csv::Reader::from_reader(Box::new(io::stdin()) as Box<dyn Read>)
+    } else {
+        let file = std::fs::File::open(command.csv_data_path)?;
+        csv::Reader::from_reader(Box::new(file) as Box<dyn Read>)
+    };
 
-    let mut rdr = csv::Reader::from_path(command.csv_data_path)?;
     let mut raw_record = csv::StringRecord::new();
     let headers = rdr.headers()?.clone();
 
@@ -173,10 +173,9 @@ fn index_command(command: IndexCommand, database: Database) -> Result<(), Box<dy
 
         println!();
 
-        let mut writer = env.write_txn().unwrap();
+        let update_id = db.update_write(|w| additions.finalize(w))?;
+
         println!("committing update...");
-        let update_id = additions.finalize(&mut writer)?;
-        writer.commit().unwrap();
         max_update_id = max_update_id.max(update_id);
         println!("committed update {}", update_id);
     }
@@ -316,14 +315,14 @@ 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_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();
+    reader.abort().unwrap();
 
     let schema = schema.ok_or(meilisearch_core::Error::SchemaMissing)?;
 
@@ -339,7 +338,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;
 
@@ -350,14 +349,14 @@ fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<
 
                 if let Some(ref filter) = command.filter {
                     let filter = filter.as_str();
-                    let (positive, filter) = if filter.chars().next() == Some('!') {
-                        (false, &filter[1..])
+                    let (positive, filter) = if let Some(stripped) = filter.strip_prefix('!') {
+                        (false, stripped)
                     } else {
                         (true, filter)
                     };
 
                     let attr = schema
-                        .attribute(&filter)
+                        .id(filter)
                         .expect("Could not find filtered attribute");
 
                     builder.with_filter(move |document_id| {
@@ -369,12 +368,12 @@ fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<
                     });
                 }
 
-                let documents = builder.query(ref_reader, &query, 0..command.number_results)?;
+                let result = builder.query(ref_reader, Some(&query), 0..command.number_results)?;
 
                 let mut retrieve_duration = Duration::default();
 
-                let number_of_documents = documents.len();
-                for mut doc in documents {
+                let number_of_documents = result.documents.len();
+                for mut doc in result.documents {
                     doc.highlights
                         .sort_unstable_by_key(|m| (m.char_index, m.char_length));
 
@@ -388,11 +387,11 @@ fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<
                             for (name, text) in document.0 {
                                 print!("{}: ", name);
 
-                                let attr = schema.attribute(&name).unwrap();
+                                let attr = schema.id(&name).unwrap();
                                 let highlights = doc
                                     .highlights
                                     .iter()
-                                    .filter(|m| SchemaAttr::new(m.attribute) == attr)
+                                    .filter(|m| FieldId::new(m.attribute) == attr)
                                     .cloned();
                                 let (text, highlights) =
                                     crop_text(&text, highlights, command.char_context);
@@ -407,8 +406,8 @@ fn search_command(command: SearchCommand, database: Database) -> Result<(), Box<
 
                     let mut matching_attributes = HashSet::new();
                     for highlight in doc.highlights {
-                        let attr = SchemaAttr::new(highlight.attribute);
-                        let name = schema.attribute_name(attr);
+                        let attr = FieldId::new(highlight.attribute);
+                        let name = schema.name(attr);
                         matching_attributes.insert(name);
                     }
 
@@ -444,15 +443,15 @@ 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_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();
+    reader.abort().unwrap();
 
     Ok(())
 }
@@ -461,7 +460,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     env_logger::init();
 
     let opt = Command::from_args();
-    let database = Database::open_or_create(opt.path())?;
+    let database = Database::open_or_create(opt.path(), DatabaseOptions::default())?;
 
     match opt {
         Command::Index(command) => index_command(command, database),

meilisearch-core/src/automaton/dfa.rs

@@ -46,3 +46,8 @@ pub fn build_prefix_dfa(query: &str) -> DFA {
 pub fn build_dfa(query: &str) -> DFA {
     build_dfa_with_setting(query, PrefixSetting::NoPrefix)
 }
+
+pub fn build_exact_dfa(query: &str) -> DFA {
+    let builder = LEVDIST0.get_or_init(|| LevBuilder::new(0, true));
+    builder.build_dfa(query)
+}

meilisearch-core/src/automaton/mod.rs

@@ -1,295 +1,4 @@
 mod dfa;
-mod query_enhancer;
 
-use std::cmp::Reverse;
-use std::{cmp, vec};
+pub use self::dfa::{build_dfa, build_prefix_dfa, build_exact_dfa};
 
-use fst::{IntoStreamer, Streamer};
-use levenshtein_automata::DFA;
-use meilisearch_tokenizer::{is_cjk, split_query_string};
-
-use crate::error::MResult;
-use crate::store;
-
-use self::dfa::{build_dfa, build_prefix_dfa};
-pub use self::query_enhancer::QueryEnhancer;
-use self::query_enhancer::QueryEnhancerBuilder;
-
-const NGRAMS: usize = 3;
-
-pub struct AutomatonProducer {
-    automatons: Vec<AutomatonGroup>,
-}
-
-impl AutomatonProducer {
-    pub fn new(
-        reader: &heed::RoTxn,
-        query: &str,
-        main_store: store::Main,
-        postings_list_store: store::PostingsLists,
-        synonyms_store: store::Synonyms,
-    ) -> MResult<(AutomatonProducer, QueryEnhancer)> {
-        let (automatons, query_enhancer) = generate_automatons(
-            reader,
-            query,
-            main_store,
-            postings_list_store,
-            synonyms_store,
-        )?;
-
-        Ok((AutomatonProducer { automatons }, query_enhancer))
-    }
-
-    pub fn into_iter(self) -> vec::IntoIter<AutomatonGroup> {
-        self.automatons.into_iter()
-    }
-}
-
-#[derive(Debug)]
-pub struct AutomatonGroup {
-    pub is_phrase_query: bool,
-    pub automatons: Vec<Automaton>,
-}
-
-impl AutomatonGroup {
-    fn normal(automatons: Vec<Automaton>) -> AutomatonGroup {
-        AutomatonGroup {
-            is_phrase_query: false,
-            automatons,
-        }
-    }
-
-    fn phrase_query(automatons: Vec<Automaton>) -> AutomatonGroup {
-        AutomatonGroup {
-            is_phrase_query: true,
-            automatons,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Automaton {
-    pub index: usize,
-    pub ngram: usize,
-    pub query_len: usize,
-    pub is_exact: bool,
-    pub is_prefix: bool,
-    pub query: String,
-}
-
-impl Automaton {
-    pub fn dfa(&self) -> DFA {
-        if self.is_prefix {
-            build_prefix_dfa(&self.query)
-        } else {
-            build_dfa(&self.query)
-        }
-    }
-
-    fn exact(index: usize, ngram: usize, query: &str) -> Automaton {
-        Automaton {
-            index,
-            ngram,
-            query_len: query.len(),
-            is_exact: true,
-            is_prefix: false,
-            query: query.to_string(),
-        }
-    }
-
-    fn prefix_exact(index: usize, ngram: usize, query: &str) -> Automaton {
-        Automaton {
-            index,
-            ngram,
-            query_len: query.len(),
-            is_exact: true,
-            is_prefix: true,
-            query: query.to_string(),
-        }
-    }
-
-    fn non_exact(index: usize, ngram: usize, query: &str) -> Automaton {
-        Automaton {
-            index,
-            ngram,
-            query_len: query.len(),
-            is_exact: false,
-            is_prefix: false,
-            query: query.to_string(),
-        }
-    }
-}
-
-pub fn normalize_str(string: &str) -> String {
-    let mut string = string.to_lowercase();
-
-    if !string.contains(is_cjk) {
-        string = deunicode::deunicode_with_tofu(&string, "");
-    }
-
-    string
-}
-
-fn split_best_frequency<'a>(
-    reader: &heed::RoTxn,
-    word: &'a str,
-    postings_lists_store: store::PostingsLists,
-) -> MResult<Option<(&'a str, &'a str)>> {
-    let chars = word.char_indices().skip(1);
-    let mut best = None;
-
-    for (i, _) in chars {
-        let (left, right) = word.split_at(i);
-
-        let left_freq = postings_lists_store
-            .postings_list(reader, left.as_ref())?
-            .map_or(0, |i| i.len());
-
-        let right_freq = postings_lists_store
-            .postings_list(reader, right.as_ref())?
-            .map_or(0, |i| i.len());
-
-        let min_freq = cmp::min(left_freq, right_freq);
-        if min_freq != 0 && best.map_or(true, |(old, _, _)| min_freq > old) {
-            best = Some((min_freq, left, right));
-        }
-    }
-
-    Ok(best.map(|(_, l, r)| (l, r)))
-}
-
-fn generate_automatons(
-    reader: &heed::RoTxn,
-    query: &str,
-    main_store: store::Main,
-    postings_lists_store: store::PostingsLists,
-    synonym_store: store::Synonyms,
-) -> MResult<(Vec<AutomatonGroup>, QueryEnhancer)> {
-    let has_end_whitespace = query.chars().last().map_or(false, char::is_whitespace);
-    let query_words: Vec<_> = split_query_string(query).map(str::to_lowercase).collect();
-    let synonyms = match main_store.synonyms_fst(reader)? {
-        Some(synonym) => synonym,
-        None => fst::Set::default(),
-    };
-
-    let mut automaton_index = 0;
-    let mut automatons = Vec::new();
-    let mut enhancer_builder = QueryEnhancerBuilder::new(&query_words);
-
-    // We must not declare the original words to the query enhancer
-    // *but* we need to push them in the automatons list first
-    let mut original_automatons = Vec::new();
-    let mut original_words = query_words.iter().peekable();
-    while let Some(word) = original_words.next() {
-        let has_following_word = original_words.peek().is_some();
-        let not_prefix_dfa = has_following_word || has_end_whitespace || word.chars().all(is_cjk);
-
-        let automaton = if not_prefix_dfa {
-            Automaton::exact(automaton_index, 1, word)
-        } else {
-            Automaton::prefix_exact(automaton_index, 1, word)
-        };
-        automaton_index += 1;
-        original_automatons.push(automaton);
-    }
-
-    automatons.push(AutomatonGroup::normal(original_automatons));
-
-    for n in 1..=NGRAMS {
-        let mut ngrams = query_words.windows(n).enumerate().peekable();
-        while let Some((query_index, ngram_slice)) = ngrams.next() {
-            let query_range = query_index..query_index + n;
-            let ngram_nb_words = ngram_slice.len();
-            let ngram = ngram_slice.join(" ");
-
-            let has_following_word = ngrams.peek().is_some();
-            let not_prefix_dfa =
-                has_following_word || has_end_whitespace || ngram.chars().all(is_cjk);
-
-            // automaton of synonyms of the ngrams
-            let normalized = normalize_str(&ngram);
-            let lev = if not_prefix_dfa {
-                build_dfa(&normalized)
-            } else {
-                build_prefix_dfa(&normalized)
-            };
-
-            let mut stream = synonyms.search(&lev).into_stream();
-            while let Some(base) = stream.next() {
-                // only trigger alternatives when the last word has been typed
-                // i.e. "new " do not but "new yo" triggers alternatives to "new york"
-                let base = std::str::from_utf8(base).unwrap();
-                let base_nb_words = split_query_string(base).count();
-                if ngram_nb_words != base_nb_words {
-                    continue;
-                }
-
-                if let Some(synonyms) = synonym_store.synonyms(reader, base.as_bytes())? {
-                    let mut stream = synonyms.into_stream();
-                    while let Some(synonyms) = stream.next() {
-                        let synonyms = std::str::from_utf8(synonyms).unwrap();
-                        let synonyms_words: Vec<_> = split_query_string(synonyms).collect();
-                        let nb_synonym_words = synonyms_words.len();
-
-                        let real_query_index = automaton_index;
-                        enhancer_builder.declare(
-                            query_range.clone(),
-                            real_query_index,
-                            &synonyms_words,
-                        );
-
-                        for synonym in synonyms_words {
-                            let automaton = if nb_synonym_words == 1 {
-                                Automaton::exact(automaton_index, n, synonym)
-                            } else {
-                                Automaton::non_exact(automaton_index, n, synonym)
-                            };
-                            automaton_index += 1;
-                            automatons.push(AutomatonGroup::normal(vec![automaton]));
-                        }
-                    }
-                }
-            }
-
-            if n == 1 {
-                if let Some((left, right)) =
-                    split_best_frequency(reader, &normalized, postings_lists_store)?
-                {
-                    let a = Automaton::exact(automaton_index, 1, left);
-                    enhancer_builder.declare(query_range.clone(), automaton_index, &[left]);
-                    automaton_index += 1;
-
-                    let b = Automaton::exact(automaton_index, 1, right);
-                    enhancer_builder.declare(query_range.clone(), automaton_index, &[left]);
-                    automaton_index += 1;
-
-                    automatons.push(AutomatonGroup::phrase_query(vec![a, b]));
-                }
-            } else {
-                // automaton of concatenation of query words
-                let concat = ngram_slice.concat();
-                let normalized = normalize_str(&concat);
-
-                let real_query_index = automaton_index;
-                enhancer_builder.declare(query_range.clone(), real_query_index, &[&normalized]);
-
-                let automaton = Automaton::exact(automaton_index, n, &normalized);
-                automaton_index += 1;
-                automatons.push(AutomatonGroup::normal(vec![automaton]));
-            }
-        }
-    }
-
-    // order automatons, the most important first,
-    // we keep the original automatons at the front.
-    automatons[1..].sort_by_key(|group| {
-        let a = group.automatons.first().unwrap();
-        (
-            Reverse(a.is_exact),
-            a.ngram,
-            Reverse(group.automatons.len()),
-        )
-    });
-
-    Ok((automatons, enhancer_builder.build()))
-}

meilisearch-core/src/automaton/query_enhancer.rs

@@ -1,423 +0,0 @@
-use std::cmp::Ordering::{Equal, Greater, Less};
-use std::ops::Range;
-
-/// Return `true` if the specified range can accept the given replacements words.
-/// Returns `false` if the replacements words are already present in the original query
-/// or if there is fewer replacement words than the range to replace.
-//
-//
-// ## Ignored because already present in original
-//
-//     new york city subway
-//     -------- ^^^^
-//   /          \
-//  [new york city]
-//
-//
-// ## Ignored because smaller than the original
-//
-//   new york city subway
-//   -------------
-//   \          /
-//    [new york]
-//
-//
-// ## Accepted because bigger than the original
-//
-//        NYC subway
-//        ---
-//       /   \
-//      /     \
-//     /       \
-//    /         \
-//   /           \
-//  [new york city]
-//
-fn rewrite_range_with<S, T>(query: &[S], range: Range<usize>, words: &[T]) -> bool
-where
-    S: AsRef<str>,
-    T: AsRef<str>,
-{
-    if words.len() <= range.len() {
-        // there is fewer or equal replacement words
-        // than there is already in the replaced range
-        return false;
-    }
-
-    // retrieve the part to rewrite but with the length
-    // of the replacement part
-    let original = query.iter().skip(range.start).take(words.len());
-
-    // check if the original query doesn't already contain
-    // the replacement words
-    !original
-        .map(AsRef::as_ref)
-        .eq(words.iter().map(AsRef::as_ref))
-}
-
-type Origin = usize;
-type RealLength = usize;
-
-struct FakeIntervalTree {
-    intervals: Vec<(Range<usize>, (Origin, RealLength))>,
-}
-
-impl FakeIntervalTree {
-    fn new(mut intervals: Vec<(Range<usize>, (Origin, RealLength))>) -> FakeIntervalTree {
-        intervals.sort_unstable_by_key(|(r, _)| (r.start, r.end));
-        FakeIntervalTree { intervals }
-    }
-
-    fn query(&self, point: usize) -> Option<(Range<usize>, (Origin, RealLength))> {
-        let element = self.intervals.binary_search_by(|(r, _)| {
-            if point >= r.start {
-                if point < r.end {
-                    Equal
-                } else {
-                    Less
-                }
-            } else {
-                Greater
-            }
-        });
-
-        let n = match element {
-            Ok(n) => n,
-            Err(n) => n,
-        };
-
-        match self.intervals.get(n) {
-            Some((range, value)) if range.contains(&point) => Some((range.clone(), *value)),
-            _otherwise => None,
-        }
-    }
-}
-
-pub struct QueryEnhancerBuilder<'a, S> {
-    query: &'a [S],
-    origins: Vec<usize>,
-    real_to_origin: Vec<(Range<usize>, (Origin, RealLength))>,
-}
-
-impl<S: AsRef<str>> QueryEnhancerBuilder<'_, S> {
-    pub fn new(query: &[S]) -> QueryEnhancerBuilder<S> {
-        // we initialize origins query indices based on their positions
-        let origins: Vec<_> = (0..=query.len()).collect();
-        let real_to_origin = origins.iter().map(|&o| (o..o + 1, (o, 1))).collect();
-
-        QueryEnhancerBuilder {
-            query,
-            origins,
-            real_to_origin,
-        }
-    }
-
-    /// Update the final real to origin query indices mapping.
-    ///
-    /// `range` is the original words range that this `replacement` words replace
-    /// and `real` is the first real query index of these replacement words.
-    pub fn declare<T>(&mut self, range: Range<usize>, real: usize, replacement: &[T])
-    where
-        T: AsRef<str>,
-    {
-        // check if the range of original words
-        // can be rewritten with the replacement words
-        if rewrite_range_with(self.query, range.clone(), replacement) {
-            // this range can be replaced so we need to
-            // modify the origins accordingly
-            let offset = replacement.len() - range.len();
-
-            let previous_padding = self.origins[range.end - 1];
-            let current_offset = (self.origins[range.end] - 1) - previous_padding;
-            let diff = offset.saturating_sub(current_offset);
-            self.origins[range.end] += diff;
-
-            for r in &mut self.origins[range.end + 1..] {
-                *r += diff;
-            }
-        }
-
-        // we need to store the real number and origins relations
-        // this way it will be possible to know by how many
-        // we need to pad real query indices
-        let real_range = real..real + replacement.len().max(range.len());
-        let real_length = replacement.len();
-        self.real_to_origin
-            .push((real_range, (range.start, real_length)));
-    }
-
-    pub fn build(self) -> QueryEnhancer {
-        QueryEnhancer {
-            origins: self.origins,
-            real_to_origin: FakeIntervalTree::new(self.real_to_origin),
-        }
-    }
-}
-
-pub struct QueryEnhancer {
-    origins: Vec<usize>,
-    real_to_origin: FakeIntervalTree,
-}
-
-impl QueryEnhancer {
-    /// Returns the query indices to use to replace this real query index.
-    pub fn replacement(&self, real: u32) -> Range<u32> {
-        let real = real as usize;
-
-        // query the fake interval tree with the real query index
-        let (range, (origin, real_length)) = self
-            .real_to_origin
-            .query(real)
-            .expect("real has never been declared");
-
-        // if `real` is the end bound of the range
-        if (range.start + real_length - 1) == real {
-            let mut count = range.len();
-            let mut new_origin = origin;
-            for (i, slice) in self.origins[new_origin..].windows(2).enumerate() {
-                let len = slice[1] - slice[0];
-                count = count.saturating_sub(len);
-                if count == 0 {
-                    new_origin = origin + i;
-                    break;
-                }
-            }
-
-            let n = real - range.start;
-            let start = self.origins[origin];
-            let end = self.origins[new_origin + 1];
-            let remaining = (end - start) - n;
-
-            Range {
-                start: (start + n) as u32,
-                end: (start + n + remaining) as u32,
-            }
-        } else {
-            // just return the origin along with
-            // the real position of the word
-            let n = real as usize - range.start;
-            let origin = self.origins[origin];
-
-            Range {
-                start: (origin + n) as u32,
-                end: (origin + n + 1) as u32,
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn original_unmodified() {
-        let query = ["new", "york", "city", "subway"];
-        //             0       1       2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // new york = new york city
-        builder.declare(0..2, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // new
-        assert_eq!(enhancer.replacement(1), 1..2); // york
-        assert_eq!(enhancer.replacement(2), 2..3); // city
-        assert_eq!(enhancer.replacement(3), 3..4); // subway
-        assert_eq!(enhancer.replacement(4), 0..1); // new
-        assert_eq!(enhancer.replacement(5), 1..2); // york
-        assert_eq!(enhancer.replacement(6), 2..3); // city
-    }
-
-    #[test]
-    fn simple_growing() {
-        let query = ["new", "york", "subway"];
-        //             0       1        2
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // new york = new york city
-        builder.declare(0..2, 3, &["new", "york", "city"]);
-        //                    ^      3       4       5
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // new
-        assert_eq!(enhancer.replacement(1), 1..3); // york
-        assert_eq!(enhancer.replacement(2), 3..4); // subway
-        assert_eq!(enhancer.replacement(3), 0..1); // new
-        assert_eq!(enhancer.replacement(4), 1..2); // york
-        assert_eq!(enhancer.replacement(5), 2..3); // city
-    }
-
-    #[test]
-    fn same_place_growings() {
-        let query = ["NY", "subway"];
-        //             0       1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NY = new york
-        builder.declare(0..1, 2, &["new", "york"]);
-        //                    ^      2       3
-
-        // NY = new york city
-        builder.declare(0..1, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // NY = NYC
-        builder.declare(0..1, 7, &["NYC"]);
-        //                    ^      7
-
-        // NY = new york city
-        builder.declare(0..1, 8, &["new", "york", "city"]);
-        //                    ^      8       9      10
-
-        // subway = underground train
-        builder.declare(1..2, 11, &["underground", "train"]);
-        //                    ^          11          12
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..3); // NY
-        assert_eq!(enhancer.replacement(1), 3..5); // subway
-        assert_eq!(enhancer.replacement(2), 0..1); // new
-        assert_eq!(enhancer.replacement(3), 1..3); // york
-        assert_eq!(enhancer.replacement(4), 0..1); // new
-        assert_eq!(enhancer.replacement(5), 1..2); // york
-        assert_eq!(enhancer.replacement(6), 2..3); // city
-        assert_eq!(enhancer.replacement(7), 0..3); // NYC
-        assert_eq!(enhancer.replacement(8), 0..1); // new
-        assert_eq!(enhancer.replacement(9), 1..2); // york
-        assert_eq!(enhancer.replacement(10), 2..3); // city
-        assert_eq!(enhancer.replacement(11), 3..4); // underground
-        assert_eq!(enhancer.replacement(12), 4..5); // train
-    }
-
-    #[test]
-    fn bigger_growing() {
-        let query = ["NYC", "subway"];
-        //             0        1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(0..1, 2, &["new", "york", "city"]);
-        //                    ^      2       3       4
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..3); // NYC
-        assert_eq!(enhancer.replacement(1), 3..4); // subway
-        assert_eq!(enhancer.replacement(2), 0..1); // new
-        assert_eq!(enhancer.replacement(3), 1..2); // york
-        assert_eq!(enhancer.replacement(4), 2..3); // city
-    }
-
-    #[test]
-    fn middle_query_growing() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // great
-        assert_eq!(enhancer.replacement(1), 1..2); // awesome
-        assert_eq!(enhancer.replacement(2), 2..5); // NYC
-        assert_eq!(enhancer.replacement(3), 5..6); // subway
-        assert_eq!(enhancer.replacement(4), 2..3); // new
-        assert_eq!(enhancer.replacement(5), 3..4); // york
-        assert_eq!(enhancer.replacement(6), 4..5); // city
-    }
-
-    #[test]
-    fn end_query_growing() {
-        let query = ["NYC", "subway"];
-        //             0        1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(1..2, 2, &["underground", "train"]);
-        //                    ^         2            3
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // NYC
-        assert_eq!(enhancer.replacement(1), 1..3); // subway
-        assert_eq!(enhancer.replacement(2), 1..2); // underground
-        assert_eq!(enhancer.replacement(3), 2..3); // train
-    }
-
-    #[test]
-    fn multiple_growings() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // subway = underground train
-        builder.declare(3..4, 7, &["underground", "train"]);
-        //                    ^          7           8
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // great
-        assert_eq!(enhancer.replacement(1), 1..2); // awesome
-        assert_eq!(enhancer.replacement(2), 2..5); // NYC
-        assert_eq!(enhancer.replacement(3), 5..7); // subway
-        assert_eq!(enhancer.replacement(4), 2..3); // new
-        assert_eq!(enhancer.replacement(5), 3..4); // york
-        assert_eq!(enhancer.replacement(6), 4..5); // city
-        assert_eq!(enhancer.replacement(7), 5..6); // underground
-        assert_eq!(enhancer.replacement(8), 6..7); // train
-    }
-
-    #[test]
-    fn multiple_probable_growings() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // subway = underground train
-        builder.declare(3..4, 7, &["underground", "train"]);
-        //                    ^          7           8
-
-        // great awesome = good
-        builder.declare(0..2, 9, &["good"]);
-        //                    ^       9
-
-        // awesome NYC = NY
-        builder.declare(1..3, 10, &["NY"]);
-        //                    ^^     10
-
-        // NYC subway = metro
-        builder.declare(2..4, 11, &["metro"]);
-        //                    ^^      11
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // great
-        assert_eq!(enhancer.replacement(1), 1..2); // awesome
-        assert_eq!(enhancer.replacement(2), 2..5); // NYC
-        assert_eq!(enhancer.replacement(3), 5..7); // subway
-        assert_eq!(enhancer.replacement(4), 2..3); // new
-        assert_eq!(enhancer.replacement(5), 3..4); // york
-        assert_eq!(enhancer.replacement(6), 4..5); // city
-        assert_eq!(enhancer.replacement(7), 5..6); // underground
-        assert_eq!(enhancer.replacement(8), 6..7); // train
-        assert_eq!(enhancer.replacement(9), 0..2); // good
-        assert_eq!(enhancer.replacement(10), 1..5); // NY
-        assert_eq!(enhancer.replacement(11), 2..5); // metro
-    }
-}

meilisearch-core/src/bucket_sort.rs

@@ -0,0 +1,679 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::mem;
+use std::ops::Deref;
+use std::ops::Range;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Instant;
+use std::fmt;
+
+use compact_arena::{SmallArena, Idx32, mk_arena};
+use log::{debug, error};
+use sdset::{Set, SetBuf, exponential_search, SetOperation, Counter, duo::OpBuilder};
+use slice_group_by::{GroupBy, GroupByMut};
+
+use meilisearch_types::DocIndex;
+
+use crate::criterion::{Criteria, Context, ContextMut};
+use crate::distinct_map::{BufferedDistinctMap, DistinctMap};
+use crate::raw_document::RawDocument;
+use crate::{database::MainT, reordered_attrs::ReorderedAttrs};
+use crate::{store, Document, DocumentId, MResult, Index, RankedMap, MainReader, Error};
+use crate::query_tree::{create_query_tree, traverse_query_tree};
+use crate::query_tree::{Operation, QueryResult, QueryKind, QueryId, PostingsKey};
+use crate::query_tree::Context as QTContext;
+
+#[derive(Debug, Default)]
+pub struct SortResult {
+    pub documents: Vec<Document>,
+    pub nb_hits: usize,
+    pub exhaustive_nb_hit: bool,
+    pub facets: Option<HashMap<String, HashMap<String, usize>>>,
+    pub exhaustive_facets_count: Option<bool>,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn bucket_sort<'c, FI>(
+    reader: &heed::RoTxn<MainT>,
+    query: &str,
+    range: Range<usize>,
+    facets_docids: Option<SetBuf<DocumentId>>,
+    facet_count_docids: Option<HashMap<String, HashMap<String, (&str, Cow<Set<DocumentId>>)>>>,
+    filter: Option<FI>,
+    criteria: Criteria<'c>,
+    searchable_attrs: Option<ReorderedAttrs>,
+    index: &Index,
+) -> MResult<SortResult>
+where
+    FI: Fn(DocumentId) -> bool,
+{
+    // We delegate the filter work to the distinct query builder,
+    // specifying a distinct rule that has no effect.
+    if filter.is_some() {
+        let distinct = |_| None;
+        let distinct_size = 1;
+        return bucket_sort_with_distinct(
+            reader,
+            query,
+            range,
+            facets_docids,
+            facet_count_docids,
+            filter,
+            distinct,
+            distinct_size,
+            criteria,
+            searchable_attrs,
+            index,
+        );
+    }
+
+    let mut result = SortResult::default();
+
+    let words_set = index.main.words_fst(reader)?;
+    let stop_words = index.main.stop_words_fst(reader)?;
+
+    let context = QTContext {
+        words_set,
+        stop_words,
+        synonyms: index.synonyms,
+        postings_lists: index.postings_lists,
+        prefix_postings_lists: index.prefix_postings_lists_cache,
+    };
+
+    let (operation, mapping) = create_query_tree(reader, &context, query)?;
+    debug!("operation:\n{:?}", operation);
+    debug!("mapping:\n{:?}", mapping);
+
+    fn recurs_operation<'o>(map: &mut HashMap<QueryId, &'o QueryKind>, operation: &'o Operation) {
+        match operation {
+            Operation::And(ops) => ops.iter().for_each(|op| recurs_operation(map, op)),
+            Operation::Or(ops) => ops.iter().for_each(|op| recurs_operation(map, op)),
+            Operation::Query(query) => { map.insert(query.id, &query.kind); },
+        }
+    }
+
+    let mut queries_kinds = HashMap::new();
+    recurs_operation(&mut queries_kinds, &operation);
+
+    let QueryResult { mut docids, queries } = traverse_query_tree(reader, &context, &operation)?;
+    debug!("found {} documents", docids.len());
+    debug!("number of postings {:?}", queries.len());
+
+    if let Some(facets_docids) = facets_docids {
+        let intersection = sdset::duo::OpBuilder::new(docids.as_ref(), facets_docids.as_set())
+            .intersection()
+            .into_set_buf();
+        docids = Cow::Owned(intersection);
+    }
+
+    if let Some(f) = facet_count_docids {
+        // hardcoded value, until approximation optimization
+        result.exhaustive_facets_count = Some(true);
+        result.facets = Some(facet_count(f, &docids));
+    }
+
+    let before = Instant::now();
+    mk_arena!(arena);
+    let mut bare_matches = cleanup_bare_matches(&mut arena, &docids, queries);
+    debug!("matches cleaned in {:.02?}", before.elapsed());
+
+    let before_bucket_sort = Instant::now();
+
+    let before_raw_documents_building = Instant::now();
+    let mut raw_documents = Vec::new();
+    for bare_matches in bare_matches.linear_group_by_key_mut(|sm| sm.document_id) {
+        let raw_document = RawDocument::new(bare_matches, &mut arena, searchable_attrs.as_ref());
+        raw_documents.push(raw_document);
+    }
+    debug!("creating {} candidates documents took {:.02?}",
+        raw_documents.len(),
+        before_raw_documents_building.elapsed(),
+    );
+
+    let before_criterion_loop = Instant::now();
+    let proximity_count = AtomicUsize::new(0);
+
+    let mut groups = vec![raw_documents.as_mut_slice()];
+
+    'criteria: for criterion in criteria.as_ref() {
+        let tmp_groups = mem::replace(&mut groups, Vec::new());
+        let mut documents_seen = 0;
+
+        for mut group in tmp_groups {
+            let before_criterion_preparation = Instant::now();
+
+            let ctx = ContextMut {
+                reader,
+                postings_lists: &mut arena,
+                query_mapping: &mapping,
+                documents_fields_counts_store: index.documents_fields_counts,
+            };
+
+            criterion.prepare(ctx, &mut group)?;
+            debug!("{:?} preparation took {:.02?}", criterion.name(), before_criterion_preparation.elapsed());
+
+            let ctx = Context {
+                postings_lists: &arena,
+                query_mapping: &mapping,
+            };
+
+            let before_criterion_sort = Instant::now();
+            group.sort_unstable_by(|a, b| criterion.evaluate(&ctx, a, b));
+            debug!("{:?} evaluation took {:.02?}", criterion.name(), before_criterion_sort.elapsed());
+
+            for group in group.binary_group_by_mut(|a, b| criterion.eq(&ctx, a, b)) {
+                debug!("{:?} produced a group of size {}", criterion.name(), group.len());
+
+                documents_seen += group.len();
+                groups.push(group);
+
+                // we have sort enough documents if the last document sorted is after
+                // the end of the requested range, we can continue to the next criterion
+                if documents_seen >= range.end {
+                    continue 'criteria;
+                }
+            }
+        }
+    }
+
+    debug!("criterion loop took {:.02?}", before_criterion_loop.elapsed());
+    debug!("proximity evaluation called {} times", proximity_count.load(Ordering::Relaxed));
+
+    let schema = index.main.schema(reader)?.ok_or(Error::SchemaMissing)?;
+    let iter = raw_documents.into_iter().skip(range.start).take(range.len());
+    let iter = iter.map(|rd| Document::from_raw(rd, &queries_kinds, &arena, searchable_attrs.as_ref(), &schema));
+    let documents = iter.collect();
+
+    debug!("bucket sort took {:.02?}", before_bucket_sort.elapsed());
+
+    result.documents = documents;
+    result.nb_hits = docids.len();
+
+    Ok(result)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn bucket_sort_with_distinct<'c, FI, FD>(
+    reader: &heed::RoTxn<MainT>,
+    query: &str,
+    range: Range<usize>,
+    facets_docids: Option<SetBuf<DocumentId>>,
+    facet_count_docids: Option<HashMap<String, HashMap<String, (&str, Cow<Set<DocumentId>>)>>>,
+    filter: Option<FI>,
+    distinct: FD,
+    distinct_size: usize,
+    criteria: Criteria<'c>,
+    searchable_attrs: Option<ReorderedAttrs>,
+    index: &Index,
+) -> MResult<SortResult>
+where
+    FI: Fn(DocumentId) -> bool,
+    FD: Fn(DocumentId) -> Option<u64>,
+{
+    let mut result = SortResult::default();
+    let mut filtered_count = 0;
+
+    let words_set = index.main.words_fst(reader)?;
+    let stop_words = index.main.stop_words_fst(reader)?;
+
+    let context = QTContext {
+        words_set,
+        stop_words,
+        synonyms: index.synonyms,
+        postings_lists: index.postings_lists,
+        prefix_postings_lists: index.prefix_postings_lists_cache,
+    };
+
+    let (operation, mapping) = create_query_tree(reader, &context, query)?;
+    debug!("operation:\n{:?}", operation);
+    debug!("mapping:\n{:?}", mapping);
+
+    fn recurs_operation<'o>(map: &mut HashMap<QueryId, &'o QueryKind>, operation: &'o Operation) {
+        match operation {
+            Operation::And(ops) => ops.iter().for_each(|op| recurs_operation(map, op)),
+            Operation::Or(ops) => ops.iter().for_each(|op| recurs_operation(map, op)),
+            Operation::Query(query) => { map.insert(query.id, &query.kind); },
+        }
+    }
+
+    let mut queries_kinds = HashMap::new();
+    recurs_operation(&mut queries_kinds, &operation);
+
+    let QueryResult { mut docids, queries } = traverse_query_tree(reader, &context, &operation)?;
+    debug!("found {} documents", docids.len());
+    debug!("number of postings {:?}", queries.len());
+
+    if let Some(facets_docids) = facets_docids {
+        let intersection = OpBuilder::new(docids.as_ref(), facets_docids.as_set())
+            .intersection()
+            .into_set_buf();
+        docids = Cow::Owned(intersection);
+    }
+
+    if let Some(f) = facet_count_docids {
+        // hardcoded value, until approximation optimization
+        result.exhaustive_facets_count = Some(true);
+        result.facets = Some(facet_count(f, &docids));
+    }
+
+    let before = Instant::now();
+    mk_arena!(arena);
+    let mut bare_matches = cleanup_bare_matches(&mut arena, &docids, queries);
+    debug!("matches cleaned in {:.02?}", before.elapsed());
+
+    let before_raw_documents_building = Instant::now();
+    let mut raw_documents = Vec::new();
+    for bare_matches in bare_matches.linear_group_by_key_mut(|sm| sm.document_id) {
+        let raw_document = RawDocument::new(bare_matches, &mut arena, searchable_attrs.as_ref());
+        raw_documents.push(raw_document);
+    }
+    debug!("creating {} candidates documents took {:.02?}",
+        raw_documents.len(),
+        before_raw_documents_building.elapsed(),
+    );
+
+    let mut groups = vec![raw_documents.as_mut_slice()];
+    let mut key_cache = HashMap::new();
+
+    let mut filter_map = HashMap::new();
+    // these two variables informs on the current distinct map and
+    // on the raw offset of the start of the group where the
+    // range.start bound is located according to the distinct function
+    let mut distinct_map = DistinctMap::new(distinct_size);
+    let mut distinct_raw_offset = 0;
+
+    'criteria: for criterion in criteria.as_ref() {
+        let tmp_groups = mem::replace(&mut groups, Vec::new());
+        let mut buf_distinct = BufferedDistinctMap::new(&mut distinct_map);
+        let mut documents_seen = 0;
+
+        for mut group in tmp_groups {
+            // if this group does not overlap with the requested range,
+            // push it without sorting and splitting it
+            if documents_seen + group.len() < distinct_raw_offset {
+                documents_seen += group.len();
+                groups.push(group);
+                continue;
+            }
+
+            let ctx = ContextMut {
+                reader,
+                postings_lists: &mut arena,
+                query_mapping: &mapping,
+                documents_fields_counts_store: index.documents_fields_counts,
+            };
+
+            let before_criterion_preparation = Instant::now();
+            criterion.prepare(ctx, &mut group)?;
+            debug!("{:?} preparation took {:.02?}", criterion.name(), before_criterion_preparation.elapsed());
+
+            let ctx = Context {
+                postings_lists: &arena,
+                query_mapping: &mapping,
+            };
+
+            let before_criterion_sort = Instant::now();
+            group.sort_unstable_by(|a, b| criterion.evaluate(&ctx, a, b));
+            debug!("{:?} evaluation took {:.02?}", criterion.name(), before_criterion_sort.elapsed());
+
+            for group in group.binary_group_by_mut(|a, b| criterion.eq(&ctx, a, b)) {
+                // we must compute the real distinguished len of this sub-group
+                for document in group.iter() {
+                    let filter_accepted = match &filter {
+                        Some(filter) => {
+                            let entry = filter_map.entry(document.id);
+                            *entry.or_insert_with(|| {
+                                let accepted = (filter)(document.id);
+                                // we only want to count it out the first time we see it
+                                if !accepted {
+                                    filtered_count += 1;
+                                }
+                                accepted
+                            })
+                        }
+                        None => true,
+                    };
+
+                    if filter_accepted {
+                        let entry = key_cache.entry(document.id);
+                        let mut seen = true;
+                        let key = entry.or_insert_with(|| {
+                            seen = false;
+                            (distinct)(document.id).map(Rc::new)
+                        });
+
+                        let distinct = match key.clone() {
+                            Some(key) => buf_distinct.register(key),
+                            None => buf_distinct.register_without_key(),
+                        };
+
+                        // we only want to count the document if it is the first time we see it and
+                        // if it wasn't accepted by distinct
+                        if !seen && !distinct {
+                            filtered_count += 1;
+                        }
+                    }
+
+                    // the requested range end is reached: stop computing distinct
+                    if buf_distinct.len() >= range.end {
+                        break;
+                    }
+                }
+
+                documents_seen += group.len();
+                groups.push(group);
+
+                // if this sub-group does not overlap with the requested range
+                // we must update the distinct map and its start index
+                if buf_distinct.len() < range.start {
+                    buf_distinct.transfert_to_internal();
+                    distinct_raw_offset = documents_seen;
+                }
+
+                // we have sort enough documents if the last document sorted is after
+                // the end of the requested range, we can continue to the next criterion
+                if buf_distinct.len() >= range.end {
+                    continue 'criteria;
+                }
+            }
+        }
+    }
+
+    // once we classified the documents related to the current
+    // automatons we save that as the next valid result
+    let mut seen = BufferedDistinctMap::new(&mut distinct_map);
+    let schema = index.main.schema(reader)?.ok_or(Error::SchemaMissing)?;
+
+    let mut documents = Vec::with_capacity(range.len());
+    for raw_document in raw_documents.into_iter().skip(distinct_raw_offset) {
+        let filter_accepted = match &filter {
+            Some(_) => filter_map.remove(&raw_document.id).unwrap_or_else(|| {
+                error!("error during filtering: expected value for document id {}", &raw_document.id.0);
+                Default::default()
+            }),
+            None => true,
+        };
+
+        if filter_accepted {
+            let key = key_cache.remove(&raw_document.id).unwrap_or_else(|| {
+                error!("error during distinct: expected value for document id {}", &raw_document.id.0);
+                Default::default()
+            });
+            let distinct_accepted = match key {
+                Some(key) => seen.register(key),
+                None => seen.register_without_key(),
+            };
+
+            if distinct_accepted && seen.len() > range.start {
+                documents.push(Document::from_raw(raw_document, &queries_kinds, &arena, searchable_attrs.as_ref(), &schema));
+                if documents.len() == range.len() {
+                    break;
+                }
+            }
+        }
+    }
+    result.documents = documents;
+    result.nb_hits = docids.len() - filtered_count;
+
+    Ok(result)
+}
+
+fn cleanup_bare_matches<'tag, 'txn>(
+    arena: &mut SmallArena<'tag, PostingsListView<'txn>>,
+    docids: &Set<DocumentId>,
+    queries: HashMap<PostingsKey, Cow<'txn, Set<DocIndex>>>,
+) -> Vec<BareMatch<'tag>>
+{
+    let docidslen = docids.len() as f32;
+    let mut bare_matches = Vec::new();
+
+    for (PostingsKey { query, input, distance, is_exact }, matches) in queries {
+        let postings_list_view = PostingsListView::original(Rc::from(input), Rc::new(matches));
+        let pllen = postings_list_view.len() as f32;
+
+        if docidslen / pllen >= 0.8 {
+            let mut offset = 0;
+            for matches in postings_list_view.linear_group_by_key(|m| m.document_id) {
+                let document_id = matches[0].document_id;
+                if docids.contains(&document_id) {
+                    let range = postings_list_view.range(offset, matches.len());
+                    let posting_list_index = arena.add(range);
+
+                    let bare_match = BareMatch {
+                        document_id,
+                        query_index: query.id,
+                        distance,
+                        is_exact,
+                        postings_list: posting_list_index,
+                    };
+
+                    bare_matches.push(bare_match);
+                }
+
+                offset += matches.len();
+            }
+
+        } else {
+            let mut offset = 0;
+            for id in docids.as_slice() {
+                let di = DocIndex { document_id: *id, ..DocIndex::default() };
+                let pos = exponential_search(&postings_list_view[offset..], &di).unwrap_or_else(|x| x);
+
+                offset += pos;
+
+                let group = postings_list_view[offset..]
+                    .linear_group_by_key(|m| m.document_id)
+                    .next()
+                    .filter(|matches| matches[0].document_id == *id);
+
+                if let Some(matches) = group {
+                    let range = postings_list_view.range(offset, matches.len());
+                    let posting_list_index = arena.add(range);
+
+                    let bare_match = BareMatch {
+                        document_id: *id,
+                        query_index: query.id,
+                        distance,
+                        is_exact,
+                        postings_list: posting_list_index,
+                    };
+
+                    bare_matches.push(bare_match);
+                }
+            }
+        }
+    }
+
+    let before_raw_documents_presort = Instant::now();
+    bare_matches.sort_unstable_by_key(|sm| sm.document_id);
+    debug!("sort by documents ids took {:.02?}", before_raw_documents_presort.elapsed());
+
+    bare_matches
+}
+
+pub struct BareMatch<'tag> {
+    pub document_id: DocumentId,
+    pub query_index: usize,
+    pub distance: u8,
+    pub is_exact: bool,
+    pub postings_list: Idx32<'tag>,
+}
+
+impl fmt::Debug for BareMatch<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("BareMatch")
+            .field("document_id", &self.document_id)
+            .field("query_index", &self.query_index)
+            .field("distance", &self.distance)
+            .field("is_exact", &self.is_exact)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct SimpleMatch {
+    pub query_index: usize,
+    pub distance: u8,
+    pub attribute: u16,
+    pub word_index: u16,
+    pub is_exact: bool,
+}
+
+#[derive(Clone)]
+pub enum PostingsListView<'txn> {
+    Original {
+        input: Rc<[u8]>,
+        postings_list: Rc<Cow<'txn, Set<DocIndex>>>,
+        offset: usize,
+        len: usize,
+    },
+    Rewritten {
+        input: Rc<[u8]>,
+        postings_list: SetBuf<DocIndex>,
+    },
+}
+
+impl fmt::Debug for PostingsListView<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PostingsListView")
+            .field("input", &std::str::from_utf8(&self.input()).unwrap())
+            .field("postings_list", &self.as_ref())
+            .finish()
+    }
+}
+
+impl<'txn> PostingsListView<'txn> {
+    pub fn original(input: Rc<[u8]>, postings_list: Rc<Cow<'txn, Set<DocIndex>>>) -> PostingsListView<'txn> {
+        let len = postings_list.len();
+        PostingsListView::Original { input, postings_list, offset: 0, len }
+    }
+
+    pub fn rewritten(input: Rc<[u8]>, postings_list: SetBuf<DocIndex>) -> PostingsListView<'txn> {
+        PostingsListView::Rewritten { input, postings_list }
+    }
+
+    pub fn rewrite_with(&mut self, postings_list: SetBuf<DocIndex>) {
+        let input = match self {
+            PostingsListView::Original { input, .. } => input.clone(),
+            PostingsListView::Rewritten { input, .. } => input.clone(),
+        };
+        *self = PostingsListView::rewritten(input, postings_list);
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            PostingsListView::Original { len, .. } => *len,
+            PostingsListView::Rewritten { postings_list, .. } => postings_list.len(),
+        }
+    }
+
+    pub fn input(&self) -> &[u8] {
+        match self {
+            PostingsListView::Original { ref input, .. } => input,
+            PostingsListView::Rewritten { ref input, .. } => input,
+        }
+    }
+
+    pub fn range(&self, range_offset: usize, range_len: usize) -> PostingsListView<'txn> {
+        match self {
+            PostingsListView::Original { input, postings_list, offset, len } => {
+                assert!(range_offset + range_len <= *len);
+                PostingsListView::Original {
+                    input: input.clone(),
+                    postings_list: postings_list.clone(),
+                    offset: offset + range_offset,
+                    len: range_len,
+                }
+            },
+            PostingsListView::Rewritten { .. } => {
+                panic!("Cannot create a range on a rewritten postings list view");
+            }
+        }
+    }
+}
+
+impl AsRef<Set<DocIndex>> for PostingsListView<'_> {
+    fn as_ref(&self) -> &Set<DocIndex> {
+        self
+    }
+}
+
+impl Deref for PostingsListView<'_> {
+    type Target = Set<DocIndex>;
+
+    fn deref(&self) -> &Set<DocIndex> {
+        match *self {
+            PostingsListView::Original { ref postings_list, offset, len, .. } => {
+                Set::new_unchecked(&postings_list[offset..offset + len])
+            },
+            PostingsListView::Rewritten { ref postings_list, .. } => postings_list,
+        }
+    }
+}
+
+/// sorts documents ids according to user defined ranking rules.
+pub fn placeholder_document_sort(
+    document_ids: &mut [DocumentId],
+    index: &store::Index,
+    reader: &MainReader,
+    ranked_map: &RankedMap
+) -> MResult<()> {
+    use crate::settings::RankingRule;
+    use std::cmp::Ordering;
+
+    enum SortOrder {
+        Asc,
+        Desc,
+    }
+
+    if let Some(ranking_rules) = index.main.ranking_rules(reader)? {
+        let schema = index.main.schema(reader)?
+            .ok_or(Error::SchemaMissing)?;
+
+        // Select custom rules from ranking rules, and map them to custom rules
+        // containing a field_id
+        let ranking_rules = ranking_rules.iter().filter_map(|r|
+            match r {
+                RankingRule::Asc(name) => schema.id(name).map(|f| (f, SortOrder::Asc)),
+                RankingRule::Desc(name) => schema.id(name).map(|f| (f, SortOrder::Desc)),
+                _ => None,
+            }).collect::<Vec<_>>();
+
+        document_ids.sort_unstable_by(|a, b| {
+            for (field_id, order) in &ranking_rules {
+                let a_value = ranked_map.get(*a, *field_id);
+                let b_value = ranked_map.get(*b, *field_id);
+                let (a, b) = match order {
+                    SortOrder::Asc => (a_value, b_value),
+                    SortOrder::Desc => (b_value, a_value),
+                };
+                match a.cmp(&b) {
+                    Ordering::Equal => continue,
+                    ordering => return ordering,
+                }
+            }
+            Ordering::Equal
+        });
+    }
+    Ok(())
+}
+
+/// For each entry in facet_docids, calculates the number of documents in the intersection with candidate_docids.
+pub fn facet_count(
+    facet_docids: HashMap<String, HashMap<String, (&str, Cow<Set<DocumentId>>)>>,
+    candidate_docids: &Set<DocumentId>,
+) -> HashMap<String, HashMap<String, usize>> {
+    let mut facets_counts = HashMap::with_capacity(facet_docids.len());
+    for (key, doc_map) in facet_docids {
+        let mut count_map = HashMap::with_capacity(doc_map.len());
+        for (_, (value, docids)) in doc_map {
+            let mut counter = Counter::new();
+            let op = OpBuilder::new(docids.as_ref(), candidate_docids).intersection();
+            SetOperation::<DocumentId>::extend_collection(op, &mut counter);
+            count_map.insert(value.to_string(), counter.0);
+        }
+        facets_counts.insert(key, count_map);
+    }
+    facets_counts
+}

meilisearch-core/src/criterion/attribute.rs

@@ -0,0 +1,37 @@
+use std::cmp::Ordering;
+use slice_group_by::GroupBy;
+use crate::{RawDocument, MResult};
+use crate::bucket_sort::SimpleMatch;
+use super::{Criterion, Context, ContextMut, prepare_bare_matches};
+
+pub struct Attribute;
+
+impl Criterion for Attribute {
+    fn name(&self) -> &str { "attribute" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        prepare_bare_matches(documents, ctx.postings_lists, ctx.query_mapping);
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        #[inline]
+        fn sum_of_attribute(matches: &[SimpleMatch]) -> usize {
+            let mut sum_of_attribute = 0;
+            for group in matches.linear_group_by_key(|bm| bm.query_index) {
+                sum_of_attribute += group[0].attribute as usize;
+            }
+            sum_of_attribute
+        }
+
+        let lhs = sum_of_attribute(&lhs.processed_matches);
+        let rhs = sum_of_attribute(&rhs.processed_matches);
+
+        lhs.cmp(&rhs)
+    }
+}

meilisearch-core/src/criterion/document_id.rs

@@ -1,16 +1,16 @@
-use crate::criterion::Criterion;
-use crate::RawDocument;
 use std::cmp::Ordering;
+use crate::RawDocument;
+use super::{Criterion, Context};
 
-#[derive(Debug, Clone, Copy)]
 pub struct DocumentId;
 
 impl Criterion for DocumentId {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        lhs.id.cmp(&rhs.id)
-    }
+    fn name(&self) -> &str { "stable document id" }
 
-    fn name(&self) -> &str {
-        "DocumentId"
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        let lhs = &lhs.id;
+        let rhs = &rhs.id;
+
+        lhs.cmp(rhs)
     }
 }

meilisearch-core/src/criterion/exact.rs

@@ -1,132 +0,0 @@
-use std::cmp::Ordering;
-
-use meilisearch_schema::SchemaAttr;
-use sdset::Set;
-use slice_group_by::GroupBy;
-
-use crate::criterion::Criterion;
-use crate::RawDocument;
-
-#[inline]
-fn number_exact_matches(
-    query_index: &[u32],
-    attribute: &[u16],
-    is_exact: &[bool],
-    fields_counts: &Set<(SchemaAttr, u64)>,
-) -> usize {
-    let mut count = 0;
-    let mut index = 0;
-
-    for group in query_index.linear_group() {
-        let len = group.len();
-
-        let mut found_exact = false;
-        for (pos, is_exact) in is_exact[index..index + len].iter().enumerate() {
-            if *is_exact {
-                found_exact = true;
-                let attr = &attribute[index + pos];
-                if let Ok(pos) = fields_counts.binary_search_by_key(attr, |(a, _)| a.0) {
-                    let (_, count) = fields_counts[pos];
-                    if count == 1 {
-                        return usize::max_value();
-                    }
-                }
-            }
-        }
-
-        count += found_exact as usize;
-        index += len;
-    }
-
-    count
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct Exact;
-
-impl Criterion for Exact {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            let is_exact = lhs.is_exact();
-            let attribute = lhs.attribute();
-            let fields_counts = &lhs.fields_counts;
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        let rhs = {
-            let query_index = rhs.query_index();
-            let is_exact = rhs.is_exact();
-            let attribute = rhs.attribute();
-            let fields_counts = &rhs.fields_counts;
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        lhs.cmp(&rhs).reverse()
-    }
-
-    fn name(&self) -> &str {
-        "Exact"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // typing: "soulier"
-    //
-    // doc0: "Soulier bleu"
-    // doc1: "souliereres rouge"
-    #[test]
-    fn easy_case() {
-        let doc0 = {
-            let query_index = &[0];
-            let attribute = &[0];
-            let is_exact = &[true];
-            let fields_counts = Set::new(&[(SchemaAttr(0), 2)]).unwrap();
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        let doc1 = {
-            let query_index = &[0];
-            let attribute = &[0];
-            let is_exact = &[false];
-            let fields_counts = Set::new(&[(SchemaAttr(0), 2)]).unwrap();
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        assert_eq!(doc0.cmp(&doc1).reverse(), Ordering::Less);
-    }
-
-    // typing: "soulier"
-    //
-    // doc0: { 0. "soulier" }
-    // doc1: { 0. "soulier bleu et blanc" }
-    #[test]
-    fn basic() {
-        let doc0 = {
-            let query_index = &[0];
-            let attribute = &[0];
-            let is_exact = &[true];
-            let fields_counts = Set::new(&[(SchemaAttr(0), 1)]).unwrap();
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        let doc1 = {
-            let query_index = &[0];
-            let attribute = &[0];
-            let is_exact = &[true];
-            let fields_counts = Set::new(&[(SchemaAttr(0), 4)]).unwrap();
-
-            number_exact_matches(query_index, attribute, is_exact, fields_counts)
-        };
-
-        assert_eq!(doc0.cmp(&doc1).reverse(), Ordering::Less);
-    }
-}

meilisearch-core/src/criterion/exactness.rs

@@ -0,0 +1,78 @@
+use std::cmp::{Ordering, Reverse};
+use std::collections::hash_map::{HashMap, Entry};
+use meilisearch_schema::IndexedPos;
+use slice_group_by::GroupBy;
+use crate::{RawDocument, MResult};
+use crate::bucket_sort::BareMatch;
+use super::{Criterion, Context, ContextMut};
+
+pub struct Exactness;
+
+impl Criterion for Exactness {
+    fn name(&self) -> &str { "exactness" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        let store = ctx.documents_fields_counts_store;
+        let reader = ctx.reader;
+
+        'documents: for doc in documents {
+            doc.bare_matches.sort_unstable_by_key(|bm| (bm.query_index, Reverse(bm.is_exact)));
+
+            // mark the document if we find a "one word field" that matches
+            let mut fields_counts = HashMap::new();
+            for group in doc.bare_matches.linear_group_by_key(|bm| bm.query_index) {
+                for group in group.linear_group_by_key(|bm| bm.is_exact) {
+                    if !group[0].is_exact { break }
+
+                    for bm in group {
+                        for di in ctx.postings_lists[bm.postings_list].as_ref() {
+
+                            let attr = IndexedPos(di.attribute);
+                            let count = match fields_counts.entry(attr) {
+                                Entry::Occupied(entry) => *entry.get(),
+                                Entry::Vacant(entry) => {
+                                    let count = store.document_field_count(reader, doc.id, attr)?;
+                                    *entry.insert(count)
+                                },
+                            };
+
+                            if count == Some(1) {
+                                doc.contains_one_word_field = true;
+                                continue 'documents
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        #[inline]
+        fn sum_exact_query_words(matches: &[BareMatch]) -> usize {
+            let mut sum_exact_query_words = 0;
+
+            for group in matches.linear_group_by_key(|bm| bm.query_index) {
+                sum_exact_query_words += group[0].is_exact as usize;
+            }
+
+            sum_exact_query_words
+        }
+
+        // does it contains a "one word field"
+        lhs.contains_one_word_field.cmp(&rhs.contains_one_word_field).reverse()
+        // if not, with document contains the more exact words
+        .then_with(|| {
+            let lhs = sum_exact_query_words(&lhs.bare_matches);
+            let rhs = sum_exact_query_words(&rhs.bare_matches);
+            lhs.cmp(&rhs).reverse()
+        })
+    }
+}

meilisearch-core/src/criterion/mod.rs

@@ -1,59 +1,75 @@
+use std::cmp::{self, Ordering};
+use std::collections::HashMap;
+use std::ops::Range;
+
+use compact_arena::SmallArena;
+use sdset::SetBuf;
+use slice_group_by::GroupBy;
+
+use crate::bucket_sort::{SimpleMatch, PostingsListView};
+use crate::database::MainT;
+use crate::query_tree::QueryId;
+use crate::{store, RawDocument, MResult};
+
+mod typo;
+mod words;
+mod proximity;
+mod attribute;
+mod words_position;
+mod exactness;
 mod document_id;
-mod exact;
-mod number_of_words;
 mod sort_by_attr;
-mod sum_of_typos;
-mod sum_of_words_attribute;
-mod sum_of_words_position;
-mod words_proximity;
 
-use crate::RawDocument;
-use std::cmp::Ordering;
-
-pub use self::{
-    document_id::DocumentId, exact::Exact, number_of_words::NumberOfWords,
-    sort_by_attr::SortByAttr, sum_of_typos::SumOfTypos,
-    sum_of_words_attribute::SumOfWordsAttribute, sum_of_words_position::SumOfWordsPosition,
-    words_proximity::WordsProximity,
-};
-
-pub trait Criterion: Send + Sync {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering;
+pub use self::typo::Typo;
+pub use self::words::Words;
+pub use self::proximity::Proximity;
+pub use self::attribute::Attribute;
+pub use self::words_position::WordsPosition;
+pub use self::exactness::Exactness;
+pub use self::document_id::DocumentId;
+pub use self::sort_by_attr::SortByAttr;
 
+pub trait Criterion {
     fn name(&self) -> &str;
 
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        _ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        _documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        Ok(())
+    }
+
+    fn evaluate<'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: &Context<'p, 'tag, 'txn, 'q>,
+        lhs: &RawDocument<'r, 'tag>,
+        rhs: &RawDocument<'r, 'tag>,
+    ) -> Ordering;
+
     #[inline]
-    fn eq(&self, lhs: &RawDocument, rhs: &RawDocument) -> bool {
-        self.evaluate(lhs, rhs) == Ordering::Equal
+    fn eq<'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: &Context<'p, 'tag, 'txn, 'q>,
+        lhs: &RawDocument<'r, 'tag>,
+        rhs: &RawDocument<'r, 'tag>,
+    ) -> bool
+    {
+        self.evaluate(ctx, lhs, rhs) == Ordering::Equal
     }
 }
 
-impl<'a, T: Criterion + ?Sized + Send + Sync> Criterion for &'a T {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        (**self).evaluate(lhs, rhs)
-    }
-
-    fn name(&self) -> &str {
-        (**self).name()
-    }
-
-    fn eq(&self, lhs: &RawDocument, rhs: &RawDocument) -> bool {
-        (**self).eq(lhs, rhs)
-    }
+pub struct ContextMut<'h, 'p, 'tag, 'txn, 'q> {
+    pub reader: &'h heed::RoTxn<'h, MainT>,
+    pub postings_lists: &'p mut SmallArena<'tag, PostingsListView<'txn>>,
+    pub query_mapping: &'q HashMap<QueryId, Range<usize>>,
+    pub documents_fields_counts_store: store::DocumentsFieldsCounts,
 }
 
-impl<T: Criterion + ?Sized> Criterion for Box<T> {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        (**self).evaluate(lhs, rhs)
-    }
-
-    fn name(&self) -> &str {
-        (**self).name()
-    }
-
-    fn eq(&self, lhs: &RawDocument, rhs: &RawDocument) -> bool {
-        (**self).eq(lhs, rhs)
-    }
+pub struct Context<'p, 'tag, 'txn, 'q> {
+    pub postings_lists: &'p SmallArena<'tag, PostingsListView<'txn>>,
+    pub query_mapping: &'q HashMap<QueryId, Range<usize>>,
 }
 
 #[derive(Default)]
@@ -76,6 +92,7 @@ impl<'a> CriteriaBuilder<'a> {
         self.inner.reserve(additional)
     }
 
+    #[allow(clippy::should_implement_trait)]
     pub fn add<C: 'a>(mut self, criterion: C) -> CriteriaBuilder<'a>
     where
         C: Criterion,
@@ -103,12 +120,12 @@ pub struct Criteria<'a> {
 impl<'a> Default for Criteria<'a> {
     fn default() -> Self {
         CriteriaBuilder::with_capacity(7)
-            .add(SumOfTypos)
-            .add(NumberOfWords)
-            .add(WordsProximity)
-            .add(SumOfWordsAttribute)
-            .add(SumOfWordsPosition)
-            .add(Exact)
+            .add(Typo)
+            .add(Words)
+            .add(Proximity)
+            .add(Attribute)
+            .add(WordsPosition)
+            .add(Exactness)
             .add(DocumentId)
             .build()
     }
@@ -119,3 +136,157 @@ impl<'a> AsRef<[Box<dyn Criterion + 'a>]> for Criteria<'a> {
         &self.inner
     }
 }
+
+fn prepare_query_distances<'a, 'tag, 'txn>(
+    documents: &mut [RawDocument<'a, 'tag>],
+    query_mapping: &HashMap<QueryId, Range<usize>>,
+    postings_lists: &SmallArena<'tag, PostingsListView<'txn>>,
+) {
+    for document in documents {
+        if !document.processed_distances.is_empty() { continue }
+
+        let mut processed = Vec::new();
+        for m in document.bare_matches.iter() {
+            if postings_lists[m.postings_list].is_empty() { continue }
+
+            let range = query_mapping[&(m.query_index as usize)].clone();
+            let new_len = cmp::max(range.end as usize, processed.len());
+            processed.resize(new_len, None);
+
+            for index in range {
+                let index = index as usize;
+                processed[index] = match processed[index] {
+                    Some(distance) if distance > m.distance => Some(m.distance),
+                    Some(distance) => Some(distance),
+                    None => Some(m.distance),
+                };
+            }
+        }
+
+        document.processed_distances = processed;
+    }
+}
+
+fn prepare_bare_matches<'a, 'tag, 'txn>(
+    documents: &mut [RawDocument<'a, 'tag>],
+    postings_lists: &mut SmallArena<'tag, PostingsListView<'txn>>,
+    query_mapping: &HashMap<QueryId, Range<usize>>,
+) {
+    for document in documents {
+        if !document.processed_matches.is_empty() { continue }
+
+        let mut processed = Vec::new();
+        for m in document.bare_matches.iter() {
+            let postings_list = &postings_lists[m.postings_list];
+            processed.reserve(postings_list.len());
+            for di in postings_list.as_ref() {
+                let simple_match = SimpleMatch {
+                    query_index: m.query_index,
+                    distance: m.distance,
+                    attribute: di.attribute,
+                    word_index: di.word_index,
+                    is_exact: m.is_exact,
+                };
+                processed.push(simple_match);
+            }
+        }
+
+        let processed = multiword_rewrite_matches(&mut processed, query_mapping);
+        document.processed_matches = processed.into_vec();
+    }
+}
+
+fn multiword_rewrite_matches(
+    matches: &mut [SimpleMatch],
+    query_mapping: &HashMap<QueryId, Range<usize>>,
+) -> SetBuf<SimpleMatch>
+{
+    matches.sort_unstable_by_key(|m| (m.attribute, m.word_index));
+
+    let mut padded_matches = Vec::with_capacity(matches.len());
+
+    // let before_padding = Instant::now();
+    // for each attribute of each document
+    for same_document_attribute in matches.linear_group_by_key(|m| m.attribute) {
+        // padding will only be applied
+        // to word indices in the same attribute
+        let mut padding = 0;
+        let mut iter = same_document_attribute.linear_group_by_key(|m| m.word_index);
+
+        // for each match at the same position
+        // in this document attribute
+        while let Some(same_word_index) = iter.next() {
+            // find the biggest padding
+            let mut biggest = 0;
+            for match_ in same_word_index {
+                let mut replacement = query_mapping[&(match_.query_index as usize)].clone();
+                let replacement_len = replacement.len();
+                let nexts = iter.remainder().linear_group_by_key(|m| m.word_index);
+
+                if let Some(query_index) = replacement.next() {
+                    let word_index = match_.word_index + padding as u16;
+                    let match_ = SimpleMatch { query_index, word_index, ..*match_ };
+                    padded_matches.push(match_);
+                }
+
+                let mut found = false;
+
+                // look ahead and if there already is a match
+                // corresponding to this padding word, abort the padding
+                'padding: for (x, next_group) in nexts.enumerate() {
+                    for (i, query_index) in replacement.clone().enumerate().skip(x) {
+                        let word_index = match_.word_index + padding as u16 + (i + 1) as u16;
+                        let padmatch = SimpleMatch { query_index, word_index, ..*match_ };
+
+                        for nmatch_ in next_group {
+                            let mut rep = query_mapping[&(nmatch_.query_index as usize)].clone();
+                            let query_index = rep.next().unwrap();
+                            if query_index == padmatch.query_index {
+                                if !found {
+                                    // if we find a corresponding padding for the
+                                    // first time we must push preceding paddings
+                                    for (i, query_index) in replacement.clone().enumerate().take(i) {
+                                        let word_index = match_.word_index + padding as u16 + (i + 1) as u16;
+                                        let match_ = SimpleMatch { query_index, word_index, ..*match_ };
+                                        padded_matches.push(match_);
+                                        biggest = biggest.max(i + 1);
+                                    }
+                                }
+
+                                padded_matches.push(padmatch);
+                                found = true;
+                                continue 'padding;
+                            }
+                        }
+                    }
+
+                    // if we do not find a corresponding padding in the
+                    // next groups so stop here and pad what was found
+                    break;
+                }
+
+                if !found {
+                    // if no padding was found in the following matches
+                    // we must insert the entire padding
+                    for (i, query_index) in replacement.enumerate() {
+                        let word_index = match_.word_index + padding as u16 + (i + 1) as u16;
+                        let match_ = SimpleMatch { query_index, word_index, ..*match_ };
+                        padded_matches.push(match_);
+                    }
+
+                    biggest = biggest.max(replacement_len - 1);
+                }
+            }
+
+            padding += biggest;
+        }
+    }
+
+    // debug!("padding matches took {:.02?}", before_padding.elapsed());
+
+    // With this check we can see that the loop above takes something
+    // like 43% of the search time even when no rewrite is needed.
+    // assert_eq!(before_matches, padded_matches);
+
+    SetBuf::from_dirty(padded_matches)
+}

meilisearch-core/src/criterion/number_of_words.rs

@@ -1,31 +0,0 @@
-use crate::criterion::Criterion;
-use crate::RawDocument;
-use slice_group_by::GroupBy;
-use std::cmp::Ordering;
-
-#[inline]
-fn number_of_query_words(query_index: &[u32]) -> usize {
-    query_index.linear_group().count()
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct NumberOfWords;
-
-impl Criterion for NumberOfWords {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            number_of_query_words(query_index)
-        };
-        let rhs = {
-            let query_index = rhs.query_index();
-            number_of_query_words(query_index)
-        };
-
-        lhs.cmp(&rhs).reverse()
-    }
-
-    fn name(&self) -> &str {
-        "NumberOfWords"
-    }
-}

meilisearch-core/src/criterion/proximity.rs

@@ -0,0 +1,68 @@
+use std::cmp::{self, Ordering};
+use slice_group_by::GroupBy;
+use crate::bucket_sort::{SimpleMatch};
+use crate::{RawDocument, MResult};
+use super::{Criterion, Context, ContextMut, prepare_bare_matches};
+
+const MAX_DISTANCE: u16 = 8;
+
+pub struct Proximity;
+
+impl Criterion for Proximity {
+    fn name(&self) -> &str { "proximity" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        prepare_bare_matches(documents, ctx.postings_lists, ctx.query_mapping);
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        fn index_proximity(lhs: u16, rhs: u16) -> u16 {
+            if lhs < rhs {
+                cmp::min(rhs - lhs, MAX_DISTANCE)
+            } else {
+                cmp::min(lhs - rhs, MAX_DISTANCE) + 1
+            }
+        }
+
+        fn attribute_proximity(lhs: SimpleMatch, rhs: SimpleMatch) -> u16 {
+            if lhs.attribute != rhs.attribute { MAX_DISTANCE }
+            else { index_proximity(lhs.word_index, rhs.word_index) }
+        }
+
+        fn min_proximity(lhs: &[SimpleMatch], rhs: &[SimpleMatch]) -> u16 {
+            let mut min_prox = u16::max_value();
+            for a in lhs {
+                for b in rhs {
+                    let prox = attribute_proximity(*a, *b);
+                    min_prox = cmp::min(min_prox, prox);
+                }
+            }
+            min_prox
+        }
+
+        fn matches_proximity(matches: &[SimpleMatch],) -> u16 {
+            let mut proximity = 0;
+            let mut iter = matches.linear_group_by_key(|m| m.query_index);
+
+            // iterate over groups by windows of size 2
+            let mut last = iter.next();
+            while let (Some(lhs), Some(rhs)) = (last, iter.next()) {
+                proximity += min_proximity(lhs, rhs);
+                last = Some(rhs);
+            }
+
+            proximity
+        }
+
+        let lhs = matches_proximity(&lhs.processed_matches);
+        let rhs = matches_proximity(&rhs.processed_matches);
+
+        lhs.cmp(&rhs)
+    }
+}

meilisearch-core/src/criterion/sort_by_attr.rs

@@ -1,10 +1,9 @@
 use std::cmp::Ordering;
 use std::error::Error;
 use std::fmt;
-
-use crate::criterion::Criterion;
+use meilisearch_schema::{Schema, FieldId};
 use crate::{RankedMap, RawDocument};
-use meilisearch_schema::{Schema, SchemaAttr};
+use super::{Criterion, Context};
 
 /// An helper struct that permit to sort documents by
 /// some of their stored attributes.
@@ -28,12 +27,12 @@ use meilisearch_schema::{Schema, SchemaAttr};
 /// let custom_ranking = SortByAttr::lower_is_better(&ranked_map, &schema, "published_at")?;
 ///
 /// let builder = CriteriaBuilder::with_capacity(8)
-///        .add(SumOfTypos)
-///        .add(NumberOfWords)
-///        .add(WordsProximity)
-///        .add(SumOfWordsAttribute)
-///        .add(SumOfWordsPosition)
-///        .add(Exact)
+///        .add(Typo)
+///        .add(Words)
+///        .add(Proximity)
+///        .add(Attribute)
+///        .add(WordsPosition)
+///        .add(Exactness)
 ///        .add(custom_ranking)
 ///        .add(DocumentId);
 ///
@@ -42,7 +41,7 @@ use meilisearch_schema::{Schema, SchemaAttr};
 /// ```
 pub struct SortByAttr<'a> {
     ranked_map: &'a RankedMap,
-    attr: SchemaAttr,
+    field_id: FieldId,
     reversed: bool,
 }
 
@@ -69,27 +68,31 @@ impl<'a> SortByAttr<'a> {
         attr_name: &str,
         reversed: bool,
     ) -> Result<SortByAttr<'a>, SortByAttrError> {
-        let attr = match schema.attribute(attr_name) {
-            Some(attr) => attr,
+        let field_id = match schema.id(attr_name) {
+            Some(field_id) => field_id,
             None => return Err(SortByAttrError::AttributeNotFound),
         };
 
-        if !schema.props(attr).is_ranked() {
+        if !schema.is_ranked(field_id) {
             return Err(SortByAttrError::AttributeNotRegisteredForRanking);
         }
 
         Ok(SortByAttr {
             ranked_map,
-            attr,
+            field_id,
             reversed,
         })
     }
 }
 
-impl<'a> Criterion for SortByAttr<'a> {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = self.ranked_map.get(lhs.id, self.attr);
-        let rhs = self.ranked_map.get(rhs.id, self.attr);
+impl Criterion for SortByAttr<'_> {
+    fn name(&self) -> &str {
+        "sort by attribute"
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        let lhs = self.ranked_map.get(lhs.id, self.field_id);
+        let rhs = self.ranked_map.get(rhs.id, self.field_id);
 
         match (lhs, rhs) {
             (Some(lhs), Some(rhs)) => {
@@ -105,10 +108,6 @@ impl<'a> Criterion for SortByAttr<'a> {
             (None, None) => Ordering::Equal,
         }
     }
-
-    fn name(&self) -> &str {
-        "SortByAttr"
-    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

meilisearch-core/src/criterion/sum_of_typos.rs

@@ -1,116 +0,0 @@
-use std::cmp::Ordering;
-
-use slice_group_by::GroupBy;
-
-use crate::criterion::Criterion;
-use crate::RawDocument;
-
-// This function is a wrong logarithmic 10 function.
-// It is safe to panic on input number higher than 3,
-// the number of typos is never bigger than that.
-#[inline]
-fn custom_log10(n: u8) -> f32 {
-    match n {
-        0 => 0.0,     // log(1)
-        1 => 0.30102, // log(2)
-        2 => 0.47712, // log(3)
-        3 => 0.60205, // log(4)
-        _ => panic!("invalid number"),
-    }
-}
-
-#[inline]
-fn sum_matches_typos(query_index: &[u32], distance: &[u8]) -> usize {
-    let mut number_words: usize = 0;
-    let mut sum_typos = 0.0;
-    let mut index = 0;
-
-    for group in query_index.linear_group() {
-        sum_typos += custom_log10(distance[index]);
-        number_words += 1;
-        index += group.len();
-    }
-
-    (number_words as f32 / (sum_typos + 1.0) * 1000.0) as usize
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct SumOfTypos;
-
-impl Criterion for SumOfTypos {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            let distance = lhs.distance();
-            sum_matches_typos(query_index, distance)
-        };
-
-        let rhs = {
-            let query_index = rhs.query_index();
-            let distance = rhs.distance();
-            sum_matches_typos(query_index, distance)
-        };
-
-        lhs.cmp(&rhs).reverse()
-    }
-
-    fn name(&self) -> &str {
-        "SumOfTypos"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // typing: "Geox CEO"
-    //
-    // doc0: "Geox SpA: CEO and Executive"
-    // doc1: "Mt. Gox CEO Resigns From Bitcoin Foundation"
-    #[test]
-    fn one_typo_reference() {
-        let query_index0 = &[0, 1];
-        let distance0 = &[0, 0];
-
-        let query_index1 = &[0, 1];
-        let distance1 = &[1, 0];
-
-        let doc0 = sum_matches_typos(query_index0, distance0);
-        let doc1 = sum_matches_typos(query_index1, distance1);
-        assert_eq!(doc0.cmp(&doc1).reverse(), Ordering::Less);
-    }
-
-    // typing: "bouton manchette"
-    //
-    // doc0: "bouton manchette"
-    // doc1: "bouton"
-    #[test]
-    fn no_typo() {
-        let query_index0 = &[0, 1];
-        let distance0 = &[0, 0];
-
-        let query_index1 = &[0];
-        let distance1 = &[0];
-
-        let doc0 = sum_matches_typos(query_index0, distance0);
-        let doc1 = sum_matches_typos(query_index1, distance1);
-        assert_eq!(doc0.cmp(&doc1).reverse(), Ordering::Less);
-    }
-
-    // typing: "bouton manchztte"
-    //
-    // doc0: "bouton manchette"
-    // doc1: "bouton"
-    #[test]
-    fn one_typo() {
-        let query_index0 = &[0, 1];
-        let distance0 = &[0, 1];
-
-        let query_index1 = &[0];
-        let distance1 = &[0];
-
-        let doc0 = sum_matches_typos(query_index0, distance0);
-        let doc1 = sum_matches_typos(query_index1, distance1);
-        assert_eq!(doc0.cmp(&doc1).reverse(), Ordering::Less);
-    }
-}

meilisearch-core/src/criterion/sum_of_words_attribute.rs

@@ -1,64 +0,0 @@
-use crate::criterion::Criterion;
-use crate::RawDocument;
-use slice_group_by::GroupBy;
-use std::cmp::Ordering;
-
-#[inline]
-fn sum_matches_attributes(query_index: &[u32], attribute: &[u16]) -> usize {
-    let mut sum_attributes = 0;
-    let mut index = 0;
-
-    for group in query_index.linear_group() {
-        sum_attributes += attribute[index] as usize;
-        index += group.len();
-    }
-
-    sum_attributes
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct SumOfWordsAttribute;
-
-impl Criterion for SumOfWordsAttribute {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            let attribute = lhs.attribute();
-            sum_matches_attributes(query_index, attribute)
-        };
-
-        let rhs = {
-            let query_index = rhs.query_index();
-            let attribute = rhs.attribute();
-            sum_matches_attributes(query_index, attribute)
-        };
-
-        lhs.cmp(&rhs)
-    }
-
-    fn name(&self) -> &str {
-        "SumOfWordsAttribute"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // typing: "soulier"
-    //
-    // doc0: { 0. "Soulier bleu", 1. "bla bla bla" }
-    // doc1: { 0. "Botte rouge", 1. "Soulier en cuir" }
-    #[test]
-    fn title_vs_description() {
-        let query_index0 = &[0];
-        let attribute0 = &[0];
-
-        let query_index1 = &[0];
-        let attribute1 = &[1];
-
-        let doc0 = sum_matches_attributes(query_index0, attribute0);
-        let doc1 = sum_matches_attributes(query_index1, attribute1);
-        assert_eq!(doc0.cmp(&doc1), Ordering::Less);
-    }
-}

meilisearch-core/src/criterion/sum_of_words_position.rs

@@ -1,64 +0,0 @@
-use crate::criterion::Criterion;
-use crate::RawDocument;
-use slice_group_by::GroupBy;
-use std::cmp::Ordering;
-
-#[inline]
-fn sum_matches_attribute_index(query_index: &[u32], word_index: &[u16]) -> usize {
-    let mut sum_word_index = 0;
-    let mut index = 0;
-
-    for group in query_index.linear_group() {
-        sum_word_index += word_index[index] as usize;
-        index += group.len();
-    }
-
-    sum_word_index
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct SumOfWordsPosition;
-
-impl Criterion for SumOfWordsPosition {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            let word_index = lhs.word_index();
-            sum_matches_attribute_index(query_index, word_index)
-        };
-
-        let rhs = {
-            let query_index = rhs.query_index();
-            let word_index = rhs.word_index();
-            sum_matches_attribute_index(query_index, word_index)
-        };
-
-        lhs.cmp(&rhs)
-    }
-
-    fn name(&self) -> &str {
-        "SumOfWordsPosition"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // typing: "soulier"
-    //
-    // doc0: "Soulier bleu"
-    // doc1: "Botte rouge et soulier noir"
-    #[test]
-    fn easy_case() {
-        let query_index0 = &[0];
-        let word_index0 = &[0];
-
-        let query_index1 = &[0];
-        let word_index1 = &[3];
-
-        let doc0 = sum_matches_attribute_index(query_index0, word_index0);
-        let doc1 = sum_matches_attribute_index(query_index1, word_index1);
-        assert_eq!(doc0.cmp(&doc1), Ordering::Less);
-    }
-}

meilisearch-core/src/criterion/typo.rs

@@ -0,0 +1,56 @@
+use std::cmp::Ordering;
+use crate::{RawDocument, MResult};
+use super::{Criterion, Context, ContextMut, prepare_query_distances};
+
+pub struct Typo;
+
+impl Criterion for Typo {
+    fn name(&self) -> &str { "typo" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        prepare_query_distances(documents, ctx.query_mapping, ctx.postings_lists);
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        // This function is a wrong logarithmic 10 function.
+        // It is safe to panic on input number higher than 3,
+        // the number of typos is never bigger than that.
+        #[inline]
+        #[allow(clippy::approx_constant)]
+        fn custom_log10(n: u8) -> f32 {
+            match n {
+                0 => 0.0,     // log(1)
+                1 => 0.30102, // log(2)
+                2 => 0.47712, // log(3)
+                3 => 0.60205, // log(4)
+                _ => panic!("invalid number"),
+            }
+        }
+
+        #[inline]
+        fn compute_typos(distances: &[Option<u8>]) -> usize {
+            let mut number_words: usize = 0;
+            let mut sum_typos = 0.0;
+
+            for distance in distances {
+                if let Some(distance) = distance {
+                    sum_typos += custom_log10(*distance);
+                    number_words += 1;
+                }
+            }
+
+            (number_words as f32 / (sum_typos + 1.0) * 1000.0) as usize
+        }
+
+        let lhs = compute_typos(&lhs.processed_distances);
+        let rhs = compute_typos(&rhs.processed_distances);
+
+        lhs.cmp(&rhs).reverse()
+    }
+}

meilisearch-core/src/criterion/words.rs

@@ -0,0 +1,31 @@
+use std::cmp::Ordering;
+use crate::{RawDocument, MResult};
+use super::{Criterion, Context, ContextMut, prepare_query_distances};
+
+pub struct Words;
+
+impl Criterion for Words {
+    fn name(&self) -> &str { "words" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        prepare_query_distances(documents, ctx.query_mapping, ctx.postings_lists);
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        #[inline]
+        fn number_of_query_words(distances: &[Option<u8>]) -> usize {
+            distances.iter().cloned().filter(Option::is_some).count()
+        }
+
+        let lhs = number_of_query_words(&lhs.processed_distances);
+        let rhs = number_of_query_words(&rhs.processed_distances);
+
+        lhs.cmp(&rhs).reverse()
+    }
+}

meilisearch-core/src/criterion/words_position.rs

@@ -0,0 +1,37 @@
+use std::cmp::Ordering;
+use slice_group_by::GroupBy;
+use crate::bucket_sort::SimpleMatch;
+use crate::{RawDocument, MResult};
+use super::{Criterion, Context, ContextMut, prepare_bare_matches};
+
+pub struct WordsPosition;
+
+impl Criterion for WordsPosition {
+    fn name(&self) -> &str { "words position" }
+
+    fn prepare<'h, 'p, 'tag, 'txn, 'q, 'r>(
+        &self,
+        ctx: ContextMut<'h, 'p, 'tag, 'txn, 'q>,
+        documents: &mut [RawDocument<'r, 'tag>],
+    ) -> MResult<()>
+    {
+        prepare_bare_matches(documents, ctx.postings_lists, ctx.query_mapping);
+        Ok(())
+    }
+
+    fn evaluate(&self, _ctx: &Context, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
+        #[inline]
+        fn sum_words_position(matches: &[SimpleMatch]) -> usize {
+            let mut sum_words_position = 0;
+            for group in matches.linear_group_by_key(|bm| bm.query_index) {
+                sum_words_position += group[0].word_index as usize;
+            }
+            sum_words_position
+        }
+
+        let lhs = sum_words_position(&lhs.processed_matches);
+        let rhs = sum_words_position(&rhs.processed_matches);
+
+        lhs.cmp(&rhs)
+    }
+}

meilisearch-core/src/criterion/words_proximity.rs

@@ -1,164 +0,0 @@
-use crate::criterion::Criterion;
-use crate::RawDocument;
-use slice_group_by::GroupBy;
-use std::cmp::{self, Ordering};
-
-const MAX_DISTANCE: u16 = 8;
-
-#[inline]
-fn clone_tuple<T: Clone, U: Clone>((a, b): (&T, &U)) -> (T, U) {
-    (a.clone(), b.clone())
-}
-
-fn index_proximity(lhs: u16, rhs: u16) -> u16 {
-    if lhs < rhs {
-        cmp::min(rhs - lhs, MAX_DISTANCE)
-    } else {
-        cmp::min(lhs - rhs, MAX_DISTANCE) + 1
-    }
-}
-
-fn attribute_proximity((lattr, lwi): (u16, u16), (rattr, rwi): (u16, u16)) -> u16 {
-    if lattr != rattr {
-        return MAX_DISTANCE;
-    }
-    index_proximity(lwi, rwi)
-}
-
-fn min_proximity((lattr, lwi): (&[u16], &[u16]), (rattr, rwi): (&[u16], &[u16])) -> u16 {
-    let mut min_prox = u16::max_value();
-
-    for a in lattr.iter().zip(lwi) {
-        for b in rattr.iter().zip(rwi) {
-            let a = clone_tuple(a);
-            let b = clone_tuple(b);
-            min_prox = cmp::min(min_prox, attribute_proximity(a, b));
-        }
-    }
-
-    min_prox
-}
-
-fn matches_proximity(
-    query_index: &[u32],
-    distance: &[u8],
-    attribute: &[u16],
-    word_index: &[u16],
-) -> u16 {
-    let mut query_index_groups = query_index.linear_group();
-    let mut proximity = 0;
-    let mut index = 0;
-
-    let get_attr_wi = |index: usize, group_len: usize| {
-        // retrieve the first distance group (with the lowest values)
-        let len = distance[index..index + group_len]
-            .linear_group()
-            .next()
-            .unwrap()
-            .len();
-
-        let rattr = &attribute[index..index + len];
-        let rwi = &word_index[index..index + len];
-
-        (rattr, rwi)
-    };
-
-    let mut last = query_index_groups.next().map(|group| {
-        let attr_wi = get_attr_wi(index, group.len());
-        index += group.len();
-        attr_wi
-    });
-
-    // iter by windows of size 2
-    while let (Some(lhs), Some(rhs)) = (last, query_index_groups.next()) {
-        let attr_wi = get_attr_wi(index, rhs.len());
-        proximity += min_proximity(lhs, attr_wi);
-        last = Some(attr_wi);
-        index += rhs.len();
-    }
-
-    proximity
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct WordsProximity;
-
-impl Criterion for WordsProximity {
-    fn evaluate(&self, lhs: &RawDocument, rhs: &RawDocument) -> Ordering {
-        let lhs = {
-            let query_index = lhs.query_index();
-            let distance = lhs.distance();
-            let attribute = lhs.attribute();
-            let word_index = lhs.word_index();
-            matches_proximity(query_index, distance, attribute, word_index)
-        };
-
-        let rhs = {
-            let query_index = rhs.query_index();
-            let distance = rhs.distance();
-            let attribute = rhs.attribute();
-            let word_index = rhs.word_index();
-            matches_proximity(query_index, distance, attribute, word_index)
-        };
-
-        lhs.cmp(&rhs)
-    }
-
-    fn name(&self) -> &str {
-        "WordsProximity"
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn three_different_attributes() {
-        // "soup" "of the" "the day"
-        //
-        // { id: 0, attr: 0, attr_index: 0 }
-        // { id: 1, attr: 1, attr_index: 0 }
-        // { id: 2, attr: 1, attr_index: 1 }
-        // { id: 2, attr: 2, attr_index: 0 }
-        // { id: 3, attr: 3, attr_index: 1 }
-
-        let query_index = &[0, 1, 2, 2, 3];
-        let distance = &[0, 0, 0, 0, 0];
-        let attribute = &[0, 1, 1, 2, 3];
-        let word_index = &[0, 0, 1, 0, 1];
-
-        //   soup -> of = 8
-        // + of -> the  = 1
-        // + the -> day = 8 (not 1)
-        assert_eq!(
-            matches_proximity(query_index, distance, attribute, word_index),
-            17
-        );
-    }
-
-    #[test]
-    fn two_different_attributes() {
-        // "soup day" "soup of the day"
-        //
-        // { id: 0, attr: 0, attr_index: 0 }
-        // { id: 0, attr: 1, attr_index: 0 }
-        // { id: 1, attr: 1, attr_index: 1 }
-        // { id: 2, attr: 1, attr_index: 2 }
-        // { id: 3, attr: 0, attr_index: 1 }
-        // { id: 3, attr: 1, attr_index: 3 }
-
-        let query_index = &[0, 0, 1, 2, 3, 3];
-        let distance = &[0, 0, 0, 0, 0, 0];
-        let attribute = &[0, 1, 1, 1, 0, 1];
-        let word_index = &[0, 0, 1, 2, 1, 3];
-
-        //   soup -> of = 1
-        // + of -> the  = 1
-        // + the -> day = 1
-        assert_eq!(
-            matches_proximity(query_index, distance, attribute, word_index),
-            3
-        );
-    }
-}

meilisearch-core/src/error.rs

@@ -1,24 +1,63 @@
 use crate::serde::{DeserializerError, SerializerError};
 use serde_json::Error as SerdeJsonError;
+use pest::error::Error as PestError;
+use crate::filters::Rule;
 use std::{error, fmt, io};
 
+pub use bincode::Error as BincodeError;
+pub use fst::Error as FstError;
+pub use heed::Error as HeedError;
+pub use pest::error as pest_error;
+
+use meilisearch_error::{ErrorCode, Code};
+
 pub type MResult<T> = Result<T, Error>;
 
 #[derive(Debug)]
 pub enum Error {
-    Io(io::Error),
-    IndexAlreadyExists,
-    SchemaDiffer,
-    SchemaMissing,
-    WordIndexMissing,
-    MissingDocumentId,
-    Zlmdb(heed::Error),
-    Fst(fst::Error),
-    SerdeJson(SerdeJsonError),
     Bincode(bincode::Error),
-    Serializer(SerializerError),
     Deserializer(DeserializerError),
-    UnsupportedOperation(UnsupportedOperation),
+    FacetError(FacetError),
+    FilterParseError(PestError<Rule>),
+    Fst(fst::Error),
+    Heed(heed::Error),
+    IndexAlreadyExists,
+    Io(io::Error),
+    MaxFieldsLimitExceeded,
+    MissingDocumentId,
+    MissingPrimaryKey,
+    Schema(meilisearch_schema::Error),
+    SchemaMissing,
+    SerdeJson(SerdeJsonError),
+    Serializer(SerializerError),
+    VersionMismatch(String),
+    WordIndexMissing,
+}
+
+impl ErrorCode for Error {
+    fn error_code(&self) -> Code {
+        use Error::*;
+
+        match self {
+            FacetError(_) => Code::Facet,
+            FilterParseError(_) => Code::Filter,
+            IndexAlreadyExists => Code::IndexAlreadyExists,
+            MissingPrimaryKey => Code::MissingPrimaryKey,
+            MissingDocumentId => Code::MissingDocumentId,
+            MaxFieldsLimitExceeded => Code::MaxFieldsLimitExceeded,
+            Schema(s) =>  s.error_code(),
+            WordIndexMissing
+            | SchemaMissing => Code::InvalidState,
+            Heed(_)
+            | Fst(_)
+            | SerdeJson(_)
+            | Bincode(_)
+            | Serializer(_)
+            | Deserializer(_)
+            | VersionMismatch(_)
+            | Io(_) => Code::Internal,
+        }
+    }
 }
 
 impl From<io::Error> for Error {
@@ -27,14 +66,48 @@ impl From<io::Error> for Error {
     }
 }
 
-impl From<heed::Error> for Error {
-    fn from(error: heed::Error) -> Error {
-        Error::Zlmdb(error)
+impl From<PestError<Rule>> for Error {
+    fn from(error: PestError<Rule>) -> Error {
+        Error::FilterParseError(error.renamed_rules(|r| {
+            let s  = match r {
+                Rule::or => "OR",
+                Rule::and => "AND",
+                Rule::not => "NOT",
+                Rule::string => "string",
+                Rule::word => "word",
+                Rule::greater => "field > value",
+                Rule::less => "field < value",
+                Rule::eq => "field = value",
+                Rule::leq => "field <= value",
+                Rule::geq => "field >= value",
+                Rule::key => "key",
+                _ => "other",
+            };
+            s.to_string()
+        }))
     }
 }
 
-impl From<fst::Error> for Error {
-    fn from(error: fst::Error) -> Error {
+impl From<FacetError> for Error {
+    fn from(error: FacetError) -> Error {
+        Error::FacetError(error)
+    }
+}
+
+impl From<meilisearch_schema::Error> for Error {
+    fn from(error: meilisearch_schema::Error) -> Error {
+        Error::Schema(error)
+    }
+}
+
+impl From<HeedError> for Error {
+    fn from(error: HeedError) -> Error {
+        Error::Heed(error)
+    }
+}
+
+impl From<FstError> for Error {
+    fn from(error: FstError) -> Error {
         Error::Fst(error)
     }
 }
@@ -45,15 +118,18 @@ impl From<SerdeJsonError> for Error {
     }
 }
 
-impl From<bincode::Error> for Error {
-    fn from(error: bincode::Error) -> Error {
+impl From<BincodeError> for Error {
+    fn from(error: BincodeError) -> Error {
         Error::Bincode(error)
     }
 }
 
 impl From<SerializerError> for Error {
     fn from(error: SerializerError) -> Error {
-        Error::Serializer(error)
+        match error {
+            SerializerError::DocumentIdNotFound => Error::MissingDocumentId,
+            e => Error::Serializer(e),
+        }
     }
 }
 
@@ -63,55 +139,86 @@ impl From<DeserializerError> for Error {
     }
 }
 
-impl From<UnsupportedOperation> for Error {
-    fn from(op: UnsupportedOperation) -> Error {
-        Error::UnsupportedOperation(op)
-    }
-}
-
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::Error::*;
         match self {
-            Io(e) => write!(f, "{}", e),
-            IndexAlreadyExists => write!(f, "index already exists"),
-            SchemaDiffer => write!(f, "schemas differ"),
-            SchemaMissing => write!(f, "this index does not have a schema"),
-            WordIndexMissing => write!(f, "this index does not have a word index"),
-            MissingDocumentId => write!(f, "document id is missing"),
-            Zlmdb(e) => write!(f, "heed error; {}", e),
-            Fst(e) => write!(f, "fst error; {}", e),
-            SerdeJson(e) => write!(f, "serde json error; {}", e),
             Bincode(e) => write!(f, "bincode error; {}", e),
-            Serializer(e) => write!(f, "serializer error; {}", e),
             Deserializer(e) => write!(f, "deserializer error; {}", e),
-            UnsupportedOperation(op) => write!(f, "unsupported operation; {}", op),
+            FacetError(e) => write!(f, "error processing facet filter: {}", e),
+            FilterParseError(e) => write!(f, "error parsing filter; {}", e),
+            Fst(e) => write!(f, "fst error; {}", e),
+            Heed(e) => write!(f, "heed error; {}", e),
+            IndexAlreadyExists => write!(f, "index already exists"),
+            Io(e) => write!(f, "{}", e),
+            MaxFieldsLimitExceeded => write!(f, "maximum number of fields in a document exceeded"),
+            MissingDocumentId => write!(f, "document id is missing"),
+            MissingPrimaryKey => write!(f, "schema cannot be built without a primary key"),
+            Schema(e) => write!(f, "schema error; {}", e),
+            SchemaMissing => write!(f, "this index does not have a schema"),
+            SerdeJson(e) => write!(f, "serde json error; {}", e),
+            Serializer(e) => write!(f, "serializer error; {}", e),
+            VersionMismatch(version) => write!(f, "Cannot open database, expected MeiliSearch engine version: {}, current engine version: {}.{}.{}",
+                version,
+                env!("CARGO_PKG_VERSION_MAJOR"),
+                env!("CARGO_PKG_VERSION_MINOR"),
+                env!("CARGO_PKG_VERSION_PATCH")),
+            WordIndexMissing => write!(f, "this index does not have a word index"),
         }
     }
 }
 
 impl error::Error for Error {}
 
-#[derive(Debug)]
-pub enum UnsupportedOperation {
-    SchemaAlreadyExists,
-    CannotUpdateSchemaIdentifier,
-    CannotReorderSchemaAttribute,
-    CanOnlyIntroduceNewSchemaAttributesAtEnd,
-    CannotRemoveSchemaAttribute,
+struct FilterParseError(PestError<Rule>);
+
+impl fmt::Display for FilterParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use crate::pest_error::LineColLocation::*;
+
+        let (line, column) = match self.0.line_col {
+            Span((line, _), (column, _)) => (line, column),
+            Pos((line, column)) => (line, column),
+        };
+        write!(f, "parsing error on line {} at column {}: {}", line, column, self.0.variant.message())
+    }
 }
 
-impl fmt::Display for UnsupportedOperation {
+#[derive(Debug)]
+pub enum FacetError {
+    EmptyArray,
+    ParsingError(String),
+    UnexpectedToken { expected: &'static [&'static str], found: String },
+    InvalidFormat(String),
+    AttributeNotFound(String),
+    AttributeNotSet { expected: Vec<String>, found: String },
+    InvalidDocumentAttribute(String),
+    NoAttributesForFaceting,
+}
+
+impl FacetError {
+    pub fn unexpected_token(expected: &'static [&'static str], found: impl ToString) -> FacetError {
+        FacetError::UnexpectedToken{ expected, found: found.to_string() }
+    }
+
+    pub fn attribute_not_set(expected: Vec<String>, found: impl ToString) -> FacetError {
+        FacetError::AttributeNotSet{ expected, found: found.to_string() }
+    }
+}
+
+impl fmt::Display for FacetError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::UnsupportedOperation::*;
+        use FacetError::*;
+
         match self {
-            SchemaAlreadyExists => write!(f, "Cannot update index which already have a schema"),
-            CannotUpdateSchemaIdentifier => write!(f, "Cannot update the identifier of a schema"),
-            CannotReorderSchemaAttribute => write!(f, "Cannot reorder the attributes of a schema"),
-            CanOnlyIntroduceNewSchemaAttributesAtEnd => {
-                write!(f, "Can only introduce new attributes at end of a schema")
-            }
-            CannotRemoveSchemaAttribute => write!(f, "Cannot remove attributes from a schema"),
+            EmptyArray => write!(f, "empty array in facet filter is unspecified behavior"),
+            ParsingError(msg) => write!(f, "parsing error: {}", msg),
+            UnexpectedToken { expected, found } => write!(f, "unexpected token {}, expected {}", found, expected.join("or")),
+            InvalidFormat(found) => write!(f, "invalid facet: {}, facets should be \"facetName:facetValue\"", found),
+            AttributeNotFound(attr) => write!(f, "unknown {:?} attribute", attr),
+            AttributeNotSet { found, expected } => write!(f, "`{}` is not set as a faceted attribute. available facet attributes: {}", found, expected.join(", ")),
+            InvalidDocumentAttribute(attr) => write!(f, "invalid document attribute {}, accepted types: String and [String]", attr),
+            NoAttributesForFaceting => write!(f, "impossible to perform faceted search, no attributes for faceting are set"),
         }
     }
 }

meilisearch-core/src/facets.rs

@@ -0,0 +1,357 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::ops::Deref;
+
+use cow_utils::CowUtils;
+use either::Either;
+use heed::types::{Str, OwnedType};
+use indexmap::IndexMap;
+use serde_json::Value;
+
+use meilisearch_schema::{FieldId, Schema};
+use meilisearch_types::DocumentId;
+
+use crate::database::MainT;
+use crate::error::{FacetError, MResult};
+use crate::store::BEU16;
+
+/// Data structure used to represent a boolean expression in the form of nested arrays.
+/// Values in the outer array are and-ed together, values in the inner arrays are or-ed together.
+#[derive(Debug, PartialEq)]
+pub struct FacetFilter(Vec<Either<Vec<FacetKey>, FacetKey>>);
+
+impl Deref for FacetFilter {
+    type Target = Vec<Either<Vec<FacetKey>, FacetKey>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl FacetFilter {
+    pub fn from_str(
+        s: &str,
+        schema: &Schema,
+        attributes_for_faceting: &[FieldId],
+    ) -> MResult<FacetFilter> {
+        if attributes_for_faceting.is_empty() {
+            return Err(FacetError::NoAttributesForFaceting.into());
+        }
+        let parsed = serde_json::from_str::<Value>(s).map_err(|e| FacetError::ParsingError(e.to_string()))?;
+        let mut filter = Vec::new();
+        match parsed {
+            Value::Array(and_exprs) => {
+                if and_exprs.is_empty() {
+                    return Err(FacetError::EmptyArray.into());
+                }
+                for expr in and_exprs {
+                    match expr {
+                        Value::String(s) => {
+                            let key = FacetKey::from_str( &s, schema, attributes_for_faceting)?;
+                            filter.push(Either::Right(key));
+                        }
+                        Value::Array(or_exprs) => {
+                            if or_exprs.is_empty() {
+                                return Err(FacetError::EmptyArray.into());
+                            }
+                            let mut inner = Vec::new();
+                            for expr in or_exprs {
+                                match expr {
+                                    Value::String(s) => {
+                                        let key = FacetKey::from_str( &s, schema, attributes_for_faceting)?;
+                                        inner.push(key);
+                                    }
+                                    bad_value => return Err(FacetError::unexpected_token(&["String"], bad_value).into()),
+                                }
+                            }
+                            filter.push(Either::Left(inner));
+                        }
+                        bad_value => return Err(FacetError::unexpected_token(&["Array", "String"], bad_value).into()),
+                    }
+                }
+                Ok(Self(filter))
+            }
+            bad_value => Err(FacetError::unexpected_token(&["Array"], bad_value).into()),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+#[repr(C)]
+pub struct FacetKey(FieldId, String);
+
+impl FacetKey {
+    pub fn new(field_id: FieldId, value: String) -> Self {
+        let value = match value.cow_to_lowercase() {
+                Cow::Borrowed(_) => value,
+                Cow::Owned(s) => s,
+        };
+        Self(field_id, value)
+    }
+
+    pub fn key(&self) -> FieldId {
+        self.0
+    }
+
+    pub fn value(&self) -> &str {
+        &self.1
+    }
+
+    // TODO improve parser
+    fn from_str(
+        s: &str,
+        schema: &Schema,
+        attributes_for_faceting: &[FieldId],
+    ) -> Result<Self, FacetError> {
+        let mut split = s.splitn(2, ':');
+        let key = split
+            .next()
+            .ok_or_else(|| FacetError::InvalidFormat(s.to_string()))?
+            .trim();
+        let field_id = schema
+            .id(key)
+            .ok_or_else(|| FacetError::AttributeNotFound(key.to_string()))?;
+
+        if !attributes_for_faceting.contains(&field_id) {
+            return Err(FacetError::attribute_not_set(
+                    attributes_for_faceting
+                    .iter()
+                    .filter_map(|&id| schema.name(id))
+                    .map(str::to_string)
+                    .collect::<Vec<_>>(),
+                    key))
+        }
+        let value = split
+            .next()
+            .ok_or_else(|| FacetError::InvalidFormat(s.to_string()))?
+            .trim();
+        // unquoting the string if need be:
+        let mut indices = value.char_indices();
+        let value =  match (indices.next(), indices.last()) {
+            (Some((s, '\'')), Some((e, '\''))) |
+            (Some((s, '\"')), Some((e, '\"'))) => value[s + 1..e].to_string(),
+            _ => value.to_string(),
+        };
+        Ok(Self::new(field_id, value))
+    }
+}
+
+impl<'a> heed::BytesEncode<'a> for FacetKey {
+    type EItem = FacetKey;
+
+    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<'a, [u8]>> {
+        let mut buffer = Vec::with_capacity(2 + item.1.len());
+        let id = BEU16::new(item.key().into());
+        let id_bytes = OwnedType::bytes_encode(&id)?;
+        let value_bytes = Str::bytes_encode(item.value())?;
+        buffer.extend_from_slice(id_bytes.as_ref());
+        buffer.extend_from_slice(value_bytes.as_ref());
+        Some(Cow::Owned(buffer))
+    }
+}
+
+impl<'a> heed::BytesDecode<'a> for FacetKey {
+    type DItem = FacetKey;
+
+    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+        let (id_bytes, value_bytes) = bytes.split_at(2);
+        let id = OwnedType::<BEU16>::bytes_decode(id_bytes)?;
+        let id = id.get().into();
+        let string = Str::bytes_decode(&value_bytes)?;
+        Some(FacetKey(id, string.to_string()))
+    }
+}
+
+pub fn add_to_facet_map(
+    facet_map: &mut HashMap<FacetKey, (String, Vec<DocumentId>)>,
+    field_id: FieldId,
+    value: Value,
+    document_id: DocumentId,
+) -> Result<(), FacetError> {
+    let value = match value {
+        Value::String(s) => s,
+        // ignore null
+        Value::Null => return Ok(()),
+        value => return Err(FacetError::InvalidDocumentAttribute(value.to_string())),
+    };
+    let key = FacetKey::new(field_id, value.clone());
+    facet_map.entry(key).or_insert_with(|| (value, Vec::new())).1.push(document_id);
+    Ok(())
+}
+
+pub fn facet_map_from_docids(
+    rtxn: &heed::RoTxn<MainT>,
+    index: &crate::Index,
+    document_ids: &[DocumentId],
+    attributes_for_facetting: &[FieldId],
+) -> MResult<HashMap<FacetKey, (String, Vec<DocumentId>)>> {
+    // A hashmap that ascociate a facet key to a pair containing the original facet attribute
+    // string with it's case preserved, and a list of document ids for that facet attribute.
+    let mut facet_map: HashMap<FacetKey, (String, Vec<DocumentId>)> = HashMap::new();
+    for document_id in document_ids {
+        for result in index
+            .documents_fields
+            .document_fields(rtxn, *document_id)?
+        {
+            let (field_id, bytes) = result?;
+            if attributes_for_facetting.contains(&field_id) {
+                match serde_json::from_slice(bytes)? {
+                    Value::Array(values) => {
+                        for v in values {
+                            add_to_facet_map(&mut facet_map, field_id, v, *document_id)?;
+                        }
+                    }
+                    v => add_to_facet_map(&mut facet_map, field_id, v, *document_id)?,
+                };
+            }
+        }
+    }
+    Ok(facet_map)
+}
+
+pub fn facet_map_from_docs(
+    schema: &Schema,
+    documents: &HashMap<DocumentId, IndexMap<String, Value>>,
+    attributes_for_facetting: &[FieldId],
+) -> MResult<HashMap<FacetKey, (String, Vec<DocumentId>)>> {
+    let mut facet_map = HashMap::new();
+    let attributes_for_facetting = attributes_for_facetting
+        .iter()
+        .filter_map(|&id| schema.name(id).map(|name| (id, name)))
+        .collect::<Vec<_>>();
+
+    for (id, document) in documents {
+        for (field_id, name) in &attributes_for_facetting {
+            if let Some(value) = document.get(*name) {
+                match value {
+                    Value::Array(values) => {
+                        for v in values {
+                            add_to_facet_map(&mut facet_map, *field_id, v.clone(), *id)?;
+                        }
+                    }
+                    v => add_to_facet_map(&mut facet_map, *field_id, v.clone(), *id)?,
+                }
+            }
+        }
+    }
+    Ok(facet_map)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use meilisearch_schema::Schema;
+
+    #[test]
+    fn test_facet_key() {
+        let mut schema = Schema::default();
+        let id = schema.insert_with_position("hello").unwrap().0;
+        let facet_list = [schema.id("hello").unwrap()];
+        assert_eq!(
+            FacetKey::from_str("hello:12", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "12".to_string())
+        );
+        assert_eq!(
+            FacetKey::from_str("hello:\"foo bar\"", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "foo bar".to_string())
+        );
+        assert_eq!(
+            FacetKey::from_str("hello:'foo bar'", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "foo bar".to_string())
+        );
+        // weird case
+        assert_eq!(
+            FacetKey::from_str("hello:blabla:machin", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "blabla:machin".to_string())
+        );
+
+        assert_eq!(
+            FacetKey::from_str("hello:\"\"", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "".to_string())
+        );
+
+        assert_eq!(
+            FacetKey::from_str("hello:'", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "'".to_string())
+        );
+        assert_eq!(
+            FacetKey::from_str("hello:''", &schema, &facet_list).unwrap(),
+            FacetKey::new(id, "".to_string())
+        );
+        assert!(FacetKey::from_str("hello", &schema, &facet_list).is_err());
+        assert!(FacetKey::from_str("toto:12", &schema, &facet_list).is_err());
+    }
+
+    #[test]
+    fn test_parse_facet_array() {
+        use either::Either::{Left, Right};
+        let mut schema = Schema::default();
+        let _id = schema.insert_with_position("hello").unwrap();
+        let facet_list = [schema.id("hello").unwrap()];
+        assert_eq!(
+            FacetFilter::from_str("[[\"hello:12\"]]", &schema, &facet_list).unwrap(),
+            FacetFilter(vec![Left(vec![FacetKey(FieldId(0), "12".to_string())])])
+        );
+        assert_eq!(
+            FacetFilter::from_str("[\"hello:12\"]", &schema, &facet_list).unwrap(),
+            FacetFilter(vec![Right(FacetKey(FieldId(0), "12".to_string()))])
+        );
+        assert_eq!(
+            FacetFilter::from_str("[\"hello:12\", \"hello:13\"]", &schema, &facet_list).unwrap(),
+            FacetFilter(vec![
+                Right(FacetKey(FieldId(0), "12".to_string())),
+                Right(FacetKey(FieldId(0), "13".to_string()))
+            ])
+        );
+        assert_eq!(
+            FacetFilter::from_str("[[\"hello:12\", \"hello:13\"]]", &schema, &facet_list).unwrap(),
+            FacetFilter(vec![Left(vec![
+                FacetKey(FieldId(0), "12".to_string()),
+                FacetKey(FieldId(0), "13".to_string())
+            ])])
+        );
+        assert_eq!(
+            FacetFilter::from_str(
+                "[[\"hello:12\", \"hello:13\"], \"hello:14\"]",
+                &schema,
+                &facet_list
+            )
+            .unwrap(),
+            FacetFilter(vec![
+                Left(vec![
+                    FacetKey(FieldId(0), "12".to_string()),
+                    FacetKey(FieldId(0), "13".to_string())
+                ]),
+                Right(FacetKey(FieldId(0), "14".to_string()))
+            ])
+        );
+
+        // invalid array depths
+        assert!(FacetFilter::from_str(
+            "[[[\"hello:12\", \"hello:13\"], \"hello:14\"]]",
+            &schema,
+            &facet_list
+        )
+        .is_err());
+        assert!(FacetFilter::from_str(
+            "[[[\"hello:12\", \"hello:13\"]], \"hello:14\"]]",
+            &schema,
+            &facet_list
+        )
+        .is_err());
+        assert!(FacetFilter::from_str("\"hello:14\"", &schema, &facet_list).is_err());
+
+        // unexisting key
+        assert!(FacetFilter::from_str("[\"foo:12\"]", &schema, &facet_list).is_err());
+
+        // invalid facet key
+        assert!(FacetFilter::from_str("[\"foo=12\"]", &schema, &facet_list).is_err());
+        assert!(FacetFilter::from_str("[\"foo12\"]", &schema, &facet_list).is_err());
+        assert!(FacetFilter::from_str("[\"\"]", &schema, &facet_list).is_err());
+
+        // empty array error
+        assert!(FacetFilter::from_str("[]", &schema, &facet_list).is_err());
+        assert!(FacetFilter::from_str("[\"hello:12\", []]", &schema, &facet_list).is_err());
+    }
+}

meilisearch-core/src/filters/condition.rs

@@ -0,0 +1,276 @@
+use std::str::FromStr;
+use std::cmp::Ordering;
+
+use crate::error::Error;
+use crate::{store::Index, DocumentId, MainT};
+use heed::RoTxn;
+use meilisearch_schema::{FieldId, Schema};
+use pest::error::{Error as PestError, ErrorVariant};
+use pest::iterators::Pair;
+use serde_json::{Value, Number};
+use super::parser::Rule;
+
+#[derive(Debug, PartialEq)]
+enum ConditionType {
+    Greater,
+    Less,
+    Equal,
+    LessEqual,
+    GreaterEqual,
+    NotEqual,
+}
+
+/// We need to infer type when the filter is constructed
+/// and match every possible types it can be parsed into.
+#[derive(Debug)]
+struct ConditionValue<'a> {
+    string: &'a str,
+    boolean: Option<bool>,
+    number: Option<Number>
+}
+
+impl<'a> ConditionValue<'a> {
+    pub fn new(value: &Pair<'a, Rule>) -> Self {
+        match value.as_rule() {
+            Rule::string | Rule::word => {
+                let string =  value.as_str();
+                let boolean = match value.as_str() {
+                    "true" => Some(true),
+                    "false" => Some(false),
+                    _ => None,
+                };
+                let number = Number::from_str(value.as_str()).ok();
+                ConditionValue { string, boolean, number }
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.string
+    }
+
+    pub fn as_number(&self) -> Option<&Number> {
+        self.number.as_ref()
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        self.boolean
+    }
+}
+
+#[derive(Debug)]
+pub struct Condition<'a> {
+    field: FieldId,
+    condition: ConditionType,
+    value: ConditionValue<'a>
+}
+
+fn get_field_value<'a>(schema: &Schema, pair: Pair<'a, Rule>) -> Result<(FieldId, ConditionValue<'a>), Error> {
+    let mut items = pair.into_inner();
+    // lexing ensures that we at least have a key
+    let key = items.next().unwrap();
+    let field = schema
+        .id(key.as_str())
+        .ok_or_else(|| PestError::new_from_span(
+                ErrorVariant::CustomError {
+                    message: format!(
+                                 "attribute `{}` not found, available attributes are: {}",
+                                 key.as_str(),
+                                 schema.names().collect::<Vec<_>>().join(", ")
+                             ),
+                },
+                key.as_span()))?;
+    let value = ConditionValue::new(&items.next().unwrap());
+    Ok((field, value))
+}
+
+// undefined behavior with big numbers
+fn compare_numbers(lhs: &Number, rhs: &Number) -> Option<Ordering> {
+    match (lhs.as_i64(), lhs.as_u64(), lhs.as_f64(),
+        rhs.as_i64(), rhs.as_u64(), rhs.as_f64()) {
+    //    i64   u64  f64  i64  u64  f64
+        (Some(lhs), _, _, Some(rhs), _, _) => lhs.partial_cmp(&rhs),
+        (_, Some(lhs), _, _, Some(rhs), _) => lhs.partial_cmp(&rhs),
+        (_, _, Some(lhs), _, _, Some(rhs)) => lhs.partial_cmp(&rhs),
+        (_, _, _, _, _, _) => None,
+    }
+}
+
+impl<'a> Condition<'a> {
+    pub fn less(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::Less;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn greater(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::Greater;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn neq(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::NotEqual;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn geq(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::GreaterEqual;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn leq(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::LessEqual;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn eq(
+        item: Pair<'a, Rule>,
+        schema: &'a Schema,
+    ) -> Result<Self, Error> {
+        let (field, value) = get_field_value(schema, item)?;
+        let condition = ConditionType::Equal;
+        Ok(Self { field, condition, value })
+    }
+
+    pub fn test(
+        &self,
+        reader: &RoTxn<MainT>,
+        index: &Index,
+        document_id: DocumentId,
+    ) -> Result<bool, Error> {
+        match index.document_attribute::<Value>(reader, document_id, self.field)? {
+            Some(Value::Array(values)) => Ok(values.iter().any(|v| self.match_value(Some(v)))),
+            other => Ok(self.match_value(other.as_ref())),
+        }
+    }
+
+    fn match_value(&self, value: Option<&Value>) -> bool {
+        match value {
+            Some(Value::String(s)) => {
+                let value = self.value.as_str();
+                match self.condition {
+                    ConditionType::Equal => unicase::eq(value, &s),
+                    ConditionType::NotEqual => !unicase::eq(value, &s),
+                    _ => false
+                }
+            },
+            Some(Value::Number(n)) => { 
+                if let Some(value) = self.value.as_number() {
+                    if let Some(ord) = compare_numbers(&n, value) {
+                        let res =  match self.condition {
+                            ConditionType::Equal => ord == Ordering::Equal,
+                            ConditionType::NotEqual => ord != Ordering::Equal,
+                            ConditionType::GreaterEqual => ord != Ordering::Less,
+                            ConditionType::LessEqual => ord != Ordering::Greater,
+                            ConditionType::Greater => ord == Ordering::Greater,
+                            ConditionType::Less => ord == Ordering::Less,
+                        };
+                        return res
+                    } 
+                } 
+                false
+            },
+            Some(Value::Bool(b)) => {
+                if let Some(value) = self.value.as_bool() {
+                    let res = match self.condition {
+                        ConditionType::Equal => *b == value,
+                        ConditionType::NotEqual => *b != value,
+                        _ => false
+                    };
+                    return res
+                }
+                false
+            },
+            // if field is not supported (or not found), all values are different from it,
+            // so != should always return true in this case.
+            _ => self.condition == ConditionType::NotEqual,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use serde_json::Number;
+    use std::cmp::Ordering;
+
+    #[test]
+    fn test_number_comp() {
+        // test both u64
+        let n1 = Number::from(1u64);
+        let n2 = Number::from(2u64);
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n2, &n1));
+        let n1 = Number::from(1u64);
+        let n2 = Number::from(1u64);
+        assert_eq!(Some(Ordering::Equal), compare_numbers(&n1, &n2));
+
+        // test both i64
+        let n1 = Number::from(1i64);
+        let n2 = Number::from(2i64);
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n2, &n1));
+        let n1 = Number::from(1i64);
+        let n2 = Number::from(1i64);
+        assert_eq!(Some(Ordering::Equal), compare_numbers(&n1, &n2));
+
+        // test both f64
+        let n1 = Number::from_f64(1f64).unwrap();
+        let n2 = Number::from_f64(2f64).unwrap();
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n2, &n1));
+        let n1 = Number::from_f64(1f64).unwrap();
+        let n2 = Number::from_f64(1f64).unwrap();
+        assert_eq!(Some(Ordering::Equal), compare_numbers(&n1, &n2));
+
+        // test one u64 and one f64
+        let n1 = Number::from_f64(1f64).unwrap();
+        let n2 = Number::from(2u64);
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n2, &n1));
+
+        // equality
+        let n1 = Number::from_f64(1f64).unwrap();
+        let n2 = Number::from(1u64);
+        assert_eq!(Some(Ordering::Equal), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Equal), compare_numbers(&n2, &n1));
+
+        // float is neg
+        let n1 = Number::from_f64(-1f64).unwrap();
+        let n2 = Number::from(1u64);
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n2, &n1));
+
+        // float is too big
+        let n1 = Number::from_f64(std::f64::MAX).unwrap();
+        let n2 = Number::from(1u64);
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n1, &n2));
+        assert_eq!(Some(Ordering::Less), compare_numbers(&n2, &n1));
+
+        // misc
+        let n1 = Number::from_f64(std::f64::MAX).unwrap();
+        let n2 = Number::from(std::u64::MAX);
+        assert_eq!(Some(Ordering::Greater), compare_numbers(&n1, &n2));
+        assert_eq!(Some( Ordering::Less ), compare_numbers(&n2, &n1));
+    }
+}

meilisearch-core/src/filters/mod.rs

@@ -0,0 +1,127 @@
+mod parser;
+mod condition;
+
+pub(crate) use parser::Rule;
+
+use std::ops::Not;
+
+use condition::Condition;
+use crate::error::Error;
+use crate::{DocumentId, MainT, store::Index};
+use heed::RoTxn;
+use meilisearch_schema::Schema;
+use parser::{PREC_CLIMBER, FilterParser};
+use pest::iterators::{Pair, Pairs};
+use pest::Parser;
+
+type FilterResult<'a> = Result<Filter<'a>, Error>;
+
+#[derive(Debug)]
+pub enum Filter<'a> {
+    Condition(Condition<'a>),
+    Or(Box<Self>, Box<Self>),
+    And(Box<Self>, Box<Self>),
+    Not(Box<Self>),
+}
+
+impl<'a> Filter<'a> {
+    pub fn parse(expr: &'a str, schema: &'a Schema) -> FilterResult<'a> {
+        let mut lexed = FilterParser::parse(Rule::prgm, expr)?;
+        Self::build(lexed.next().unwrap().into_inner(), schema)
+    }
+
+    pub fn test(
+        &self,
+        reader: &RoTxn<MainT>,
+        index: &Index,
+        document_id: DocumentId,
+    ) -> Result<bool, Error> {
+        use Filter::*;
+        match self {
+            Condition(c) => c.test(reader, index, document_id),
+            Or(lhs, rhs) => Ok(
+                lhs.test(reader, index, document_id)? || rhs.test(reader, index, document_id)?
+            ),
+            And(lhs, rhs) => Ok(
+                lhs.test(reader, index, document_id)? && rhs.test(reader, index, document_id)?
+            ),
+            Not(op) => op.test(reader, index, document_id).map(bool::not),
+        }
+    }
+
+    fn build(expression: Pairs<'a, Rule>, schema: &'a Schema) -> FilterResult<'a> {
+        PREC_CLIMBER.climb(
+            expression,
+            |pair: Pair<Rule>| match pair.as_rule() {
+                Rule::eq => Ok(Filter::Condition(Condition::eq(pair, schema)?)),
+                Rule::greater => Ok(Filter::Condition(Condition::greater(pair, schema)?)),
+                Rule::less => Ok(Filter::Condition(Condition::less(pair, schema)?)),
+                Rule::neq => Ok(Filter::Condition(Condition::neq(pair, schema)?)),
+                Rule::geq => Ok(Filter::Condition(Condition::geq(pair, schema)?)),
+                Rule::leq => Ok(Filter::Condition(Condition::leq(pair, schema)?)),
+                Rule::prgm => Self::build(pair.into_inner(), schema),
+                Rule::term => Self::build(pair.into_inner(), schema),
+                Rule::not => Ok(Filter::Not(Box::new(Self::build(
+                    pair.into_inner(),
+                    schema,
+                )?))),
+                _ => unreachable!(),
+            },
+            |lhs: FilterResult, op: Pair<Rule>, rhs: FilterResult| match op.as_rule() {
+                Rule::or => Ok(Filter::Or(Box::new(lhs?), Box::new(rhs?))),
+                Rule::and => Ok(Filter::And(Box::new(lhs?), Box::new(rhs?))),
+                _ => unreachable!(),
+            },
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn invalid_syntax() {
+        assert!(FilterParser::parse(Rule::prgm, "field : id").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "field=hello hello").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "field=hello OR OR").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "OR field:hello").is_err());
+        assert!(FilterParser::parse(Rule::prgm, r#"field="hello world"#).is_err());
+        assert!(FilterParser::parse(Rule::prgm, r#"field='hello world"#).is_err());
+        assert!(FilterParser::parse(Rule::prgm, "NOT field=").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "N").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "(field=1").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "(field=1))").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "field=1ORfield=2").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "field=1 ( OR field=2)").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "hello world=1").is_err());
+        assert!(FilterParser::parse(Rule::prgm, "").is_err());
+        assert!(FilterParser::parse(Rule::prgm, r#"((((((hello=world)))))"#).is_err());
+    }
+
+    #[test]
+    fn valid_syntax() {
+        assert!(FilterParser::parse(Rule::prgm, "field = id").is_ok());
+        assert!(FilterParser::parse(Rule::prgm, "field=id").is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field >= 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field <= 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field="hello world""#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field='hello world'"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field > 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field < 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field < 10 AND NOT field=5"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field < 10 AND NOT field > 7.5"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field=true OR NOT field=5"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"NOT field=true OR NOT field=5"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field='hello world' OR ( NOT field=true OR NOT field=5 )"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field='hello \'worl\'d' OR ( NOT field=true OR NOT field=5 )"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"field="hello \"worl\"d" OR ( NOT field=true OR NOT field=5 )"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"((((((hello=world))))))"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#""foo bar" > 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#""foo bar" = 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"'foo bar' = 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"'foo bar' <= 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"'foo bar' != 10"#).is_ok());
+        assert!(FilterParser::parse(Rule::prgm, r#"bar != 10"#).is_ok());
+    }
+}

meilisearch-core/src/filters/parser/grammar.pest

@@ -0,0 +1,28 @@
+key = _{quoted | word}
+value = _{quoted | word}
+quoted = _{ (PUSH("'") | PUSH("\"")) ~ string ~ POP  }
+string = {char*}
+word = ${(LETTER | NUMBER | "_" | "-" | ".")+}
+
+char =  _{ !(PEEK | "\\") ~ ANY
+    | "\\" ~ (PEEK | "\\" | "/" | "b" | "f" | "n" | "r" | "t")
+    | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})}
+
+condition = _{eq | greater | less | geq | leq | neq}
+geq = {key ~ ">=" ~ value}
+leq = {key ~ "<=" ~ value}
+neq = {key ~ "!=" ~ value}
+eq = {key ~ "=" ~ value}
+greater = {key ~ ">" ~ value}
+less = {key ~ "<" ~ value}
+
+prgm = {SOI ~ expr ~ EOI}
+expr = _{ ( term ~ (operation ~ term)* ) }
+term = { ("(" ~ expr ~ ")") | condition | not }
+operation = _{ and | or }
+	and = {"AND"}
+	or = {"OR"}
+
+not = {"NOT" ~ term}
+
+WHITESPACE = _{ " " }

meilisearch-core/src/filters/parser/mod.rs

@@ -0,0 +1,12 @@
+use once_cell::sync::Lazy;
+use pest::prec_climber::{Operator, Assoc, PrecClimber};
+
+pub static PREC_CLIMBER: Lazy<PrecClimber<Rule>> = Lazy::new(|| {
+    use Assoc::*;
+    use Rule::*;
+    pest::prec_climber::PrecClimber::new(vec![Operator::new(or, Left), Operator::new(and, Left)])
+});
+
+#[derive(Parser)]
+#[grammar = "filters/parser/grammar.pest"]
+pub struct FilterParser;

meilisearch-core/src/lib.rs

@@ -1,87 +1,193 @@
+#![allow(clippy::type_complexity)]
+
 #[cfg(test)]
 #[macro_use]
 extern crate assert_matches;
+#[macro_use]
+extern crate pest_derive;
 
 mod automaton;
-pub mod criterion;
+mod bucket_sort;
 mod database;
 mod distinct_map;
 mod error;
+mod filters;
 mod levenshtein;
 mod number;
 mod query_builder;
+mod query_tree;
+mod query_words_mapper;
 mod ranked_map;
 mod raw_document;
-pub mod raw_indexer;
 mod reordered_attrs;
+pub mod criterion;
+pub mod facets;
+pub mod raw_indexer;
 pub mod serde;
+pub mod settings;
 pub mod store;
-mod update;
+pub mod update;
 
-pub use self::database::{BoxUpdateFn, Database};
-pub use self::error::{Error, MResult};
+pub use self::database::{BoxUpdateFn, Database, DatabaseOptions, MainT, UpdateT, MainWriter, MainReader, UpdateWriter, UpdateReader};
+pub use self::error::{Error, HeedError, FstError, MResult, pest_error, FacetError};
+pub use self::filters::Filter;
 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};
+pub use meilisearch_schema::Schema;
+pub use query_words_mapper::QueryWordsMapper;
+pub use query_tree::MAX_QUERY_LEN;
 
-#[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,
-}
+use compact_arena::SmallArena;
+use log::{error, trace};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::convert::TryFrom;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+use crate::bucket_sort::PostingsListView;
+use crate::levenshtein::prefix_damerau_levenshtein;
+use crate::query_tree::{QueryId, QueryKind};
+use crate::reordered_attrs::ReorderedAttrs;
+
+type FstSetCow<'a> = fst::Set<Cow<'a, [u8]>>;
+type FstMapCow<'a> = fst::Map<Cow<'a, [u8]>>;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Document {
     pub id: DocumentId,
     pub highlights: Vec<Highlight>,
 
     #[cfg(test)]
-    pub matches: Vec<TmpMatch>,
+    pub matches: Vec<crate::bucket_sort::SimpleMatch>,
+}
+
+fn highlights_from_raw_document<'a, 'tag, 'txn>(
+    raw_document: &RawDocument<'a, 'tag>,
+    queries_kinds: &HashMap<QueryId, &QueryKind>,
+    arena: &SmallArena<'tag, PostingsListView<'txn>>,
+    searchable_attrs: Option<&ReorderedAttrs>,
+    schema: &Schema,
+) -> Vec<Highlight>
+{
+    let mut highlights = Vec::new();
+
+    for bm in raw_document.bare_matches.iter() {
+        let postings_list = &arena[bm.postings_list];
+        let input = postings_list.input();
+        let kind = &queries_kinds.get(&bm.query_index);
+
+        for di in postings_list.iter() {
+            let covered_area = match kind {
+                Some(QueryKind::NonTolerant(query)) | Some(QueryKind::Tolerant(query)) => {
+                    let len = if query.len() > input.len() {
+                        input.len()
+                    } else {
+                        prefix_damerau_levenshtein(query.as_bytes(), input).1
+                    };
+                    u16::try_from(len).unwrap_or(u16::max_value())
+                },
+                _ => di.char_length,
+            };
+
+            let attribute = searchable_attrs
+                .and_then(|sa| sa.reverse(di.attribute))
+                .unwrap_or(di.attribute);
+
+            let attribute = match schema.indexed_pos_to_field_id(attribute) {
+                Some(field_id) => field_id.0,
+                None => {
+                    error!("Cannot convert indexed_pos {} to field_id", attribute);
+                    trace!("Schema is compromized; {:?}", schema);
+                    continue
+                }
+            };
+
+            let highlight = Highlight {
+                attribute,
+                char_index: di.char_index,
+                char_length: covered_area,
+            };
+
+            highlights.push(highlight);
+        }
+    }
+
+    highlights
 }
 
 impl Document {
     #[cfg(not(test))]
-    fn from_raw(raw: RawDocument) -> Document {
-        Document {
-            id: raw.id,
-            highlights: raw.highlights,
-        }
+    pub fn from_highlights(id: DocumentId, highlights: &[Highlight]) -> Document {
+        Document { id, highlights: highlights.to_owned() }
     }
 
     #[cfg(test)]
-    fn from_raw(raw: RawDocument) -> Document {
-        let len = raw.query_index().len();
-        let mut matches = Vec::with_capacity(len);
+    pub fn from_highlights(id: DocumentId, highlights: &[Highlight]) -> Document {
+        Document { id, highlights: highlights.to_owned(), matches: Vec::new() }
+    }
 
-        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();
+    #[cfg(not(test))]
+    pub fn from_raw<'a, 'tag, 'txn>(
+        raw_document: RawDocument<'a, 'tag>,
+        queries_kinds: &HashMap<QueryId, &QueryKind>,
+        arena: &SmallArena<'tag, PostingsListView<'txn>>,
+        searchable_attrs: Option<&ReorderedAttrs>,
+        schema: &Schema,
+    ) -> Document
+    {
+        let highlights = highlights_from_raw_document(
+            &raw_document,
+            queries_kinds,
+            arena,
+            searchable_attrs,
+            schema,
+        );
 
-        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],
+        Document { id: raw_document.id, highlights }
+    }
+
+    #[cfg(test)]
+    pub fn from_raw<'a, 'tag, 'txn>(
+        raw_document: RawDocument<'a, 'tag>,
+        queries_kinds: &HashMap<QueryId, &QueryKind>,
+        arena: &SmallArena<'tag, PostingsListView<'txn>>,
+        searchable_attrs: Option<&ReorderedAttrs>,
+        schema: &Schema,
+    ) -> Document
+    {
+        use crate::bucket_sort::SimpleMatch;
+
+        let highlights = highlights_from_raw_document(
+            &raw_document,
+            queries_kinds,
+            arena,
+            searchable_attrs,
+            schema,
+        );
+
+        let mut matches = Vec::new();
+        for sm in raw_document.processed_matches {
+            let attribute = searchable_attrs
+                .and_then(|sa| sa.reverse(sm.attribute))
+                .unwrap_or(sm.attribute);
+
+            let attribute = match schema.indexed_pos_to_field_id(attribute) {
+                Some(field_id) => field_id.0,
+                None => {
+                    error!("Cannot convert indexed_pos {} to field_id", attribute);
+                    trace!("Schema is compromized; {:?}", schema);
+                    continue
+                }
             };
-            matches.push(match_);
-        }
 
-        Document {
-            id: raw.id,
-            matches,
-            highlights: raw.highlights,
+            matches.push(SimpleMatch { attribute, ..sm });
         }
+        matches.sort_unstable();
+
+        Document { id: raw_document.id, highlights, matches }
     }
 }
 
@@ -92,6 +198,6 @@ mod tests {
 
     #[test]
     fn docindex_mem_size() {
-        assert_eq!(mem::size_of::<DocIndex>(), 16);
+        assert_eq!(mem::size_of::<DocIndex>(), 12);
     }
 }

meilisearch-core/src/number.rs

@@ -6,11 +6,18 @@ use std::str::FromStr;
 use ordered_float::OrderedFloat;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, Debug, Copy, Clone, Hash)]
+#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
 pub enum Number {
     Unsigned(u64),
     Signed(i64),
     Float(OrderedFloat<f64>),
+    Null,
+}
+
+impl Default for Number {
+    fn default() -> Self {
+        Self::Null
+    }
 }
 
 impl FromStr for Number {
@@ -56,7 +63,7 @@ impl PartialOrd for Number {
 
 impl Ord for Number {
     fn cmp(&self, other: &Self) -> Ordering {
-        use Number::{Float, Signed, Unsigned};
+        use Number::{Float, Signed, Unsigned, Null};
 
         match (*self, *other) {
             (Unsigned(a), Unsigned(b)) => a.cmp(&b),
@@ -80,6 +87,9 @@ impl Ord for Number {
             (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),
+            (Null, Null) => Ordering::Equal,
+            (_, Null) => Ordering::Less,
+            (Null, _) => Ordering::Greater,
         }
     }
 }

meilisearch-core/src/query_enhancer.rs

@@ -1,398 +0,0 @@
-use std::ops::Range;
-use std::cmp::Ordering::{Less, Greater, Equal};
-
-/// Return `true` if the specified range can accept the given replacements words.
-/// Returns `false` if the replacements words are already present in the original query
-/// or if there is fewer replacement words than the range to replace.
-//
-//
-// ## Ignored because already present in original
-//
-//     new york city subway
-//     -------- ^^^^
-//   /          \
-//  [new york city]
-//
-//
-// ## Ignored because smaller than the original
-//
-//   new york city subway
-//   -------------
-//   \          /
-//    [new york]
-//
-//
-// ## Accepted because bigger than the original
-//
-//        NYC subway
-//        ---
-//       /   \
-//      /     \
-//     /       \
-//    /         \
-//   /           \
-//  [new york city]
-//
-fn rewrite_range_with<S, T>(query: &[S], range: Range<usize>, words: &[T]) -> bool
-where S: AsRef<str>,
-      T: AsRef<str>,
-{
-    if words.len() <= range.len() {
-        // there is fewer or equal replacement words
-        // than there is already in the replaced range
-        return false
-    }
-
-    // retrieve the part to rewrite but with the length
-    // of the replacement part
-    let original = query.iter().skip(range.start).take(words.len());
-
-    // check if the original query doesn't already contain
-    // the replacement words
-    !original.map(AsRef::as_ref).eq(words.iter().map(AsRef::as_ref))
-}
-
-type Origin = usize;
-type RealLength = usize;
-
-struct FakeIntervalTree {
-    intervals: Vec<(Range<usize>, (Origin, RealLength))>,
-}
-
-impl FakeIntervalTree {
-    fn new(mut intervals: Vec<(Range<usize>, (Origin, RealLength))>) -> FakeIntervalTree {
-        intervals.sort_unstable_by_key(|(r, _)| (r.start, r.end));
-        FakeIntervalTree { intervals }
-    }
-
-    fn query(&self, point: usize) -> Option<(Range<usize>, (Origin, RealLength))> {
-        let element = self.intervals.binary_search_by(|(r, _)| {
-            if point >= r.start {
-                if point < r.end { Equal } else { Less }
-            } else { Greater }
-        });
-
-        let n = match element { Ok(n) => n, Err(n) => n };
-
-        match self.intervals.get(n) {
-            Some((range, value)) if range.contains(&point) => Some((range.clone(), *value)),
-            _otherwise => None,
-        }
-    }
-}
-
-pub struct QueryEnhancerBuilder<'a, S> {
-    query: &'a [S],
-    origins: Vec<usize>,
-    real_to_origin: Vec<(Range<usize>, (Origin, RealLength))>,
-}
-
-impl<S: AsRef<str>> QueryEnhancerBuilder<'_, S> {
-    pub fn new(query: &[S]) -> QueryEnhancerBuilder<S> {
-        // we initialize origins query indices based on their positions
-        let origins: Vec<_> = (0..query.len() + 1).collect();
-        let real_to_origin = origins.iter().map(|&o| (o..o+1, (o, 1))).collect();
-
-        QueryEnhancerBuilder { query, origins, real_to_origin }
-    }
-
-    /// Update the final real to origin query indices mapping.
-    ///
-    /// `range` is the original words range that this `replacement` words replace
-    /// and `real` is the first real query index of these replacement words.
-    pub fn declare<T>(&mut self, range: Range<usize>, real: usize, replacement: &[T])
-    where T: AsRef<str>,
-    {
-        // check if the range of original words
-        // can be rewritten with the replacement words
-        if rewrite_range_with(self.query, range.clone(), replacement) {
-
-            // this range can be replaced so we need to
-            // modify the origins accordingly
-            let offset = replacement.len() - range.len();
-
-            let previous_padding = self.origins[range.end - 1];
-            let current_offset = (self.origins[range.end] - 1) - previous_padding;
-            let diff = offset.saturating_sub(current_offset);
-            self.origins[range.end] += diff;
-
-            for r in &mut self.origins[range.end + 1..] {
-                *r += diff;
-            }
-        }
-
-        // we need to store the real number and origins relations
-        // this way it will be possible to know by how many
-        // we need to pad real query indices
-        let real_range = real..real + replacement.len().max(range.len());
-        let real_length = replacement.len();
-        self.real_to_origin.push((real_range, (range.start, real_length)));
-    }
-
-    pub fn build(self) -> QueryEnhancer {
-        QueryEnhancer {
-            origins: self.origins,
-            real_to_origin: FakeIntervalTree::new(self.real_to_origin),
-        }
-    }
-}
-
-pub struct QueryEnhancer {
-    origins: Vec<usize>,
-    real_to_origin: FakeIntervalTree,
-}
-
-impl QueryEnhancer {
-    /// Returns the query indices to use to replace this real query index.
-    pub fn replacement(&self, real: u32) -> Range<u32> {
-        let real = real as usize;
-
-        // query the fake interval tree with the real query index
-        let (range, (origin, real_length)) =
-            self.real_to_origin
-                .query(real)
-                .expect("real has never been declared");
-
-        // if `real` is the end bound of the range
-        if (range.start + real_length - 1) == real {
-            let mut count = range.len();
-            let mut new_origin = origin;
-            for (i, slice) in self.origins[new_origin..].windows(2).enumerate() {
-                let len = slice[1] - slice[0];
-                count = count.saturating_sub(len);
-                if count == 0 { new_origin = origin + i; break }
-            }
-
-            let n = real - range.start;
-            let start = self.origins[origin];
-            let end = self.origins[new_origin + 1];
-            let remaining = (end - start) - n;
-
-            Range { start: (start + n) as u32, end: (start + n + remaining) as u32 }
-
-        } else {
-            // just return the origin along with
-            // the real position of the word
-            let n = real as usize - range.start;
-            let origin = self.origins[origin];
-
-            Range { start: (origin + n) as u32, end: (origin + n + 1) as u32 }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn original_unmodified() {
-        let query = ["new", "york", "city", "subway"];
-        //             0       1       2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // new york = new york city
-        builder.declare(0..2, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // new
-        assert_eq!(enhancer.replacement(1), 1..2); // york
-        assert_eq!(enhancer.replacement(2), 2..3); // city
-        assert_eq!(enhancer.replacement(3), 3..4); // subway
-        assert_eq!(enhancer.replacement(4), 0..1); // new
-        assert_eq!(enhancer.replacement(5), 1..2); // york
-        assert_eq!(enhancer.replacement(6), 2..3); // city
-    }
-
-    #[test]
-    fn simple_growing() {
-        let query = ["new", "york", "subway"];
-        //             0       1        2
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // new york = new york city
-        builder.declare(0..2, 3, &["new", "york", "city"]);
-        //                    ^      3       4       5
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // new
-        assert_eq!(enhancer.replacement(1), 1..3); // york
-        assert_eq!(enhancer.replacement(2), 3..4); // subway
-        assert_eq!(enhancer.replacement(3), 0..1); // new
-        assert_eq!(enhancer.replacement(4), 1..2); // york
-        assert_eq!(enhancer.replacement(5), 2..3); // city
-    }
-
-    #[test]
-    fn same_place_growings() {
-        let query = ["NY", "subway"];
-        //             0       1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NY = new york
-        builder.declare(0..1, 2, &["new", "york"]);
-        //                    ^      2       3
-
-        // NY = new york city
-        builder.declare(0..1, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // NY = NYC
-        builder.declare(0..1, 7, &["NYC"]);
-        //                    ^      7
-
-        // NY = new york city
-        builder.declare(0..1, 8, &["new", "york", "city"]);
-        //                    ^      8       9      10
-
-        // subway = underground train
-        builder.declare(1..2, 11, &["underground", "train"]);
-        //                    ^          11          12
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..3); // NY
-        assert_eq!(enhancer.replacement(1), 3..5); // subway
-        assert_eq!(enhancer.replacement(2), 0..1); // new
-        assert_eq!(enhancer.replacement(3), 1..3); // york
-        assert_eq!(enhancer.replacement(4), 0..1); // new
-        assert_eq!(enhancer.replacement(5), 1..2); // york
-        assert_eq!(enhancer.replacement(6), 2..3); // city
-        assert_eq!(enhancer.replacement(7), 0..3); // NYC
-        assert_eq!(enhancer.replacement(8), 0..1); // new
-        assert_eq!(enhancer.replacement(9), 1..2); // york
-        assert_eq!(enhancer.replacement(10), 2..3); // city
-        assert_eq!(enhancer.replacement(11), 3..4); // underground
-        assert_eq!(enhancer.replacement(12), 4..5); // train
-    }
-
-    #[test]
-    fn bigger_growing() {
-        let query = ["NYC", "subway"];
-        //             0        1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(0..1, 2, &["new", "york", "city"]);
-        //                    ^      2       3       4
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..3); // NYC
-        assert_eq!(enhancer.replacement(1), 3..4); // subway
-        assert_eq!(enhancer.replacement(2), 0..1); // new
-        assert_eq!(enhancer.replacement(3), 1..2); // york
-        assert_eq!(enhancer.replacement(4), 2..3); // city
-    }
-
-    #[test]
-    fn middle_query_growing() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // great
-        assert_eq!(enhancer.replacement(1), 1..2); // awesome
-        assert_eq!(enhancer.replacement(2), 2..5); // NYC
-        assert_eq!(enhancer.replacement(3), 5..6); // subway
-        assert_eq!(enhancer.replacement(4), 2..3); // new
-        assert_eq!(enhancer.replacement(5), 3..4); // york
-        assert_eq!(enhancer.replacement(6), 4..5); // city
-    }
-
-    #[test]
-    fn end_query_growing() {
-        let query = ["NYC", "subway"];
-        //             0        1
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(1..2, 2, &["underground", "train"]);
-        //                    ^         2            3
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // NYC
-        assert_eq!(enhancer.replacement(1), 1..3); // subway
-        assert_eq!(enhancer.replacement(2), 1..2); // underground
-        assert_eq!(enhancer.replacement(3), 2..3); // train
-    }
-
-    #[test]
-    fn multiple_growings() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // subway = underground train
-        builder.declare(3..4, 7, &["underground", "train"]);
-        //                    ^          7           8
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0), 0..1); // great
-        assert_eq!(enhancer.replacement(1), 1..2); // awesome
-        assert_eq!(enhancer.replacement(2), 2..5); // NYC
-        assert_eq!(enhancer.replacement(3), 5..7); // subway
-        assert_eq!(enhancer.replacement(4), 2..3); // new
-        assert_eq!(enhancer.replacement(5), 3..4); // york
-        assert_eq!(enhancer.replacement(6), 4..5); // city
-        assert_eq!(enhancer.replacement(7), 5..6); // underground
-        assert_eq!(enhancer.replacement(8), 6..7); // train
-    }
-
-    #[test]
-    fn multiple_probable_growings() {
-        let query = ["great", "awesome", "NYC", "subway"];
-        //              0         1        2        3
-        let mut builder = QueryEnhancerBuilder::new(&query);
-
-        // NYC = new york city
-        builder.declare(2..3, 4, &["new", "york", "city"]);
-        //                    ^      4       5       6
-
-        // subway = underground train
-        builder.declare(3..4, 7, &["underground", "train"]);
-        //                    ^          7           8
-
-        // great awesome = good
-        builder.declare(0..2, 9, &["good"]);
-        //                    ^       9
-
-        // awesome NYC = NY
-        builder.declare(1..3, 10, &["NY"]);
-        //                    ^^     10
-
-        // NYC subway = metro
-        builder.declare(2..4, 11, &["metro"]);
-        //                    ^^      11
-
-        let enhancer = builder.build();
-
-        assert_eq!(enhancer.replacement(0),  0..1); // great
-        assert_eq!(enhancer.replacement(1),  1..2); // awesome
-        assert_eq!(enhancer.replacement(2),  2..5); // NYC
-        assert_eq!(enhancer.replacement(3),  5..7); // subway
-        assert_eq!(enhancer.replacement(4),  2..3); // new
-        assert_eq!(enhancer.replacement(5),  3..4); // york
-        assert_eq!(enhancer.replacement(6),  4..5); // city
-        assert_eq!(enhancer.replacement(7),  5..6); // underground
-        assert_eq!(enhancer.replacement(8),  6..7); // train
-        assert_eq!(enhancer.replacement(9),  0..2); // good
-        assert_eq!(enhancer.replacement(10), 1..5); // NY
-        assert_eq!(enhancer.replacement(11), 2..5); // metro
-    }
-}

meilisearch-core/src/query_tree.rs

@@ -0,0 +1,573 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::ops::Range;
+use std::time::Instant;
+use std::{cmp, fmt, iter::once};
+
+use fst::{IntoStreamer, Streamer};
+use itertools::{EitherOrBoth, merge_join_by};
+use log::debug;
+use meilisearch_tokenizer::analyzer::{Analyzer, AnalyzerConfig};
+use sdset::{Set, SetBuf, SetOperation};
+
+use crate::database::MainT;
+use crate::{store, DocumentId, DocIndex, MResult, FstSetCow};
+use crate::automaton::{build_dfa, build_prefix_dfa, build_exact_dfa};
+use crate::QueryWordsMapper;
+
+pub const MAX_QUERY_LEN: usize = 10;
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub enum Operation {
+    And(Vec<Operation>),
+    Or(Vec<Operation>),
+    Query(Query),
+}
+
+impl fmt::Debug for Operation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn pprint_tree(f: &mut fmt::Formatter<'_>, op: &Operation, depth: usize) -> fmt::Result {
+            match op {
+                Operation::And(children) => {
+                    writeln!(f, "{:1$}AND", "", depth * 2)?;
+                    children.iter().try_for_each(|c| pprint_tree(f, c, depth + 1))
+                },
+                Operation::Or(children) => {
+                    writeln!(f, "{:1$}OR", "", depth * 2)?;
+                    children.iter().try_for_each(|c| pprint_tree(f, c, depth + 1))
+                },
+                Operation::Query(query) => writeln!(f, "{:2$}{:?}", "", query, depth * 2),
+            }
+        }
+
+        pprint_tree(f, self, 0)
+    }
+}
+
+impl Operation {
+    fn tolerant(id: QueryId, prefix: bool, s: &str) -> Operation {
+        Operation::Query(Query { id, prefix, exact: true, kind: QueryKind::Tolerant(s.to_string()) })
+    }
+
+    fn non_tolerant(id: QueryId, prefix: bool, s: &str) -> Operation {
+        Operation::Query(Query { id, prefix, exact: true, kind: QueryKind::NonTolerant(s.to_string()) })
+    }
+
+    fn phrase2(id: QueryId, prefix: bool, (left, right): (&str, &str)) -> Operation {
+        let kind = QueryKind::Phrase(vec![left.to_owned(), right.to_owned()]);
+        Operation::Query(Query { id, prefix, exact: true, kind })
+    }
+}
+
+pub type QueryId = usize;
+
+#[derive(Clone, Eq)]
+pub struct Query {
+    pub id: QueryId,
+    pub prefix: bool,
+    pub exact: bool,
+    pub kind: QueryKind,
+}
+
+impl PartialEq for Query {
+    fn eq(&self, other: &Self) -> bool {
+        self.prefix == other.prefix && self.kind == other.kind
+    }
+}
+
+impl Hash for Query {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.prefix.hash(state);
+        self.kind.hash(state);
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub enum QueryKind {
+    Tolerant(String),
+    NonTolerant(String),
+    Phrase(Vec<String>),
+}
+
+impl fmt::Debug for Query {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Query { id, prefix, kind, .. } = self;
+        let prefix = if *prefix { String::from("Prefix") } else { String::default() };
+        match kind {
+            QueryKind::NonTolerant(word) => {
+                f.debug_struct(&(prefix + "NonTolerant")).field("id", &id).field("word", &word).finish()
+            },
+            QueryKind::Tolerant(word) => {
+                f.debug_struct(&(prefix + "Tolerant")).field("id", &id).field("word", &word).finish()
+            },
+            QueryKind::Phrase(words) => {
+                f.debug_struct(&(prefix + "Phrase")).field("id", &id).field("words", &words).finish()
+            },
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct PostingsList {
+    docids: SetBuf<DocumentId>,
+    matches: SetBuf<DocIndex>,
+}
+
+pub struct Context<'a> {
+    pub words_set: FstSetCow<'a>,
+    pub stop_words: FstSetCow<'a>,
+    pub synonyms: store::Synonyms,
+    pub postings_lists: store::PostingsLists,
+    pub prefix_postings_lists: store::PrefixPostingsListsCache,
+}
+
+fn split_best_frequency<'a>(reader: &heed::RoTxn<MainT>, ctx: &Context, word: &'a str) -> MResult<Option<(&'a str, &'a str)>> {
+    let chars = word.char_indices().skip(1);
+    let mut best = None;
+
+    for (i, _) in chars {
+        let (left, right) = word.split_at(i);
+
+        let left_freq = ctx.postings_lists
+            .postings_list(reader, left.as_bytes())?
+            .map(|p| p.docids.len())
+            .unwrap_or(0);
+        let right_freq = ctx.postings_lists
+            .postings_list(reader, right.as_bytes())?
+            .map(|p| p.docids.len())
+            .unwrap_or(0);
+
+        let min_freq = cmp::min(left_freq, right_freq);
+        if min_freq != 0 && best.map_or(true, |(old, _, _)| min_freq > old) {
+            best = Some((min_freq, left, right));
+        }
+    }
+
+    Ok(best.map(|(_, l, r)| (l, r)))
+}
+
+fn fetch_synonyms(reader: &heed::RoTxn<MainT>, ctx: &Context, words: &[&str]) -> MResult<Vec<Vec<String>>> {
+    let words = &words.join(" ");
+    let set = ctx.synonyms.synonyms_fst(reader, words.as_bytes())?;
+
+    let mut strings = Vec::new();
+    let mut stream = set.stream();
+    while let Some(input) = stream.next() {
+        if let Ok(input) = std::str::from_utf8(input) {
+            let alts = input.split_ascii_whitespace().map(ToOwned::to_owned).collect();
+            strings.push(alts);
+        }
+    }
+
+    Ok(strings)
+}
+
+fn create_operation<I, F>(iter: I, f: F) -> Operation
+where I: IntoIterator<Item=Operation>,
+      F: Fn(Vec<Operation>) -> Operation,
+{
+    let mut iter = iter.into_iter();
+    match (iter.next(), iter.next()) {
+        (Some(first), None) => first,
+        (first, second) => f(first.into_iter().chain(second).chain(iter).collect()),
+    }
+}
+
+const MAX_NGRAM: usize = 3;
+
+fn split_query_string<'a, A: AsRef<[u8]>>(s: &str, stop_words: &'a fst::Set<A>) -> Vec<(usize, String)> {
+    // TODO: Use global instance instead
+    Analyzer::new(AnalyzerConfig::default_with_stopwords(stop_words))
+        .analyze(s)
+        .tokens()
+        .filter(|t| t.is_word())
+        .map(|t| t.word.to_string())
+        .take(MAX_QUERY_LEN)
+        .enumerate()
+        .collect()
+}
+
+pub fn create_query_tree(
+    reader: &heed::RoTxn<MainT>,
+    ctx: &Context,
+    query: &str,
+) -> MResult<(Operation, HashMap<QueryId, Range<usize>>)>
+{
+    // TODO: use a shared analyzer instance
+    let words = split_query_string(query, &ctx.stop_words);
+
+    let mut mapper = QueryWordsMapper::new(words.iter().map(|(_, w)| w));
+
+    fn create_inner(
+        reader: &heed::RoTxn<MainT>,
+        ctx: &Context,
+        mapper: &mut QueryWordsMapper,
+        words: &[(usize, String)],
+    ) -> MResult<Vec<Operation>>
+    {
+        let mut alts = Vec::new();
+
+        for ngram in 1..=MAX_NGRAM {
+            if let Some(group) = words.get(..ngram) {
+                let mut group_ops = Vec::new();
+
+                let tail = &words[ngram..];
+                let is_last = tail.is_empty();
+
+                let mut group_alts = Vec::new();
+                match group {
+                    [(id, word)] => {
+                        let mut idgen = ((id + 1) * 100)..;
+                        let range = (*id)..id+1;
+
+                        let phrase = split_best_frequency(reader, ctx, word)?
+                            .map(|ws| {
+                                let id = idgen.next().unwrap();
+                                idgen.next().unwrap();
+                                mapper.declare(range.clone(), id, &[ws.0, ws.1]);
+                                Operation::phrase2(id, is_last, ws)
+                            });
+
+                        let synonyms = fetch_synonyms(reader, ctx, &[word])?
+                            .into_iter()
+                            .map(|alts| {
+                                let exact = alts.len() == 1;
+                                let id = idgen.next().unwrap();
+                                mapper.declare(range.clone(), id, &alts);
+
+                                let mut idgen = once(id).chain(&mut idgen);
+                                let iter = alts.into_iter().map(|w| {
+                                    let id = idgen.next().unwrap();
+                                    let kind = QueryKind::NonTolerant(w);
+                                    Operation::Query(Query { id, prefix: false, exact, kind })
+                                });
+
+                                create_operation(iter, Operation::And)
+                            });
+
+                        let original = Operation::tolerant(*id, is_last, word);
+
+                        group_alts.push(original);
+                        group_alts.extend(synonyms.chain(phrase));
+                    },
+                    words => {
+                        let id = words[0].0;
+                        let mut idgen = ((id + 1) * 100_usize.pow(ngram as u32))..;
+                        let range = id..id+ngram;
+
+                        let words: Vec<_> = words.iter().map(|(_, s)| s.as_str()).collect();
+
+                        for synonym in fetch_synonyms(reader, ctx, &words)? {
+                            let exact = synonym.len() == 1;
+                            let id = idgen.next().unwrap();
+                            mapper.declare(range.clone(), id, &synonym);
+
+                            let mut idgen = once(id).chain(&mut idgen);
+                            let synonym = synonym.into_iter().map(|s| {
+                                let id = idgen.next().unwrap();
+                                let kind = QueryKind::NonTolerant(s);
+                                Operation::Query(Query { id, prefix: false, exact, kind })
+                            });
+                            group_alts.push(create_operation(synonym, Operation::And));
+                        }
+
+                        let id = idgen.next().unwrap();
+                        let concat = words.concat();
+                        mapper.declare(range.clone(), id, &[&concat]);
+                        group_alts.push(Operation::non_tolerant(id, is_last, &concat));
+                    }
+                }
+
+                group_ops.push(create_operation(group_alts, Operation::Or));
+
+                if !tail.is_empty() {
+                    let tail_ops = create_inner(reader, ctx, mapper, tail)?;
+                    group_ops.push(create_operation(tail_ops, Operation::Or));
+                }
+
+                alts.push(create_operation(group_ops, Operation::And));
+            }
+        }
+
+        Ok(alts)
+    }
+
+    let alternatives = create_inner(reader, ctx, &mut mapper, &words)?;
+    let operation = Operation::Or(alternatives);
+    let mapping = mapper.mapping();
+
+    Ok((operation, mapping))
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PostingsKey<'o> {
+    pub query: &'o Query,
+    pub input: Vec<u8>,
+    pub distance: u8,
+    pub is_exact: bool,
+}
+
+pub type Postings<'o, 'txn> = HashMap<PostingsKey<'o>, Cow<'txn, Set<DocIndex>>>;
+pub type Cache<'o, 'txn> = HashMap<&'o Operation, Cow<'txn, Set<DocumentId>>>;
+
+pub struct QueryResult<'o, 'txn> {
+    pub docids: Cow<'txn, Set<DocumentId>>,
+    pub queries: Postings<'o, 'txn>,
+}
+
+pub fn traverse_query_tree<'o, 'txn>(
+    reader: &'txn heed::RoTxn<MainT>,
+    ctx: &Context,
+    tree: &'o Operation,
+) -> MResult<QueryResult<'o, 'txn>>
+{
+    fn execute_and<'o, 'txn>(
+        reader: &'txn heed::RoTxn<MainT>,
+        ctx: &Context,
+        cache: &mut Cache<'o, 'txn>,
+        postings: &mut Postings<'o, 'txn>,
+        depth: usize,
+        operations: &'o [Operation],
+    ) -> MResult<Cow<'txn, Set<DocumentId>>>
+    {
+        debug!("{:1$}AND", "", depth * 2);
+
+        let before = Instant::now();
+        let mut results = Vec::new();
+
+        for op in operations {
+            if cache.get(op).is_none() {
+                let docids = match op {
+                    Operation::And(ops) => execute_and(reader, ctx, cache, postings, depth + 1, &ops)?,
+                    Operation::Or(ops) => execute_or(reader, ctx, cache, postings, depth + 1, &ops)?,
+                    Operation::Query(query) => execute_query(reader, ctx, postings, depth + 1, &query)?,
+                };
+                cache.insert(op, docids);
+            }
+        }
+
+        for op in operations {
+            if let Some(docids) = cache.get(op) {
+                results.push(docids.as_ref());
+            }
+        }
+
+        let op = sdset::multi::Intersection::new(results);
+        let docids = op.into_set_buf();
+
+        debug!("{:3$}--- AND fetched {} documents in {:.02?}", "", docids.len(), before.elapsed(), depth * 2);
+
+        Ok(Cow::Owned(docids))
+    }
+
+    fn execute_or<'o, 'txn>(
+        reader: &'txn heed::RoTxn<MainT>,
+        ctx: &Context,
+        cache: &mut Cache<'o, 'txn>,
+        postings: &mut Postings<'o, 'txn>,
+        depth: usize,
+        operations: &'o [Operation],
+    ) -> MResult<Cow<'txn, Set<DocumentId>>>
+    {
+        debug!("{:1$}OR", "", depth * 2);
+
+        let before = Instant::now();
+        let mut results = Vec::new();
+
+        for op in operations {
+            if cache.get(op).is_none() {
+                let docids = match op {
+                    Operation::And(ops) => execute_and(reader, ctx, cache, postings, depth + 1, &ops)?,
+                    Operation::Or(ops) => execute_or(reader, ctx, cache, postings, depth + 1, &ops)?,
+                    Operation::Query(query) => execute_query(reader, ctx, postings, depth + 1, &query)?,
+                };
+                cache.insert(op, docids);
+            }
+        }
+
+        for op in operations {
+            if let Some(docids) = cache.get(op) {
+                results.push(docids.as_ref());
+            }
+        }
+
+        let op = sdset::multi::Union::new(results);
+        let docids = op.into_set_buf();
+
+        debug!("{:3$}--- OR fetched {} documents in {:.02?}", "", docids.len(), before.elapsed(), depth * 2);
+
+        Ok(Cow::Owned(docids))
+    }
+
+    fn execute_query<'o, 'txn>(
+        reader: &'txn heed::RoTxn<MainT>,
+        ctx: &Context,
+        postings: &mut Postings<'o, 'txn>,
+        depth: usize,
+        query: &'o Query,
+    ) -> MResult<Cow<'txn, Set<DocumentId>>>
+    {
+        let before = Instant::now();
+
+        let Query { prefix, kind, exact, .. } = query;
+        let docids: Cow<Set<_>> = match kind {
+            QueryKind::Tolerant(word) => {
+                if *prefix && word.len() <= 2 {
+                    let prefix = {
+                        let mut array = [0; 4];
+                        let bytes = word.as_bytes();
+                        array[..bytes.len()].copy_from_slice(bytes);
+                        array
+                    };
+
+                    // We retrieve the cached postings lists for all
+                    // the words that starts with this short prefix.
+                    let result = ctx.prefix_postings_lists.prefix_postings_list(reader, prefix)?.unwrap_or_default();
+                    let key = PostingsKey { query, input: word.clone().into_bytes(), distance: 0, is_exact: false };
+                    postings.insert(key, result.matches);
+                    let prefix_docids = &result.docids;
+
+                    // We retrieve the exact postings list for the prefix,
+                    // because we must consider these matches as exact.
+                    let result = ctx.postings_lists.postings_list(reader, word.as_bytes())?.unwrap_or_default();
+                    let key = PostingsKey { query, input: word.clone().into_bytes(), distance: 0, is_exact: true };
+                    postings.insert(key, result.matches);
+                    let exact_docids = &result.docids;
+
+                    let before = Instant::now();
+                    let docids = sdset::duo::Union::new(prefix_docids, exact_docids).into_set_buf();
+                    debug!("{:4$}prefix docids ({} and {}) construction took {:.02?}",
+                        "", prefix_docids.len(), exact_docids.len(), before.elapsed(), depth * 2);
+
+                    Cow::Owned(docids)
+
+                } else {
+                    let dfa = if *prefix { build_prefix_dfa(word) } else { build_dfa(word) };
+
+                    let byte = word.as_bytes()[0];
+                    let mut stream = if byte == u8::max_value() {
+                        ctx.words_set.search(&dfa).ge(&[byte]).into_stream()
+                    } else {
+                        ctx.words_set.search(&dfa).ge(&[byte]).lt(&[byte + 1]).into_stream()
+                    };
+
+                    let before = Instant::now();
+                    let mut results = Vec::new();
+                    while let Some(input) = stream.next() {
+                        if let Some(result) = ctx.postings_lists.postings_list(reader, input)? {
+                            let distance = dfa.eval(input).to_u8();
+                            let is_exact = *exact && distance == 0 && input.len() == word.len();
+                            results.push(result.docids);
+                            let key = PostingsKey { query, input: input.to_owned(), distance, is_exact };
+                            postings.insert(key, result.matches);
+                        }
+                    }
+                    debug!("{:3$}docids retrieval ({:?}) took {:.02?}", "", results.len(), before.elapsed(), depth * 2);
+
+                    let before = Instant::now();
+                    let docids = if results.len() > 10 {
+                        let cap = results.iter().map(|dis| dis.len()).sum();
+                        let mut docids = Vec::with_capacity(cap);
+                        for dis in results {
+                            docids.extend_from_slice(&dis);
+                        }
+                        SetBuf::from_dirty(docids)
+                    } else {
+                        let sets = results.iter().map(AsRef::as_ref).collect();
+                        sdset::multi::Union::new(sets).into_set_buf()
+                    };
+                    debug!("{:2$}docids construction took {:.02?}", "", before.elapsed(), depth * 2);
+
+                    Cow::Owned(docids)
+                }
+            },
+            QueryKind::NonTolerant(word) => {
+                // TODO support prefix and non-prefix exact DFA
+                let dfa = build_exact_dfa(word);
+
+                let byte = word.as_bytes()[0];
+                let mut stream = if byte == u8::max_value() {
+                    ctx.words_set.search(&dfa).ge(&[byte]).into_stream()
+                } else {
+                    ctx.words_set.search(&dfa).ge(&[byte]).lt(&[byte + 1]).into_stream()
+                };
+
+                let before = Instant::now();
+                let mut results = Vec::new();
+                while let Some(input) = stream.next() {
+                    if let Some(result) = ctx.postings_lists.postings_list(reader, input)? {
+                        let distance = dfa.eval(input).to_u8();
+                        results.push(result.docids);
+                        let key = PostingsKey { query, input: input.to_owned(), distance, is_exact: *exact };
+                        postings.insert(key, result.matches);
+                    }
+                }
+                debug!("{:3$}docids retrieval ({:?}) took {:.02?}", "", results.len(), before.elapsed(), depth * 2);
+
+                let before = Instant::now();
+                let docids = if results.len() > 10 {
+                    let cap = results.iter().map(|dis| dis.len()).sum();
+                    let mut docids = Vec::with_capacity(cap);
+                    for dis in results {
+                        docids.extend_from_slice(&dis);
+                    }
+                    SetBuf::from_dirty(docids)
+                } else {
+                    let sets = results.iter().map(AsRef::as_ref).collect();
+                    sdset::multi::Union::new(sets).into_set_buf()
+                };
+                debug!("{:2$}docids construction took {:.02?}", "", before.elapsed(), depth * 2);
+
+                Cow::Owned(docids)
+            },
+            QueryKind::Phrase(words) => {
+                // TODO support prefix and non-prefix exact DFA
+                if let [first, second] = words.as_slice() {
+                    let first = ctx.postings_lists.postings_list(reader, first.as_bytes())?.unwrap_or_default();
+                    let second = ctx.postings_lists.postings_list(reader, second.as_bytes())?.unwrap_or_default();
+
+                    let iter = merge_join_by(first.matches.as_slice(), second.matches.as_slice(), |a, b| {
+                        let x = (a.document_id, a.attribute, (a.word_index as u32) + 1);
+                        let y = (b.document_id, b.attribute, b.word_index as u32);
+                        x.cmp(&y)
+                    });
+
+                    let matches: Vec<_> = iter
+                        .filter_map(EitherOrBoth::both)
+                        .flat_map(|(a, b)| once(*a).chain(Some(*b)))
+                        .collect();
+
+                    let before = Instant::now();
+                    let mut docids: Vec<_> = matches.iter().map(|m| m.document_id).collect();
+                    docids.dedup();
+                    let docids = SetBuf::new(docids).unwrap();
+                    debug!("{:2$}docids construction took {:.02?}", "", before.elapsed(), depth * 2);
+
+                    let matches = Cow::Owned(SetBuf::from_dirty(matches));
+                    let key = PostingsKey { query, input: vec![], distance: 0, is_exact: true };
+                    postings.insert(key, matches);
+
+                    Cow::Owned(docids)
+                } else {
+                    debug!("{:2$}{:?} skipped", "", words, depth * 2);
+                    Cow::default()
+                }
+            },
+        };
+
+        debug!("{:4$}{:?} fetched {:?} documents in {:.02?}", "", query, docids.len(), before.elapsed(), depth * 2);
+        Ok(docids)
+    }
+
+    let mut cache = Cache::new();
+    let mut postings = Postings::new();
+
+    let docids = match tree {
+        Operation::And(ops) => execute_and(reader, ctx, &mut cache, &mut postings, 0, &ops)?,
+        Operation::Or(ops) => execute_or(reader, ctx, &mut cache, &mut postings, 0, &ops)?,
+        Operation::Query(query) => execute_query(reader, ctx, &mut postings, 0, &query)?,
+    };
+
+    Ok(QueryResult { docids, queries: postings })
+}

meilisearch-core/src/query_words_mapper.rs

@@ -0,0 +1,416 @@
+use std::collections::HashMap;
+use std::iter::FromIterator;
+use std::ops::Range;
+use intervaltree::{Element, IntervalTree};
+
+pub type QueryId = usize;
+
+pub struct QueryWordsMapper {
+    originals: Vec<String>,
+    mappings: HashMap<QueryId, (Range<usize>, Vec<String>)>,
+}
+
+impl QueryWordsMapper {
+    pub fn new<I, A>(originals: I) -> QueryWordsMapper
+    where I: IntoIterator<Item = A>,
+          A: ToString,
+    {
+        let originals = originals.into_iter().map(|s| s.to_string()).collect();
+        QueryWordsMapper { originals, mappings: HashMap::new() }
+    }
+
+    #[allow(clippy::len_zero)]
+    pub fn declare<I, A>(&mut self, range: Range<usize>, id: QueryId, replacement: I)
+    where I: IntoIterator<Item = A>,
+          A: ToString,
+    {
+        assert!(range.len() != 0);
+        assert!(self.originals.get(range.clone()).is_some());
+        assert!(id >= self.originals.len());
+
+        let replacement: Vec<_> = replacement.into_iter().map(|s| s.to_string()).collect();
+
+        assert!(!replacement.is_empty());
+
+        // We detect words at the end and at the front of the
+        // replacement that are common with the originals:
+        //
+        //     x a b c d e f g
+        //       ^^^/   \^^^
+        //     a b x c d k j e f
+        //     ^^^           ^^^
+        //
+
+        let left = &self.originals[..range.start];
+        let right = &self.originals[range.end..];
+
+        let common_left = longest_common_prefix(left, &replacement);
+        let common_right = longest_common_prefix(&replacement, right);
+
+        for i in 0..common_left {
+            let range = range.start - common_left + i..range.start - common_left + i + 1;
+            let replacement = vec![replacement[i].clone()];
+            self.mappings.insert(id + i, (range, replacement));
+        }
+
+        {
+            let replacement = replacement[common_left..replacement.len() - common_right].to_vec();
+            self.mappings.insert(id + common_left, (range.clone(), replacement));
+        }
+
+        for i in 0..common_right {
+            let id = id + replacement.len() - common_right + i;
+            let range = range.end + i..range.end + i + 1;
+            let replacement = vec![replacement[replacement.len() - common_right + i].clone()];
+            self.mappings.insert(id, (range, replacement));
+        }
+    }
+
+    pub fn mapping(self) -> HashMap<QueryId, Range<usize>> {
+        let mappings = self.mappings.into_iter().map(|(i, (r, v))| (r, (i, v)));
+        let intervals = IntervalTree::from_iter(mappings);
+
+        let mut output = HashMap::new();
+        let mut offset = 0;
+
+        // We map each original word to the biggest number of
+        // associated words.
+        for i in 0..self.originals.len() {
+            let max = intervals.query_point(i)
+                .filter_map(|e| {
+                    if e.range.end - 1 == i {
+                        let len = e.value.1.iter().skip(i - e.range.start).count();
+                        if len != 0 { Some(len) } else { None }
+                    } else { None }
+                })
+                .max()
+                .unwrap_or(1);
+
+            let range = i + offset..i + offset + max;
+            output.insert(i, range);
+            offset += max - 1;
+        }
+
+        // We retrieve the range that each original word
+        // is mapped to and apply it to each of the words.
+        for i in 0..self.originals.len() {
+
+            let iter = intervals.query_point(i).filter(|e| e.range.end - 1 == i);
+            for Element { range, value: (id, words) } in iter {
+
+                // We ask for the complete range mapped to the area we map.
+                let start = output.get(&range.start).map(|r| r.start).unwrap_or(range.start);
+                let end = output.get(&(range.end - 1)).map(|r| r.end).unwrap_or(range.end);
+                let range = start..end;
+
+                // We map each query id to one word until the last,
+                // we map it to the remainings words.
+                let add = range.len() - words.len();
+                for (j, x) in range.take(words.len()).enumerate() {
+                    let add = if j == words.len() - 1 { add } else { 0 }; // is last?
+                    let range = x..x + 1 + add;
+                    output.insert(id + j, range);
+                }
+            }
+        }
+
+        output
+    }
+}
+
+fn longest_common_prefix<T: Eq + std::fmt::Debug>(a: &[T], b: &[T]) -> usize {
+    let mut best = None;
+    for i in (0..a.len()).rev() {
+        let count = a[i..].iter().zip(b).take_while(|(a, b)| a == b).count();
+        best = match best {
+            Some(old) if count > old => Some(count),
+            Some(_) => break,
+            None => Some(count),
+        };
+    }
+    best.unwrap_or(0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn original_unmodified() {
+        let query = ["new", "york", "city", "subway"];
+        //             0       1       2        3
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // new york = new york city
+        builder.declare(0..2, 4, &["new", "york", "city"]);
+        //                    ^      4       5       6
+
+        // new = new york city
+        builder.declare(0..1, 7, &["new", "york", "city"]);
+        //                    ^      7       8       9
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // new
+        assert_eq!(mapping[&1], 1..2); // york
+        assert_eq!(mapping[&2], 2..3); // city
+        assert_eq!(mapping[&3], 3..4); // subway
+
+        assert_eq!(mapping[&4], 0..1); // new
+        assert_eq!(mapping[&5], 1..2); // york
+        assert_eq!(mapping[&6], 2..3); // city
+
+        assert_eq!(mapping[&7], 0..1); // new
+        assert_eq!(mapping[&8], 1..2); // york
+        assert_eq!(mapping[&9], 2..3); // city
+    }
+
+    #[test]
+    fn original_unmodified2() {
+        let query = ["new", "york", "city", "subway"];
+        //             0       1       2        3
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // city subway = new york city underground train
+        builder.declare(2..4, 4, &["new", "york", "city", "underground", "train"]);
+        //                    ^      4      5       6           7           8
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // new
+        assert_eq!(mapping[&1], 1..2); // york
+        assert_eq!(mapping[&2], 2..3); // city
+        assert_eq!(mapping[&3], 3..5); // subway
+
+        assert_eq!(mapping[&4], 0..1); // new
+        assert_eq!(mapping[&5], 1..2); // york
+        assert_eq!(mapping[&6], 2..3); // city
+        assert_eq!(mapping[&7], 3..4); // underground
+        assert_eq!(mapping[&8], 4..5); // train
+    }
+
+    #[test]
+    fn original_unmodified3() {
+        let query = ["a", "b", "x", "x", "a", "b", "c", "d", "e", "f", "g"];
+        //            0    1    2    3    4    5    6    7    8    9    10
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // c d = a b x c d k j e f
+        builder.declare(6..8, 11, &["a", "b", "x", "c", "d", "k", "j", "e", "f"]);
+        //                    ^^    11   12   13   14   15   16   17   18   19
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0],  0..1); // a
+        assert_eq!(mapping[&1],  1..2); // b
+        assert_eq!(mapping[&2],  2..3); // x
+        assert_eq!(mapping[&3],  3..4); // x
+        assert_eq!(mapping[&4],  4..5); // a
+        assert_eq!(mapping[&5],  5..6); // b
+        assert_eq!(mapping[&6],  6..7); // c
+        assert_eq!(mapping[&7],  7..11); // d
+        assert_eq!(mapping[&8],  11..12); // e
+        assert_eq!(mapping[&9],  12..13); // f
+        assert_eq!(mapping[&10], 13..14); // g
+
+        assert_eq!(mapping[&11], 4..5); // a
+        assert_eq!(mapping[&12], 5..6); // b
+        assert_eq!(mapping[&13], 6..7); // x
+        assert_eq!(mapping[&14], 7..8); // c
+        assert_eq!(mapping[&15], 8..9); // d
+        assert_eq!(mapping[&16], 9..10); // k
+        assert_eq!(mapping[&17], 10..11); // j
+        assert_eq!(mapping[&18], 11..12); // e
+        assert_eq!(mapping[&19], 12..13); // f
+    }
+
+    #[test]
+    fn simple_growing() {
+        let query = ["new", "york", "subway"];
+        //             0       1        2
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // new york = new york city
+        builder.declare(0..2, 3, &["new", "york", "city"]);
+        //                    ^      3       4       5
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // new
+        assert_eq!(mapping[&1], 1..3); // york
+        assert_eq!(mapping[&2], 3..4); // subway
+        assert_eq!(mapping[&3], 0..1); // new
+        assert_eq!(mapping[&4], 1..2); // york
+        assert_eq!(mapping[&5], 2..3); // city
+    }
+
+    #[test]
+    fn same_place_growings() {
+        let query = ["NY", "subway"];
+        //             0       1
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NY = new york
+        builder.declare(0..1, 2, &["new", "york"]);
+        //                    ^      2       3
+
+        // NY = new york city
+        builder.declare(0..1, 4, &["new", "york", "city"]);
+        //                    ^      4       5       6
+
+        // NY = NYC
+        builder.declare(0..1, 7, &["NYC"]);
+        //                    ^      7
+
+        // NY = new york city
+        builder.declare(0..1, 8, &["new", "york", "city"]);
+        //                    ^      8       9      10
+
+        // subway = underground train
+        builder.declare(1..2, 11, &["underground", "train"]);
+        //                    ^          11          12
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..3); // NY
+        assert_eq!(mapping[&1], 3..5); // subway
+        assert_eq!(mapping[&2], 0..1); // new
+        assert_eq!(mapping[&3], 1..3); // york
+        assert_eq!(mapping[&4], 0..1); // new
+        assert_eq!(mapping[&5], 1..2); // york
+        assert_eq!(mapping[&6], 2..3); // city
+        assert_eq!(mapping[&7], 0..3); // NYC
+        assert_eq!(mapping[&8], 0..1); // new
+        assert_eq!(mapping[&9], 1..2); // york
+        assert_eq!(mapping[&10], 2..3); // city
+        assert_eq!(mapping[&11], 3..4); // underground
+        assert_eq!(mapping[&12], 4..5); // train
+    }
+
+    #[test]
+    fn bigger_growing() {
+        let query = ["NYC", "subway"];
+        //             0        1
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NYC = new york city
+        builder.declare(0..1, 2, &["new", "york", "city"]);
+        //                    ^      2       3       4
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..3); // NYC
+        assert_eq!(mapping[&1], 3..4); // subway
+        assert_eq!(mapping[&2], 0..1); // new
+        assert_eq!(mapping[&3], 1..2); // york
+        assert_eq!(mapping[&4], 2..3); // city
+    }
+
+    #[test]
+    fn middle_query_growing() {
+        let query = ["great", "awesome", "NYC", "subway"];
+        //              0         1        2        3
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NYC = new york city
+        builder.declare(2..3, 4, &["new", "york", "city"]);
+        //                    ^      4       5       6
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // great
+        assert_eq!(mapping[&1], 1..2); // awesome
+        assert_eq!(mapping[&2], 2..5); // NYC
+        assert_eq!(mapping[&3], 5..6); // subway
+        assert_eq!(mapping[&4], 2..3); // new
+        assert_eq!(mapping[&5], 3..4); // york
+        assert_eq!(mapping[&6], 4..5); // city
+    }
+
+    #[test]
+    fn end_query_growing() {
+        let query = ["NYC", "subway"];
+        //             0        1
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NYC = new york city
+        builder.declare(1..2, 2, &["underground", "train"]);
+        //                    ^         2            3
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // NYC
+        assert_eq!(mapping[&1], 1..3); // subway
+        assert_eq!(mapping[&2], 1..2); // underground
+        assert_eq!(mapping[&3], 2..3); // train
+    }
+
+    #[test]
+    fn multiple_growings() {
+        let query = ["great", "awesome", "NYC", "subway"];
+        //              0         1        2        3
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NYC = new york city
+        builder.declare(2..3, 4, &["new", "york", "city"]);
+        //                    ^      4       5       6
+
+        // subway = underground train
+        builder.declare(3..4, 7, &["underground", "train"]);
+        //                    ^          7           8
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // great
+        assert_eq!(mapping[&1], 1..2); // awesome
+        assert_eq!(mapping[&2], 2..5); // NYC
+        assert_eq!(mapping[&3], 5..7); // subway
+        assert_eq!(mapping[&4], 2..3); // new
+        assert_eq!(mapping[&5], 3..4); // york
+        assert_eq!(mapping[&6], 4..5); // city
+        assert_eq!(mapping[&7], 5..6); // underground
+        assert_eq!(mapping[&8], 6..7); // train
+    }
+
+    #[test]
+    fn multiple_probable_growings() {
+        let query = ["great", "awesome", "NYC", "subway"];
+        //              0         1        2        3
+        let mut builder = QueryWordsMapper::new(&query);
+
+        // NYC = new york city
+        builder.declare(2..3, 4, &["new", "york", "city"]);
+        //                    ^      4       5       6
+
+        // subway = underground train
+        builder.declare(3..4, 7, &["underground", "train"]);
+        //                    ^          7           8
+
+        // great awesome = good
+        builder.declare(0..2, 9, &["good"]);
+        //                    ^       9
+
+        // awesome NYC = NY
+        builder.declare(1..3, 10, &["NY"]);
+        //                    ^^     10
+
+        // NYC subway = metro
+        builder.declare(2..4, 11, &["metro"]);
+        //                    ^^      11
+
+        let mapping = builder.mapping();
+
+        assert_eq!(mapping[&0], 0..1); // great
+        assert_eq!(mapping[&1], 1..2); // awesome
+        assert_eq!(mapping[&2], 2..5); // NYC
+        assert_eq!(mapping[&3], 5..7); // subway
+        assert_eq!(mapping[&4], 2..3); // new
+        assert_eq!(mapping[&5], 3..4); // york
+        assert_eq!(mapping[&6], 4..5); // city
+        assert_eq!(mapping[&7], 5..6); // underground
+        assert_eq!(mapping[&8], 6..7); // train
+        assert_eq!(mapping[&9], 0..2); // good
+        assert_eq!(mapping[&10], 1..5); // NY
+        assert_eq!(mapping[&11], 2..7); // metro
+    }
+}

meilisearch-core/src/ranked_map.rs

@@ -1,14 +1,14 @@
 use std::io::{Read, Write};
 
 use hashbrown::HashMap;
-use meilisearch_schema::SchemaAttr;
+use meilisearch_schema::FieldId;
 use serde::{Deserialize, Serialize};
 
 use crate::{DocumentId, Number};
 
 #[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct RankedMap(HashMap<(DocumentId, SchemaAttr), Number>);
+pub struct RankedMap(HashMap<(DocumentId, FieldId), Number>);
 
 impl RankedMap {
     pub fn len(&self) -> usize {
@@ -19,16 +19,16 @@ impl RankedMap {
         self.0.is_empty()
     }
 
-    pub fn insert(&mut self, document: DocumentId, attribute: SchemaAttr, number: Number) {
-        self.0.insert((document, attribute), number);
+    pub fn insert(&mut self, document: DocumentId, field: FieldId, number: Number) {
+        self.0.insert((document, field), number);
     }
 
-    pub fn remove(&mut self, document: DocumentId, attribute: SchemaAttr) {
-        self.0.remove(&(document, attribute));
+    pub fn remove(&mut self, document: DocumentId, field: FieldId) {
+        self.0.remove(&(document, field));
     }
 
-    pub fn get(&self, document: DocumentId, attribute: SchemaAttr) -> Option<Number> {
-        self.0.get(&(document, attribute)).cloned()
+    pub fn get(&self, document: DocumentId, field: FieldId) -> Option<Number> {
+        self.0.get(&(document, field)).cloned()
     }
 
     pub fn read_from_bin<R: Read>(reader: R) -> bincode::Result<RankedMap> {

meilisearch-core/src/raw_document.rs

@@ -1,186 +1,51 @@
-use std::fmt;
-use std::sync::Arc;
-
-use meilisearch_schema::SchemaAttr;
+use compact_arena::SmallArena;
 use sdset::SetBuf;
-use slice_group_by::GroupBy;
+use crate::DocIndex;
+use crate::bucket_sort::{SimpleMatch, BareMatch, PostingsListView};
+use crate::reordered_attrs::ReorderedAttrs;
 
-use crate::{DocumentId, Highlight, TmpMatch};
-
-#[derive(Clone)]
-pub struct RawDocument {
-    pub id: DocumentId,
-    pub matches: SharedMatches,
-    pub highlights: Vec<Highlight>,
-    pub fields_counts: SetBuf<(SchemaAttr, u64)>,
+pub struct RawDocument<'a, 'tag> {
+    pub id: crate::DocumentId,
+    pub bare_matches: &'a mut [BareMatch<'tag>],
+    pub processed_matches: Vec<SimpleMatch>,
+    /// The list of minimum `distance` found
+    pub processed_distances: Vec<Option<u8>>,
+    /// Does this document contains a field
+    /// with one word that is exactly matching
+    pub contains_one_word_field: bool,
 }
 
-impl RawDocument {
-    pub fn query_index(&self) -> &[u32] {
-        let r = self.matches.range;
-        // it is safe because construction/modifications
-        // can only be done in this module
-        unsafe {
-            &self
-                .matches
-                .matches
-                .query_index
-                .get_unchecked(r.start..r.end)
-        }
-    }
+impl<'a, 'tag> RawDocument<'a, 'tag> {
+    pub fn new<'txn>(
+        bare_matches: &'a mut [BareMatch<'tag>],
+        postings_lists: &mut SmallArena<'tag, PostingsListView<'txn>>,
+        searchable_attrs: Option<&ReorderedAttrs>,
+    ) -> RawDocument<'a, 'tag>
+    {
+        if let Some(reordered_attrs) = searchable_attrs {
+            for bm in bare_matches.iter() {
+                let postings_list = &postings_lists[bm.postings_list];
 
-    pub fn distance(&self) -> &[u8] {
-        let r = self.matches.range;
-        // it is safe because construction/modifications
-        // can only be done in this module
-        unsafe { &self.matches.matches.distance.get_unchecked(r.start..r.end) }
-    }
+                let mut rewritten = Vec::new();
+                for di in postings_list.iter() {
+                    if let Some(attribute) = reordered_attrs.get(di.attribute) {
+                        rewritten.push(DocIndex { attribute, ..*di });
+                    }
+                }
 
-    pub fn attribute(&self) -> &[u16] {
-        let r = self.matches.range;
-        // it is safe because construction/modifications
-        // can only be done in this module
-        unsafe { &self.matches.matches.attribute.get_unchecked(r.start..r.end) }
-    }
-
-    pub fn word_index(&self) -> &[u16] {
-        let r = self.matches.range;
-        // it is safe because construction/modifications
-        // can only be done in this module
-        unsafe {
-            &self
-                .matches
-                .matches
-                .word_index
-                .get_unchecked(r.start..r.end)
-        }
-    }
-
-    pub fn is_exact(&self) -> &[bool] {
-        let r = self.matches.range;
-        // it is safe because construction/modifications
-        // can only be done in this module
-        unsafe { &self.matches.matches.is_exact.get_unchecked(r.start..r.end) }
-    }
-}
-
-impl fmt::Debug for RawDocument {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("RawDocument {\r\n")?;
-        f.write_fmt(format_args!("{:>15}: {:?},\r\n", "id", self.id))?;
-        f.write_fmt(format_args!(
-            "{:>15}: {:^5?},\r\n",
-            "query_index",
-            self.query_index()
-        ))?;
-        f.write_fmt(format_args!(
-            "{:>15}: {:^5?},\r\n",
-            "distance",
-            self.distance()
-        ))?;
-        f.write_fmt(format_args!(
-            "{:>15}: {:^5?},\r\n",
-            "attribute",
-            self.attribute()
-        ))?;
-        f.write_fmt(format_args!(
-            "{:>15}: {:^5?},\r\n",
-            "word_index",
-            self.word_index()
-        ))?;
-        f.write_fmt(format_args!(
-            "{:>15}: {:^5?},\r\n",
-            "is_exact",
-            self.is_exact()
-        ))?;
-        f.write_str("}")?;
-        Ok(())
-    }
-}
-
-pub fn raw_documents_from(
-    matches: SetBuf<(DocumentId, TmpMatch)>,
-    highlights: SetBuf<(DocumentId, Highlight)>,
-    fields_counts: SetBuf<(DocumentId, SchemaAttr, u64)>,
-) -> Vec<RawDocument> {
-    let mut docs_ranges: Vec<(_, Range, _, _)> = Vec::new();
-    let mut matches2 = Matches::with_capacity(matches.len());
-
-    let matches = matches.linear_group_by_key(|(id, _)| *id);
-    let highlights = highlights.linear_group_by_key(|(id, _)| *id);
-    let fields_counts = fields_counts.linear_group_by_key(|(id, _, _)| *id);
-
-    for ((mgroup, hgroup), fgroup) in matches.zip(highlights).zip(fields_counts) {
-        debug_assert_eq!(mgroup[0].0, hgroup[0].0);
-        debug_assert_eq!(mgroup[0].0, fgroup[0].0);
-
-        let document_id = mgroup[0].0;
-        let start = docs_ranges.last().map(|(_, r, _, _)| r.end).unwrap_or(0);
-        let end = start + mgroup.len();
-        let highlights = hgroup.iter().map(|(_, h)| *h).collect();
-        let fields_counts = SetBuf::new(fgroup.iter().map(|(_, a, c)| (*a, *c)).collect()).unwrap();
-
-        docs_ranges.push((document_id, Range { start, end }, highlights, fields_counts));
-        matches2.extend_from_slice(mgroup);
-    }
-
-    let matches = Arc::new(matches2);
-    docs_ranges
-        .into_iter()
-        .map(|(id, range, highlights, fields_counts)| {
-            let matches = SharedMatches {
-                range,
-                matches: matches.clone(),
-            };
-            RawDocument {
-                id,
-                matches,
-                highlights,
-                fields_counts,
+                let new_postings = SetBuf::from_dirty(rewritten);
+                postings_lists[bm.postings_list].rewrite_with(new_postings);
             }
-        })
-        .collect()
-}
-
-#[derive(Debug, Copy, Clone)]
-struct Range {
-    start: usize,
-    end: usize,
-}
-
-#[derive(Clone)]
-pub struct SharedMatches {
-    range: Range,
-    matches: Arc<Matches>,
-}
-
-#[derive(Clone)]
-struct Matches {
-    query_index: Vec<u32>,
-    distance: Vec<u8>,
-    attribute: Vec<u16>,
-    word_index: Vec<u16>,
-    is_exact: Vec<bool>,
-}
-
-impl Matches {
-    fn with_capacity(cap: usize) -> Matches {
-        Matches {
-            query_index: Vec::with_capacity(cap),
-            distance: Vec::with_capacity(cap),
-            attribute: Vec::with_capacity(cap),
-            word_index: Vec::with_capacity(cap),
-            is_exact: Vec::with_capacity(cap),
         }
-    }
 
-    fn extend_from_slice(&mut self, matches: &[(DocumentId, TmpMatch)]) {
-        for (_, match_) in matches {
-            self.query_index.push(match_.query_index);
-            self.distance.push(match_.distance);
-            self.attribute.push(match_.attribute);
-            self.word_index.push(match_.word_index);
-            self.is_exact.push(match_.is_exact);
+        bare_matches.sort_unstable_by_key(|m| m.query_index);
+
+        RawDocument {
+            id: bare_matches[0].document_id,
+            bare_matches,
+            processed_matches: Vec::new(),
+            processed_distances: Vec::new(),
+            contains_one_word_field: false,
         }
     }
 }

meilisearch-core/src/raw_indexer.rs

@@ -1,52 +1,60 @@
+use std::borrow::Cow;
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;
 
-use crate::{DocIndex, DocumentId};
-use deunicode::deunicode_with_tofu;
-use meilisearch_schema::SchemaAttr;
-use meilisearch_tokenizer::{is_cjk, SeqTokenizer, Token, Tokenizer};
+use meilisearch_schema::IndexedPos;
+use meilisearch_tokenizer::analyzer::{Analyzer, AnalyzerConfig};
+use meilisearch_tokenizer::{Token, token::SeparatorKind, TokenKind};
 use sdset::SetBuf;
 
+use crate::{DocIndex, DocumentId};
+use crate::FstSetCow;
+
 const WORD_LENGTH_LIMIT: usize = 80;
 
 type Word = Vec<u8>; // TODO make it be a SmallVec
 
-pub struct RawIndexer {
+pub struct RawIndexer<'a, A> {
     word_limit: usize, // the maximum number of indexed words
-    stop_words: fst::Set,
     words_doc_indexes: BTreeMap<Word, Vec<DocIndex>>,
     docs_words: HashMap<DocumentId, Vec<Word>>,
+    analyzer: Analyzer<'a, A>,
 }
 
-pub struct Indexed {
+pub struct Indexed<'a> {
     pub words_doc_indexes: BTreeMap<Word, SetBuf<DocIndex>>,
-    pub docs_words: HashMap<DocumentId, fst::Set>,
+    pub docs_words: HashMap<DocumentId, FstSetCow<'a>>,
 }
 
-impl RawIndexer {
-    pub fn new(stop_words: fst::Set) -> RawIndexer {
+impl<'a, A> RawIndexer<'a, A>
+where
+    A: AsRef<[u8]>
+{
+    pub fn new(stop_words: &'a fst::Set<A>) -> RawIndexer<'a, A> {
         RawIndexer::with_word_limit(stop_words, 1000)
     }
 
-    pub fn with_word_limit(stop_words: fst::Set, limit: usize) -> RawIndexer {
+    pub fn with_word_limit(stop_words: &'a fst::Set<A>, limit: usize) -> RawIndexer<A> {
         RawIndexer {
             word_limit: limit,
-            stop_words,
             words_doc_indexes: BTreeMap::new(),
             docs_words: HashMap::new(),
+            analyzer: Analyzer::new(AnalyzerConfig::default_with_stopwords(stop_words)),
         }
     }
 
-    pub fn index_text(&mut self, id: DocumentId, attr: SchemaAttr, text: &str) -> usize {
+    pub fn index_text(&mut self, id: DocumentId, indexed_pos: IndexedPos, text: &str) -> usize {
         let mut number_of_words = 0;
 
-        for token in Tokenizer::new(text) {
+        let analyzed_text = self.analyzer.analyze(text);
+        for (token_pos, (word_pos, token)) in process_tokens(analyzed_text.tokens()).enumerate() {
             let must_continue = index_token(
                 token,
+                word_pos,
+                token_pos,
                 id,
-                attr,
+                indexed_pos,
                 self.word_limit,
-                &self.stop_words,
                 &mut self.words_doc_indexes,
                 &mut self.docs_words,
             );
@@ -61,29 +69,42 @@ impl RawIndexer {
         number_of_words
     }
 
-    pub fn index_text_seq<'a, I>(&mut self, id: DocumentId, attr: SchemaAttr, iter: I)
+    pub fn index_text_seq<'s, I>(&mut self, id: DocumentId, indexed_pos: IndexedPos, text_iter: I)
     where
-        I: IntoIterator<Item = &'a str>,
+        I: IntoIterator<Item = &'s str>,
     {
-        let iter = iter.into_iter();
-        for token in SeqTokenizer::new(iter) {
-            let must_continue = index_token(
-                token,
-                id,
-                attr,
-                self.word_limit,
-                &self.stop_words,
-                &mut self.words_doc_indexes,
-                &mut self.docs_words,
-            );
+        let mut word_offset = 0;
 
-            if !must_continue {
-                break;
+        for text in text_iter.into_iter() {
+            let current_word_offset = word_offset;
+
+            let analyzed_text = self.analyzer.analyze(text);
+            let tokens = process_tokens(analyzed_text.tokens())
+                .map(|(i, t)| (i + current_word_offset, t))
+                .enumerate();
+
+            for (token_pos, (word_pos, token)) in tokens  {
+                word_offset = word_pos + 1;
+
+                let must_continue = index_token(
+                    token,
+                    word_pos,
+                    token_pos,
+                    id,
+                    indexed_pos,
+                    self.word_limit,
+                    &mut self.words_doc_indexes,
+                    &mut self.docs_words,
+                );
+
+                if !must_continue {
+                    break;
+                }
             }
         }
     }
 
-    pub fn build(self) -> Indexed {
+    pub fn build(self) -> Indexed<'static> {
         let words_doc_indexes = self
             .words_doc_indexes
             .into_iter()
@@ -96,7 +117,8 @@ impl RawIndexer {
             .map(|(id, mut words)| {
                 words.sort_unstable();
                 words.dedup();
-                (id, fst::Set::from_iter(words).unwrap())
+                let fst = fst::Set::from_iter(words).unwrap().map_data(Cow::Owned).unwrap();
+                (id, fst)
             })
             .collect();
 
@@ -107,29 +129,53 @@ impl RawIndexer {
     }
 }
 
+fn process_tokens<'a>(tokens: impl Iterator<Item = Token<'a>>) -> impl Iterator<Item = (usize, Token<'a>)> {
+    tokens
+        .skip_while(|token| !token.is_word())
+        .scan((0, None), |(offset, prev_kind), token| {
+                match token.kind {
+                    TokenKind::Word | TokenKind::StopWord | TokenKind::Unknown => {
+                        *offset += match *prev_kind {
+                            Some(TokenKind::Separator(SeparatorKind::Hard)) => 8,
+                            Some(_) => 1,
+                            None => 0,
+                        };
+                        *prev_kind = Some(token.kind)
+                    }
+                    TokenKind::Separator(SeparatorKind::Hard) => {
+                        *prev_kind = Some(token.kind);
+                    }
+                    TokenKind::Separator(SeparatorKind::Soft)
+                        if *prev_kind != Some(TokenKind::Separator(SeparatorKind::Hard)) => {
+                        *prev_kind = Some(token.kind);
+                    }
+                    _ => (),
+                }
+            Some((*offset, token))
+        })
+    .filter(|(_, t)| t.is_word())
+}
+
+#[allow(clippy::too_many_arguments)]
 fn index_token(
     token: Token,
+    word_pos: usize,
+    token_pos: usize,
     id: DocumentId,
-    attr: SchemaAttr,
+    indexed_pos: IndexedPos,
     word_limit: usize,
-    stop_words: &fst::Set,
     words_doc_indexes: &mut BTreeMap<Word, Vec<DocIndex>>,
     docs_words: &mut HashMap<DocumentId, Vec<Word>>,
-) -> bool {
-    if token.word_index >= word_limit {
+) -> bool
+{
+    if token_pos >= word_limit {
         return false;
     }
 
-    let lower = token.word.to_lowercase();
-    let token = Token {
-        word: &lower,
-        ..token
-    };
-
-    if !stop_words.contains(&token.word) {
-        match token_to_docindex(id, attr, token) {
+    if !token.is_stopword() {
+        match token_to_docindex(id, indexed_pos, &token, word_pos) {
             Some(docindex) => {
-                let word = Vec::from(token.word);
+                let word = Vec::from(token.word.as_ref());
 
                 if word.len() <= WORD_LENGTH_LIMIT {
                     words_doc_indexes
@@ -137,20 +183,6 @@ fn index_token(
                         .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);
-                            }
-                        }
-                    }
                 }
             }
             None => return false,
@@ -160,14 +192,14 @@ fn index_token(
     true
 }
 
-fn token_to_docindex(id: DocumentId, attr: SchemaAttr, token: Token) -> Option<DocIndex> {
-    let word_index = u16::try_from(token.word_index).ok()?;
-    let char_index = u16::try_from(token.char_index).ok()?;
-    let char_length = u16::try_from(token.word.chars().count()).ok()?;
+fn token_to_docindex(id: DocumentId, indexed_pos: IndexedPos, token: &Token, word_index: usize) -> Option<DocIndex> {
+    let word_index = u16::try_from(word_index).ok()?;
+    let char_index = u16::try_from(token.byte_start).ok()?;
+    let char_length = u16::try_from(token.word.len()).ok()?;
 
     let docindex = DocIndex {
         document_id: id,
-        attribute: attr.0,
+        attribute: indexed_pos.0,
         word_index,
         char_index,
         char_length,
@@ -179,15 +211,29 @@ fn token_to_docindex(id: DocumentId, attr: SchemaAttr, token: Token) -> Option<D
 #[cfg(test)]
 mod tests {
     use super::*;
+    use meilisearch_schema::IndexedPos;
+    use meilisearch_tokenizer::{Analyzer, AnalyzerConfig};
+    use fst::Set;
+
+    #[test]
+    fn test_process_token() {
+        let text = " 為一包含一千多萬目詞的帶標記平衡語料庫";
+        let stopwords = Set::default();
+        let analyzer = Analyzer::new(AnalyzerConfig::default_with_stopwords(&stopwords));
+        let analyzer = analyzer.analyze(text);
+        let tokens: Vec<_> = process_tokens(analyzer.tokens()).map(|(_, t)| t.text().to_string()).collect();
+        assert_eq!(tokens, ["为", "一", "包含", "一千多万", "目词", "的", "带", "标记", "平衡", "语料库"]);
+    }
 
     #[test]
     fn strange_apostrophe() {
-        let mut indexer = RawIndexer::new(fst::Set::default());
+        let stop_words = fst::Set::default();
+        let mut indexer = RawIndexer::new(&stop_words);
 
         let docid = DocumentId(0);
-        let attr = SchemaAttr(0);
+        let indexed_pos = IndexedPos(0);
         let text = "Zut, l’aspirateur, j’ai oublié de l’éteindre !";
-        indexer.index_text(docid, attr, text);
+        indexer.index_text(docid, indexed_pos, text);
 
         let Indexed {
             words_doc_indexes, ..
@@ -197,19 +243,17 @@ mod tests {
         assert!(words_doc_indexes.get(&b"aspirateur"[..]).is_some());
         assert!(words_doc_indexes.get(&b"ai"[..]).is_some());
         assert!(words_doc_indexes.get(&b"eteindre"[..]).is_some());
-        assert!(words_doc_indexes
-            .get(&"éteindre".to_owned().into_bytes())
-            .is_some());
     }
 
     #[test]
     fn strange_apostrophe_in_sequence() {
-        let mut indexer = RawIndexer::new(fst::Set::default());
+        let stop_words = fst::Set::default();
+        let mut indexer = RawIndexer::new(&stop_words);
 
         let docid = DocumentId(0);
-        let attr = SchemaAttr(0);
+        let indexed_pos = IndexedPos(0);
         let text = vec!["Zut, l’aspirateur, j’ai oublié de l’éteindre !"];
-        indexer.index_text_seq(docid, attr, text);
+        indexer.index_text_seq(docid, indexed_pos, text);
 
         let Indexed {
             words_doc_indexes, ..
@@ -219,9 +263,6 @@ mod tests {
         assert!(words_doc_indexes.get(&b"aspirateur"[..]).is_some());
         assert!(words_doc_indexes.get(&b"ai"[..]).is_some());
         assert!(words_doc_indexes.get(&b"eteindre"[..]).is_some());
-        assert!(words_doc_indexes
-            .get(&"éteindre".to_owned().into_bytes())
-            .is_some());
     }
 
     #[test]
@@ -229,12 +270,12 @@ mod tests {
         let stop_words = sdset::SetBuf::from_dirty(vec!["l", "j", "ai", "de"]);
         let stop_words = fst::Set::from_iter(stop_words).unwrap();
 
-        let mut indexer = RawIndexer::new(stop_words);
+        let mut indexer = RawIndexer::new(&stop_words);
 
         let docid = DocumentId(0);
-        let attr = SchemaAttr(0);
+        let indexed_pos = IndexedPos(0);
         let text = "Zut, l’aspirateur, j’ai oublié de l’éteindre !";
-        indexer.index_text(docid, attr, text);
+        indexer.index_text(docid, indexed_pos, text);
 
         let Indexed {
             words_doc_indexes, ..
@@ -246,19 +287,17 @@ mod tests {
         assert!(words_doc_indexes.get(&b"ai"[..]).is_none());
         assert!(words_doc_indexes.get(&b"de"[..]).is_none());
         assert!(words_doc_indexes.get(&b"eteindre"[..]).is_some());
-        assert!(words_doc_indexes
-            .get(&"éteindre".to_owned().into_bytes())
-            .is_some());
     }
 
     #[test]
     fn no_empty_unidecode() {
-        let mut indexer = RawIndexer::new(fst::Set::default());
+        let stop_words = fst::Set::default();
+        let mut indexer = RawIndexer::new(&stop_words);
 
         let docid = DocumentId(0);
-        let attr = SchemaAttr(0);
+        let indexed_pos = IndexedPos(0);
         let text = "🇯🇵";
-        indexer.index_text(docid, attr, text);
+        indexer.index_text(docid, indexed_pos, text);
 
         let Indexed {
             words_doc_indexes, ..
@@ -268,4 +307,38 @@ mod tests {
             .get(&"🇯🇵".to_owned().into_bytes())
             .is_some());
     }
+
+    #[test]
+    // test sample from 807
+    fn very_long_text() {
+        let stop_words = fst::Set::default();
+        let mut indexer = RawIndexer::new(&stop_words);
+        let indexed_pos = IndexedPos(0);
+        let docid = DocumentId(0);
+        let text = " The locations block is the most powerful, and potentially most involved, section of the .platform.app.yaml file. It allows you to control how the application container responds to incoming requests at a very fine-grained level. Common patterns also vary between language containers due to the way PHP-FPM handles incoming requests.\nEach entry of the locations block is an absolute URI path (with leading /) and its value includes the configuration directives for how the web server should handle matching requests. That is, if your domain is example.com then '/' means &ldquo;requests for example.com/&rdquo;, while '/admin' means &ldquo;requests for example.com/admin&rdquo;. If multiple blocks could match an incoming request then the most-specific will apply.\nweb:locations:&#39;/&#39;:# Rules for all requests that don&#39;t otherwise match....&#39;/sites/default/files&#39;:# Rules for any requests that begin with /sites/default/files....The simplest possible locations configuration is one that simply passes all requests on to your application unconditionally:\nweb:locations:&#39;/&#39;:passthru:trueThat is, all requests to /* should be forwarded to the process started by web.commands.start above. Note that for PHP containers the passthru key must specify what PHP file the request should be forwarded to, and must also specify a docroot under which the file lives. For example:\nweb:locations:&#39;/&#39;:root:&#39;web&#39;passthru:&#39;/app.php&#39;This block will serve requests to / from the web directory in the application, and if a file doesn&rsquo;t exist on disk then the request will be forwarded to the /app.php script.\nA full list of the possible subkeys for locations is below.\n  root: The folder from which to serve static assets for this location relative to the application root. The application root is the directory in which the .platform.app.yaml file is located. Typical values for this property include public or web. Setting it to '' is not recommended, and its behavior may vary depending on the type of application. Absolute paths are not supported.\n  passthru: Whether to forward disallowed and missing resources from this location to the application and can be true, false or an absolute URI path (with leading /). The default value is false. For non-PHP applications it will generally be just true or false. In a PHP application this will typically be the front controller such as /index.php or /app.php. This entry works similar to mod_rewrite under Apache. Note: If the value of passthru does not begin with the same value as the location key it is under, the passthru may evaluate to another entry. That may be useful when you want different cache settings for different paths, for instance, but want missing files in all of them to map back to the same front controller. See the example block below.\n  index: The files to consider when serving a request for a directory: an array of file names or null. (typically ['index.html']). Note that in order for this to work, access to the static files named must be allowed by the allow or rules keys for this location.\n  expires: How long to allow static assets from this location to be cached (this enables the Cache-Control and Expires headers) and can be a time or -1 for no caching (default). Times can be suffixed with &ldquo;ms&rdquo; (milliseconds), &ldquo;s&rdquo; (seconds), &ldquo;m&rdquo; (minutes), &ldquo;h&rdquo; (hours), &ldquo;d&rdquo; (days), &ldquo;w&rdquo; (weeks), &ldquo;M&rdquo; (months, 30d) or &ldquo;y&rdquo; (years, 365d).\n  scripts: Whether to allow loading scripts in that location (true or false). This directive is only meaningful on PHP.\n  allow: Whether to allow serving files which don&rsquo;t match a rule (true or false, default: true).\n  headers: Any additional headers to apply to static assets. This section is a mapping of header names to header values. Responses from the application aren&rsquo;t affected, to avoid overlap with the application&rsquo;s own ability to include custom headers in the response.\n  rules: Specific overrides for a specific location. The key is a PCRE (regular expression) that is matched against the full request path.\n  request_buffering: Most application servers do not support chunked requests (e.g. fpm, uwsgi), so Platform.sh enables request_buffering by default to handle them. That default configuration would look like this if it was present in .platform.app.yaml:\nweb:locations:&#39;/&#39;:passthru:truerequest_buffering:enabled:truemax_request_size:250mIf the application server can already efficiently handle chunked requests, the request_buffering subkey can be modified to disable it entirely (enabled: false). Additionally, applications that frequently deal with uploads greater than 250MB in size can update the max_request_size key to the application&rsquo;s needs. Note that modifications to request_buffering will need to be specified at each location where it is desired.\n ";
+        indexer.index_text(docid, indexed_pos, text);
+        let Indexed {
+            words_doc_indexes, ..
+        } = indexer.build();
+        assert!(words_doc_indexes.get(&"request".to_owned().into_bytes()).is_some());
+    }
+
+    #[test]
+    fn words_over_index_1000_not_indexed() {
+        let stop_words = fst::Set::default();
+        let mut indexer = RawIndexer::new(&stop_words);
+        let indexed_pos = IndexedPos(0);
+        let docid = DocumentId(0);
+        let mut text = String::with_capacity(5000);
+        for _ in 0..1000 {
+            text.push_str("less ");
+        }
+        text.push_str("more");
+        indexer.index_text(docid, indexed_pos, &text);
+        let Indexed {
+            words_doc_indexes, ..
+        } = indexer.build();
+        assert!(words_doc_indexes.get(&"less".to_owned().into_bytes()).is_some());
+        assert!(words_doc_indexes.get(&"more".to_owned().into_bytes()).is_none());
+    }
 }

meilisearch-core/src/reordered_attrs.rs

@@ -1,27 +1,31 @@
+use std::cmp;
+
 #[derive(Default, Clone)]
 pub struct ReorderedAttrs {
-    count: usize,
     reorders: Vec<Option<u16>>,
+    reverse: Vec<u16>,
 }
 
 impl ReorderedAttrs {
     pub fn new() -> ReorderedAttrs {
-        ReorderedAttrs {
-            count: 0,
-            reorders: Vec::new(),
-        }
+        ReorderedAttrs { reorders: Vec::new(), reverse: Vec::new() }
     }
 
     pub fn insert_attribute(&mut self, attribute: u16) {
-        self.reorders.resize(attribute as usize + 1, None);
-        self.reorders[attribute as usize] = Some(self.count as u16);
-        self.count += 1;
+        let new_len = cmp::max(attribute as usize + 1, self.reorders.len());
+        self.reorders.resize(new_len, None);
+        self.reorders[attribute as usize] = Some(self.reverse.len() as u16);
+        self.reverse.push(attribute);
     }
 
     pub fn get(&self, attribute: u16) -> Option<u16> {
-        match self.reorders.get(attribute as usize) {
-            Some(Some(attribute)) => Some(*attribute),
-            _ => None,
+        match self.reorders.get(attribute as usize)? {
+            Some(attribute) => Some(*attribute),
+            None => None,
         }
     }
+
+    pub fn reverse(&self, attribute: u16) -> Option<u16> {
+        self.reverse.get(attribute as usize).copied()
+    }
 }

meilisearch-core/src/serde/convert_to_number.rs

@@ -1,198 +0,0 @@
-use std::str::FromStr;
-
-use ordered_float::OrderedFloat;
-use serde::ser;
-use serde::Serialize;
-
-use super::SerializerError;
-use crate::Number;
-
-pub struct ConvertToNumber;
-
-impl ser::Serializer for ConvertToNumber {
-    type Ok = Number;
-    type Error = SerializerError;
-    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeMap = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
-
-    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Unsigned(u64::from(value)))
-    }
-
-    fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType { type_name: "char" })
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Signed(i64::from(value)))
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Signed(i64::from(value)))
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Signed(i64::from(value)))
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Signed(value))
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Unsigned(u64::from(value)))
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Unsigned(u64::from(value)))
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Unsigned(u64::from(value)))
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Unsigned(value))
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Float(OrderedFloat(f64::from(value))))
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::Float(OrderedFloat(value)))
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        Ok(Number::from_str(value)?)
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType { type_name: "&[u8]" })
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnrankableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType { type_name: "()" })
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "unit struct",
-        })
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "unit variant",
-        })
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnrankableType {
-            type_name: "newtype variant",
-        })
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "sequence",
-        })
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(SerializerError::UnrankableType { type_name: "tuple" })
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "tuple struct",
-        })
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "tuple variant",
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Err(SerializerError::UnrankableType { type_name: "map" })
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "struct",
-        })
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(SerializerError::UnrankableType {
-            type_name: "struct variant",
-        })
-    }
-}

meilisearch-core/src/serde/convert_to_string.rs

@@ -1,258 +0,0 @@
-use serde::ser;
-use serde::Serialize;
-
-use super::SerializerError;
-
-pub struct ConvertToString;
-
-impl ser::Serializer for ConvertToString {
-    type Ok = String;
-    type Error = SerializerError;
-    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeMap = MapConvertToString;
-    type SerializeStruct = StructConvertToString;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
-
-    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "boolean",
-        })
-    }
-
-    fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "&[u8]" })
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "()" })
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit struct",
-        })
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit variant",
-        })
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "newtype variant",
-        })
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "sequence",
-        })
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "tuple" })
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple struct",
-        })
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple variant",
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Ok(MapConvertToString {
-            text: String::new(),
-        })
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Ok(StructConvertToString {
-            text: String::new(),
-        })
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "struct variant",
-        })
-    }
-}
-
-pub struct MapConvertToString {
-    text: String,
-}
-
-impl ser::SerializeMap for MapConvertToString {
-    type Ok = String;
-    type Error = SerializerError;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = key.serialize(ConvertToString)?;
-        self.text.push_str(&text);
-        self.text.push_str(" ");
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = value.serialize(ConvertToString)?;
-        self.text.push_str(&text);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.text)
-    }
-}
-
-pub struct StructConvertToString {
-    text: String,
-}
-
-impl ser::SerializeStruct for StructConvertToString {
-    type Ok = String;
-    type Error = SerializerError;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let value = value.serialize(ConvertToString)?;
-        self.text.push_str(key);
-        self.text.push_str(" ");
-        self.text.push_str(&value);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.text)
-    }
-}

meilisearch-core/src/serde/deserializer.rs

@@ -2,12 +2,13 @@ use std::collections::HashSet;
 use std::io::Cursor;
 use std::{error::Error, fmt};
 
-use meilisearch_schema::{Schema, SchemaAttr};
+use meilisearch_schema::{Schema, FieldId};
 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,10 +51,10 @@ impl From<heed::Error> for DeserializerError {
 
 pub struct Deserializer<'a> {
     pub document_id: DocumentId,
-    pub reader: &'a heed::RoTxn,
+    pub reader: &'a heed::RoTxn<'a, MainT>,
     pub documents_fields: DocumentsFields,
     pub schema: &'a Schema,
-    pub attributes: Option<&'a HashSet<SchemaAttr>>,
+    pub fields: Option<&'a HashSet<FieldId>>,
 }
 
 impl<'de, 'a, 'b> de::Deserializer<'de> for &'b mut Deserializer<'a> {
@@ -91,15 +92,17 @@ impl<'de, 'a, 'b> de::Deserializer<'de> for &'b mut Deserializer<'a> {
                     }
                 };
 
-                let is_displayed = self.schema.props(attr).is_displayed();
-                if is_displayed && self.attributes.map_or(true, |f| f.contains(&attr)) {
-                    let attribute_name = self.schema.attribute_name(attr);
+                let is_displayed = self.schema.is_displayed(attr);
+                if is_displayed && self.fields.map_or(true, |f| f.contains(&attr)) {
+                    if let Some(attribute_name) = self.schema.name(attr) {
+                        let cursor = Cursor::new(value.to_owned());
+                        let ioread = SerdeJsonIoRead::new(cursor);
+                        let value = Value(SerdeJsonDeserializer::new(ioread));
 
-                    let cursor = Cursor::new(value.to_owned());
-                    let ioread = SerdeJsonIoRead::new(cursor);
-                    let value = Value(SerdeJsonDeserializer::new(ioread));
-
-                    Some((attribute_name, value))
+                        Some((attribute_name, value))
+                    } else {
+                        None
+                    }
                 } else {
                     None
                 }

meilisearch-core/src/serde/extract_document_id.rs

@@ -1,295 +0,0 @@
-use std::hash::{Hash, Hasher};
-
-use crate::DocumentId;
-use serde::{ser, Serialize};
-use serde_json::Value;
-use siphasher::sip::SipHasher;
-
-use super::{ConvertToString, SerializerError};
-
-pub fn extract_document_id<D>(
-    identifier: &str,
-    document: &D,
-) -> Result<Option<DocumentId>, SerializerError>
-where
-    D: serde::Serialize,
-{
-    let serializer = ExtractDocumentId { identifier };
-    document.serialize(serializer)
-}
-
-pub fn value_to_string(value: &Value) -> Option<String> {
-    match value {
-        Value::Null => None,
-        Value::Bool(_) => None,
-        Value::Number(value) => Some(value.to_string()),
-        Value::String(value) => Some(value.to_string()),
-        Value::Array(_) => None,
-        Value::Object(_) => None,
-    }
-}
-
-pub fn compute_document_id<H: Hash>(t: H) -> DocumentId {
-    let mut s = SipHasher::new();
-    t.hash(&mut s);
-    let hash = s.finish();
-    DocumentId(hash)
-}
-
-struct ExtractDocumentId<'a> {
-    identifier: &'a str,
-}
-
-impl<'a> ser::Serializer for ExtractDocumentId<'a> {
-    type Ok = Option<DocumentId>;
-    type Error = SerializerError;
-    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeMap = ExtractDocumentIdMapSerializer<'a>;
-    type SerializeStruct = ExtractDocumentIdStructSerializer<'a>;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
-
-    forward_to_unserializable_type! {
-        bool => serialize_bool,
-        char => serialize_char,
-
-        i8  => serialize_i8,
-        i16 => serialize_i16,
-        i32 => serialize_i32,
-        i64 => serialize_i64,
-
-        u8  => serialize_u8,
-        u16 => serialize_u16,
-        u32 => serialize_u32,
-        u64 => serialize_u64,
-
-        f32 => serialize_f32,
-        f64 => serialize_f64,
-    }
-
-    fn serialize_str(self, _value: &str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "str" })
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "&[u8]" })
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "()" })
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit struct",
-        })
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit variant",
-        })
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "newtype variant",
-        })
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "sequence",
-        })
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "tuple" })
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple struct",
-        })
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple variant",
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        let serializer = ExtractDocumentIdMapSerializer {
-            identifier: self.identifier,
-            document_id: None,
-            current_key_name: None,
-        };
-
-        Ok(serializer)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        let serializer = ExtractDocumentIdStructSerializer {
-            identifier: self.identifier,
-            document_id: None,
-        };
-
-        Ok(serializer)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "struct variant",
-        })
-    }
-}
-
-pub struct ExtractDocumentIdMapSerializer<'a> {
-    identifier: &'a str,
-    document_id: Option<DocumentId>,
-    current_key_name: Option<String>,
-}
-
-impl<'a> ser::SerializeMap for ExtractDocumentIdMapSerializer<'a> {
-    type Ok = Option<DocumentId>;
-    type Error = SerializerError;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        let key = key.serialize(ConvertToString)?;
-        self.current_key_name = Some(key);
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        let key = self.current_key_name.take().unwrap();
-        self.serialize_entry(&key, value)
-    }
-
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-    {
-        let key = key.serialize(ConvertToString)?;
-
-        if self.identifier == key {
-            let value = serde_json::to_string(value).and_then(|s| serde_json::from_str(&s))?;
-            match value_to_string(&value).map(|s| compute_document_id(&s)) {
-                Some(document_id) => self.document_id = Some(document_id),
-                None => return Err(SerializerError::InvalidDocumentIdType),
-            }
-        }
-
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.document_id)
-    }
-}
-
-pub struct ExtractDocumentIdStructSerializer<'a> {
-    identifier: &'a str,
-    document_id: Option<DocumentId>,
-}
-
-impl<'a> ser::SerializeStruct for ExtractDocumentIdStructSerializer<'a> {
-    type Ok = Option<DocumentId>;
-    type Error = SerializerError;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        if self.identifier == key {
-            let value = serde_json::to_string(value).and_then(|s| serde_json::from_str(&s))?;
-            match value_to_string(&value).map(compute_document_id) {
-                Some(document_id) => self.document_id = Some(document_id),
-                None => return Err(SerializerError::InvalidDocumentIdType),
-            }
-        }
-
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.document_id)
-    }
-}

meilisearch-core/src/serde/indexer.rs

@@ -1,365 +0,0 @@
-use meilisearch_schema::SchemaAttr;
-use serde::ser;
-use serde::Serialize;
-
-use super::{ConvertToString, SerializerError};
-use crate::raw_indexer::RawIndexer;
-use crate::DocumentId;
-
-pub struct Indexer<'a> {
-    pub attribute: SchemaAttr,
-    pub indexer: &'a mut RawIndexer,
-    pub document_id: DocumentId,
-}
-
-impl<'a> ser::Serializer for Indexer<'a> {
-    type Ok = Option<usize>;
-    type Error = SerializerError;
-    type SerializeSeq = SeqIndexer<'a>;
-    type SerializeTuple = TupleIndexer<'a>;
-    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeMap = MapIndexer<'a>;
-    type SerializeStruct = StructIndexer<'a>;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
-
-    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "boolean",
-        })
-    }
-
-    fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<Self::Ok, Self::Error> {
-        let text = value.serialize(ConvertToString)?;
-        self.serialize_str(&text)
-    }
-
-    fn serialize_str(self, text: &str) -> Result<Self::Ok, Self::Error> {
-        let number_of_words = self
-            .indexer
-            .index_text(self.document_id, self.attribute, text);
-        Ok(Some(number_of_words))
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType { type_name: "&[u8]" })
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = value.serialize(ConvertToString)?;
-        let number_of_words = self
-            .indexer
-            .index_text(self.document_id, self.attribute, &text);
-        Ok(Some(number_of_words))
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType { type_name: "()" })
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "unit struct",
-        })
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "unit variant",
-        })
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(SerializerError::UnindexableType {
-            type_name: "newtype variant",
-        })
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        let indexer = SeqIndexer {
-            attribute: self.attribute,
-            document_id: self.document_id,
-            indexer: self.indexer,
-            texts: Vec::new(),
-        };
-
-        Ok(indexer)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        let indexer = TupleIndexer {
-            attribute: self.attribute,
-            document_id: self.document_id,
-            indexer: self.indexer,
-            texts: Vec::new(),
-        };
-
-        Ok(indexer)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "tuple struct",
-        })
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "tuple variant",
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        let indexer = MapIndexer {
-            attribute: self.attribute,
-            document_id: self.document_id,
-            indexer: self.indexer,
-            texts: Vec::new(),
-        };
-
-        Ok(indexer)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "struct",
-        })
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(SerializerError::UnindexableType {
-            type_name: "struct variant",
-        })
-    }
-}
-
-pub struct SeqIndexer<'a> {
-    attribute: SchemaAttr,
-    document_id: DocumentId,
-    indexer: &'a mut RawIndexer,
-    texts: Vec<String>,
-}
-
-impl<'a> ser::SerializeSeq for SeqIndexer<'a> {
-    type Ok = Option<usize>;
-    type Error = SerializerError;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = value.serialize(ConvertToString)?;
-        self.texts.push(text);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        let texts = self.texts.iter().map(String::as_str);
-        self.indexer
-            .index_text_seq(self.document_id, self.attribute, texts);
-        Ok(None)
-    }
-}
-
-pub struct MapIndexer<'a> {
-    attribute: SchemaAttr,
-    document_id: DocumentId,
-    indexer: &'a mut RawIndexer,
-    texts: Vec<String>,
-}
-
-impl<'a> ser::SerializeMap for MapIndexer<'a> {
-    type Ok = Option<usize>;
-    type Error = SerializerError;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = key.serialize(ConvertToString)?;
-        self.texts.push(text);
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let text = value.serialize(ConvertToString)?;
-        self.texts.push(text);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        let texts = self.texts.iter().map(String::as_str);
-        self.indexer
-            .index_text_seq(self.document_id, self.attribute, texts);
-        Ok(None)
-    }
-}
-
-pub struct StructIndexer<'a> {
-    attribute: SchemaAttr,
-    document_id: DocumentId,
-    indexer: &'a mut RawIndexer,
-    texts: Vec<String>,
-}
-
-impl<'a> ser::SerializeStruct for StructIndexer<'a> {
-    type Ok = Option<usize>;
-    type Error = SerializerError;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let key_text = key.to_owned();
-        let value_text = value.serialize(ConvertToString)?;
-        self.texts.push(key_text);
-        self.texts.push(value_text);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        let texts = self.texts.iter().map(String::as_str);
-        self.indexer
-            .index_text_seq(self.document_id, self.attribute, texts);
-        Ok(None)
-    }
-}
-
-pub struct TupleIndexer<'a> {
-    attribute: SchemaAttr,
-    document_id: DocumentId,
-    indexer: &'a mut RawIndexer,
-    texts: Vec<String>,
-}
-
-impl<'a> ser::SerializeTuple for TupleIndexer<'a> {
-    type Ok = Option<usize>;
-    type Error = SerializerError;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize,
-    {
-        let text = value.serialize(ConvertToString)?;
-        self.texts.push(text);
-        Ok(())
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        let texts = self.texts.iter().map(String::as_str);
-        self.indexer
-            .index_text_seq(self.document_id, self.attribute, texts);
-        Ok(None)
-    }
-}

meilisearch-core/src/serde/mod.rs

@@ -1,41 +1,23 @@
-macro_rules! forward_to_unserializable_type {
-    ($($ty:ident => $se_method:ident,)*) => {
-        $(
-            fn $se_method(self, _v: $ty) -> Result<Self::Ok, Self::Error> {
-                Err(SerializerError::UnserializableType { type_name: "$ty" })
-            }
-        )*
-    }
-}
-
-mod convert_to_number;
-mod convert_to_string;
 mod deserializer;
-mod extract_document_id;
-mod indexer;
-mod serializer;
 
-pub use self::convert_to_number::ConvertToNumber;
-pub use self::convert_to_string::ConvertToString;
 pub use self::deserializer::{Deserializer, DeserializerError};
-pub use self::extract_document_id::{compute_document_id, extract_document_id, value_to_string};
-pub use self::indexer::Indexer;
-pub use self::serializer::{serialize_value, Serializer};
 
 use std::{error::Error, fmt};
 
 use serde::ser;
 use serde_json::Error as SerdeJsonError;
+use meilisearch_schema::Error as SchemaError;
 
 use crate::ParseNumberError;
 
 #[derive(Debug)]
 pub enum SerializerError {
     DocumentIdNotFound,
-    InvalidDocumentIdType,
+    InvalidDocumentIdFormat,
     Zlmdb(heed::Error),
     SerdeJson(SerdeJsonError),
     ParseNumber(ParseNumberError),
+    Schema(SchemaError),
     UnserializableType { type_name: &'static str },
     UnindexableType { type_name: &'static str },
     UnrankableType { type_name: &'static str },
@@ -52,16 +34,17 @@ impl fmt::Display for SerializerError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             SerializerError::DocumentIdNotFound => {
-                f.write_str("serialized document does not have an id according to the schema")
+                f.write_str("Primary key is missing.")
             }
-            SerializerError::InvalidDocumentIdType => {
-                f.write_str("document identifier can only be of type string or number")
+            SerializerError::InvalidDocumentIdFormat => {
+                f.write_str("a document primary key can be of type integer or string only composed of alphanumeric characters, hyphens (-) and underscores (_).")
             }
             SerializerError::Zlmdb(e) => write!(f, "heed related error: {}", e),
             SerializerError::SerdeJson(e) => write!(f, "serde json error: {}", e),
             SerializerError::ParseNumber(e) => {
                 write!(f, "error while trying to parse a number: {}", e)
             }
+            SerializerError::Schema(e) => write!(f, "impossible to update schema: {}", e),
             SerializerError::UnserializableType { type_name } => {
                 write!(f, "{} is not a serializable type", type_name)
             }
@@ -101,3 +84,9 @@ impl From<ParseNumberError> for SerializerError {
         SerializerError::ParseNumber(error)
     }
 }
+
+impl From<SchemaError> for SerializerError {
+    fn from(error: SchemaError) -> SerializerError {
+        SerializerError::Schema(error)
+   }
+}

meilisearch-core/src/serde/serializer.rs

@@ -1,338 +0,0 @@
-use meilisearch_schema::{Schema, SchemaAttr, SchemaProps};
-use serde::ser;
-
-use crate::raw_indexer::RawIndexer;
-use crate::store::{DocumentsFields, DocumentsFieldsCounts};
-use crate::{DocumentId, RankedMap};
-
-use super::{ConvertToNumber, ConvertToString, Indexer, SerializerError};
-
-pub struct Serializer<'a, 'b> {
-    pub txn: &'a mut heed::RwTxn<'b>,
-    pub schema: &'a Schema,
-    pub document_store: DocumentsFields,
-    pub document_fields_counts: DocumentsFieldsCounts,
-    pub indexer: &'a mut RawIndexer,
-    pub ranked_map: &'a mut RankedMap,
-    pub document_id: DocumentId,
-}
-
-impl<'a, 'b> ser::Serializer for Serializer<'a, 'b> {
-    type Ok = ();
-    type Error = SerializerError;
-    type SerializeSeq = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTuple = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleStruct = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeTupleVariant = ser::Impossible<Self::Ok, Self::Error>;
-    type SerializeMap = MapSerializer<'a, 'b>;
-    type SerializeStruct = StructSerializer<'a, 'b>;
-    type SerializeStructVariant = ser::Impossible<Self::Ok, Self::Error>;
-
-    forward_to_unserializable_type! {
-        bool => serialize_bool,
-        char => serialize_char,
-
-        i8  => serialize_i8,
-        i16 => serialize_i16,
-        i32 => serialize_i32,
-        i64 => serialize_i64,
-
-        u8  => serialize_u8,
-        u16 => serialize_u16,
-        u32 => serialize_u32,
-        u64 => serialize_u64,
-
-        f32 => serialize_f32,
-        f64 => serialize_f64,
-    }
-
-    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "str" })
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "&[u8]" })
-    }
-
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "Option",
-        })
-    }
-
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "()" })
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit struct",
-        })
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "unit variant",
-        })
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        _name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        Err(SerializerError::UnserializableType {
-            type_name: "newtype variant",
-        })
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "sequence",
-        })
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
-        Err(SerializerError::UnserializableType { type_name: "tuple" })
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple struct",
-        })
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "tuple variant",
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        Ok(MapSerializer {
-            txn: self.txn,
-            schema: self.schema,
-            document_id: self.document_id,
-            document_store: self.document_store,
-            document_fields_counts: self.document_fields_counts,
-            indexer: self.indexer,
-            ranked_map: self.ranked_map,
-            current_key_name: None,
-        })
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error> {
-        Ok(StructSerializer {
-            txn: self.txn,
-            schema: self.schema,
-            document_id: self.document_id,
-            document_store: self.document_store,
-            document_fields_counts: self.document_fields_counts,
-            indexer: self.indexer,
-            ranked_map: self.ranked_map,
-        })
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error> {
-        Err(SerializerError::UnserializableType {
-            type_name: "struct variant",
-        })
-    }
-}
-
-pub struct MapSerializer<'a, 'b> {
-    txn: &'a mut heed::RwTxn<'b>,
-    schema: &'a Schema,
-    document_id: DocumentId,
-    document_store: DocumentsFields,
-    document_fields_counts: DocumentsFieldsCounts,
-    indexer: &'a mut RawIndexer,
-    ranked_map: &'a mut RankedMap,
-    current_key_name: Option<String>,
-}
-
-impl<'a, 'b> ser::SerializeMap for MapSerializer<'a, 'b> {
-    type Ok = ();
-    type Error = SerializerError;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let key = key.serialize(ConvertToString)?;
-        self.current_key_name = Some(key);
-        Ok(())
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        let key = self.current_key_name.take().unwrap();
-        self.serialize_entry(&key, value)
-    }
-
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
-    where
-        K: ser::Serialize,
-        V: ser::Serialize,
-    {
-        let key = key.serialize(ConvertToString)?;
-        match self.schema.attribute(&key) {
-            Some(attribute) => serialize_value(
-                self.txn,
-                attribute,
-                self.schema.props(attribute),
-                self.document_id,
-                self.document_store,
-                self.document_fields_counts,
-                self.indexer,
-                self.ranked_map,
-                value,
-            ),
-            None => Ok(()),
-        }
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-pub struct StructSerializer<'a, 'b> {
-    txn: &'a mut heed::RwTxn<'b>,
-    schema: &'a Schema,
-    document_id: DocumentId,
-    document_store: DocumentsFields,
-    document_fields_counts: DocumentsFieldsCounts,
-    indexer: &'a mut RawIndexer,
-    ranked_map: &'a mut RankedMap,
-}
-
-impl<'a, 'b> ser::SerializeStruct for StructSerializer<'a, 'b> {
-    type Ok = ();
-    type Error = SerializerError;
-
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: ser::Serialize,
-    {
-        match self.schema.attribute(key) {
-            Some(attribute) => serialize_value(
-                self.txn,
-                attribute,
-                self.schema.props(attribute),
-                self.document_id,
-                self.document_store,
-                self.document_fields_counts,
-                self.indexer,
-                self.ranked_map,
-                value,
-            ),
-            None => Ok(()),
-        }
-    }
-
-    fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(())
-    }
-}
-
-pub fn serialize_value<T: ?Sized>(
-    txn: &mut heed::RwTxn,
-    attribute: SchemaAttr,
-    props: SchemaProps,
-    document_id: DocumentId,
-    document_store: DocumentsFields,
-    documents_fields_counts: DocumentsFieldsCounts,
-    indexer: &mut RawIndexer,
-    ranked_map: &mut RankedMap,
-    value: &T,
-) -> Result<(), SerializerError>
-where
-    T: ser::Serialize,
-{
-    let serialized = serde_json::to_vec(value)?;
-    document_store.put_document_field(txn, document_id, attribute, &serialized)?;
-
-    if props.is_indexed() {
-        let indexer = Indexer {
-            attribute,
-            indexer,
-            document_id,
-        };
-        if let Some(number_of_words) = value.serialize(indexer)? {
-            documents_fields_counts.put_document_field_count(
-                txn,
-                document_id,
-                attribute,
-                number_of_words as u64,
-            )?;
-        }
-    }
-
-    if props.is_ranked() {
-        let number = value.serialize(ConvertToNumber)?;
-        ranked_map.insert(document_id, attribute, number);
-    }
-
-    Ok(())
-}

meilisearch-core/src/settings.rs

@@ -0,0 +1,183 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::str::FromStr;
+use std::iter::IntoIterator;
+
+use serde::{Deserialize, Deserializer, Serialize};
+use once_cell::sync::Lazy;
+
+use self::RankingRule::*;
+
+pub const DEFAULT_RANKING_RULES: [RankingRule; 6] = [Typo, Words, Proximity, Attribute, WordsPosition, Exactness];
+
+static RANKING_RULE_REGEX: Lazy<regex::Regex> = Lazy::new(|| {
+    regex::Regex::new(r"(asc|desc)\(([a-zA-Z0-9-_]*)\)").unwrap()
+});
+
+#[derive(Default, Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct Settings {
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub ranking_rules: Option<Option<Vec<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub distinct_attribute: Option<Option<String>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub searchable_attributes: Option<Option<Vec<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub displayed_attributes: Option<Option<BTreeSet<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub stop_words: Option<Option<BTreeSet<String>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub synonyms: Option<Option<BTreeMap<String, Vec<String>>>>,
+    #[serde(default, deserialize_with = "deserialize_some")]
+    pub attributes_for_faceting: Option<Option<Vec<String>>>,
+}
+
+// Any value that is present is considered Some value, including null.
+fn deserialize_some<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
+    where T: Deserialize<'de>,
+          D: Deserializer<'de>
+{
+    Deserialize::deserialize(deserializer).map(Some)
+}
+
+impl Settings {
+    pub fn to_update(&self) -> Result<SettingsUpdate, RankingRuleConversionError> {
+        let settings = self.clone();
+
+        let ranking_rules = match settings.ranking_rules {
+            Some(Some(rules)) => UpdateState::Update(RankingRule::try_from_iter(rules.iter())?),
+            Some(None) => UpdateState::Clear,
+            None => UpdateState::Nothing,
+        };
+
+        Ok(SettingsUpdate {
+            ranking_rules,
+            distinct_attribute: settings.distinct_attribute.into(),
+            primary_key: UpdateState::Nothing,
+            searchable_attributes: settings.searchable_attributes.into(),
+            displayed_attributes: settings.displayed_attributes.into(),
+            stop_words: settings.stop_words.into(),
+            synonyms: settings.synonyms.into(),
+            attributes_for_faceting: settings.attributes_for_faceting.into(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UpdateState<T> {
+    Update(T),
+    Clear,
+    Nothing,
+}
+
+impl <T> From<Option<Option<T>>> for UpdateState<T> {
+    fn from(opt: Option<Option<T>>) -> UpdateState<T> {
+        match opt {
+            Some(Some(t)) => UpdateState::Update(t),
+            Some(None) => UpdateState::Clear,
+            None => UpdateState::Nothing,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct RankingRuleConversionError;
+
+impl std::fmt::Display for RankingRuleConversionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "impossible to convert into RankingRule")
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum RankingRule {
+    Typo,
+    Words,
+    Proximity,
+    Attribute,
+    WordsPosition,
+    Exactness,
+    Asc(String),
+    Desc(String),
+}
+
+impl std::fmt::Display for RankingRule {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RankingRule::Typo => f.write_str("typo"),
+            RankingRule::Words => f.write_str("words"),
+            RankingRule::Proximity => f.write_str("proximity"),
+            RankingRule::Attribute => f.write_str("attribute"),
+            RankingRule::WordsPosition => f.write_str("wordsPosition"),
+            RankingRule::Exactness => f.write_str("exactness"),
+            RankingRule::Asc(field) => write!(f, "asc({})", field),
+            RankingRule::Desc(field) => write!(f, "desc({})", field),
+        }
+    }
+}
+
+impl FromStr for RankingRule {
+    type Err = RankingRuleConversionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let rule = match s {
+            "typo" => RankingRule::Typo,
+            "words" => RankingRule::Words,
+            "proximity" => RankingRule::Proximity,
+            "attribute" => RankingRule::Attribute,
+            "wordsPosition" => RankingRule::WordsPosition,
+            "exactness" => RankingRule::Exactness,
+            _ => {
+                let captures = RANKING_RULE_REGEX.captures(s).ok_or(RankingRuleConversionError)?;
+                match (captures.get(1).map(|m| m.as_str()), captures.get(2)) {
+                    (Some("asc"), Some(field)) => RankingRule::Asc(field.as_str().to_string()),
+                    (Some("desc"), Some(field)) => RankingRule::Desc(field.as_str().to_string()),
+                    _ => return Err(RankingRuleConversionError)
+                }
+            }
+        };
+        Ok(rule)
+    }
+}
+
+impl RankingRule {
+    pub fn field(&self) -> Option<&str> {
+        match self {
+            RankingRule::Asc(field) | RankingRule::Desc(field) => Some(field),
+            _ => None,
+        }
+    }
+
+    pub fn try_from_iter(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Result<Vec<RankingRule>, RankingRuleConversionError> {
+        rules.into_iter()
+            .map(|s| RankingRule::from_str(s.as_ref()))
+            .collect()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SettingsUpdate {
+    pub ranking_rules: UpdateState<Vec<RankingRule>>,
+    pub distinct_attribute: UpdateState<String>,
+    pub primary_key: UpdateState<String>,
+    pub searchable_attributes: UpdateState<Vec<String>>,
+    pub displayed_attributes: UpdateState<BTreeSet<String>>,
+    pub stop_words: UpdateState<BTreeSet<String>>,
+    pub synonyms: UpdateState<BTreeMap<String, Vec<String>>>,
+    pub attributes_for_faceting: UpdateState<Vec<String>>,
+}
+
+impl Default for SettingsUpdate {
+    fn default() -> Self {
+        Self {
+            ranking_rules: UpdateState::Nothing,
+            distinct_attribute: UpdateState::Nothing,
+            primary_key: UpdateState::Nothing,
+            searchable_attributes: UpdateState::Nothing,
+            displayed_attributes: UpdateState::Nothing,
+            stop_words: UpdateState::Nothing,
+            synonyms: UpdateState::Nothing,
+            attributes_for_faceting: UpdateState::Nothing,
+        }
+    }
+}

meilisearch-core/src/store/cow_set.rs

@@ -0,0 +1,32 @@
+use std::borrow::Cow;
+
+use heed::{types::CowSlice, BytesEncode, BytesDecode};
+use sdset::{Set, SetBuf};
+use zerocopy::{AsBytes, FromBytes};
+
+pub struct CowSet<T>(std::marker::PhantomData<T>);
+
+impl<'a, T: 'a> BytesEncode<'a> for CowSet<T>
+where
+    T: AsBytes,
+{
+    type EItem = Set<T>;
+
+    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<[u8]>> {
+        CowSlice::bytes_encode(item.as_slice())
+    }
+}
+
+impl<'a, T: 'a> BytesDecode<'a> for CowSet<T>
+where
+    T: FromBytes + Copy,
+{
+    type DItem = Cow<'a, Set<T>>;
+
+    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+        match CowSlice::<T>::bytes_decode(bytes)? {
+            Cow::Owned(vec) => Some(Cow::Owned(SetBuf::new_unchecked(vec))),
+            Cow::Borrowed(slice) => Some(Cow::Borrowed(Set::new_unchecked(slice))),
+        }
+    }
+}

meilisearch-core/src/store/docs_words.rs

@@ -1,49 +1,43 @@
-use super::BEU64;
-use crate::DocumentId;
-use heed::types::{ByteSlice, OwnedType};
+use std::borrow::Cow;
+
 use heed::Result as ZResult;
-use std::sync::Arc;
+use heed::types::{ByteSlice, OwnedType};
+
+use crate::database::MainT;
+use crate::{DocumentId, FstSetCow};
+use super::BEU32;
 
 #[derive(Copy, Clone)]
 pub struct DocsWords {
-    pub(crate) docs_words: heed::Database<OwnedType<BEU64>, ByteSlice>,
+    pub(crate) docs_words: heed::Database<OwnedType<BEU32>, ByteSlice>,
 }
 
 impl DocsWords {
     pub fn put_doc_words(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
-        words: &fst::Set,
+        words: &FstSetCow,
     ) -> ZResult<()> {
-        let document_id = BEU64::new(document_id.0);
+        let document_id = BEU32::new(document_id.0);
         let bytes = words.as_fst().as_bytes();
         self.docs_words.put(writer, &document_id, bytes)
     }
 
-    pub fn del_doc_words(self, writer: &mut heed::RwTxn, document_id: DocumentId) -> ZResult<bool> {
-        let document_id = BEU64::new(document_id.0);
+    pub fn del_doc_words(self, writer: &mut heed::RwTxn<MainT>, document_id: DocumentId) -> ZResult<bool> {
+        let document_id = BEU32::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,
-        document_id: DocumentId,
-    ) -> ZResult<Option<fst::Set>> {
-        let document_id = BEU64::new(document_id.0);
+    pub fn doc_words<'a>(self, reader: &'a heed::RoTxn<'a, MainT>, document_id: DocumentId) -> ZResult<FstSetCow> {
+        let document_id = BEU32::new(document_id.0);
         match self.docs_words.get(reader, &document_id)? {
-            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),
+            Some(bytes) => Ok(fst::Set::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Set::default().map_data(Cow::Owned).unwrap()),
         }
     }
 }

meilisearch-core/src/store/documents_fields.rs

@@ -1,75 +1,76 @@
 use heed::types::{ByteSlice, OwnedType};
+use crate::database::MainT;
 use heed::Result as ZResult;
-use meilisearch_schema::SchemaAttr;
+use meilisearch_schema::FieldId;
 
-use super::DocumentAttrKey;
+use super::DocumentFieldStoredKey;
 use crate::DocumentId;
 
 #[derive(Copy, Clone)]
 pub struct DocumentsFields {
-    pub(crate) documents_fields: heed::Database<OwnedType<DocumentAttrKey>, ByteSlice>,
+    pub(crate) documents_fields: heed::Database<OwnedType<DocumentFieldStoredKey>, ByteSlice>,
 }
 
 impl DocumentsFields {
     pub fn put_document_field(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         document_id: DocumentId,
-        attribute: SchemaAttr,
+        field: FieldId,
         value: &[u8],
     ) -> ZResult<()> {
-        let key = DocumentAttrKey::new(document_id, attribute);
+        let key = DocumentFieldStoredKey::new(document_id, field);
         self.documents_fields.put(writer, &key, value)
     }
 
     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());
-        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
+        let start = DocumentFieldStoredKey::new(document_id, FieldId::min());
+        let end = DocumentFieldStoredKey::new(document_id, FieldId::max());
         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,
+        field: FieldId,
     ) -> ZResult<Option<&'txn [u8]>> {
-        let key = DocumentAttrKey::new(document_id, attribute);
+        let key = DocumentFieldStoredKey::new(document_id, field);
         self.documents_fields.get(reader, &key)
     }
 
     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());
-        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
+        let start = DocumentFieldStoredKey::new(document_id, FieldId::min());
+        let end = DocumentFieldStoredKey::new(document_id, FieldId::max());
         let iter = self.documents_fields.range(reader, &(start..=end))?;
         Ok(DocumentFieldsIter { iter })
     }
 }
 
 pub struct DocumentFieldsIter<'txn> {
-    iter: heed::RoRange<'txn, OwnedType<DocumentAttrKey>, ByteSlice>,
+    iter: heed::RoRange<'txn, OwnedType<DocumentFieldStoredKey>, ByteSlice>,
 }
 
 impl<'txn> Iterator for DocumentFieldsIter<'txn> {
-    type Item = ZResult<(SchemaAttr, &'txn [u8])>;
+    type Item = ZResult<(FieldId, &'txn [u8])>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter.next() {
             Some(Ok((key, bytes))) => {
-                let attr = SchemaAttr(key.attr.get());
-                Some(Ok((attr, bytes)))
+                let field_id = FieldId(key.field_id.get());
+                Some(Ok((field_id, bytes)))
             }
             Some(Err(e)) => Some(Err(e)),
             None => None,

meilisearch-core/src/store/documents_fields_counts.rs

@@ -1,48 +1,49 @@
-use super::DocumentAttrKey;
+use super::DocumentFieldIndexedKey;
+use crate::database::MainT;
 use crate::DocumentId;
 use heed::types::OwnedType;
 use heed::Result as ZResult;
-use meilisearch_schema::SchemaAttr;
+use meilisearch_schema::IndexedPos;
+use crate::MResult;
 
 #[derive(Copy, Clone)]
 pub struct DocumentsFieldsCounts {
-    pub(crate) documents_fields_counts: heed::Database<OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+    pub(crate) documents_fields_counts: heed::Database<OwnedType<DocumentFieldIndexedKey>, OwnedType<u16>>,
 }
 
 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,
+        attribute: IndexedPos,
+        value: u16,
     ) -> ZResult<()> {
-        let key = DocumentAttrKey::new(document_id, attribute);
+        let key = DocumentFieldIndexedKey::new(document_id, attribute);
         self.documents_fields_counts.put(writer, &key, &value)
     }
 
     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());
-        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
-        self.documents_fields_counts
-            .delete_range(writer, &(start..=end))
+        let start = DocumentFieldIndexedKey::new(document_id, IndexedPos::min());
+        let end = DocumentFieldIndexedKey::new(document_id, IndexedPos::max());
+        self.documents_fields_counts.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>> {
-        let key = DocumentAttrKey::new(document_id, attribute);
+        attribute: IndexedPos,
+    ) -> ZResult<Option<u16>> {
+        let key = DocumentFieldIndexedKey::new(document_id, attribute);
         match self.documents_fields_counts.get(reader, &key)? {
             Some(count) => Ok(Some(count)),
             None => Ok(None),
@@ -51,16 +52,16 @@ 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());
-        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
+        let start = DocumentFieldIndexedKey::new(document_id, IndexedPos::min());
+        let end = DocumentFieldIndexedKey::new(document_id, IndexedPos::max());
         let iter = self.documents_fields_counts.range(reader, &(start..=end))?;
         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>) -> MResult<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 })
@@ -78,17 +79,17 @@ impl DocumentsFieldsCounts {
 }
 
 pub struct DocumentFieldsCountsIter<'txn> {
-    iter: heed::RoRange<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+    iter: heed::RoRange<'txn, OwnedType<DocumentFieldIndexedKey>, OwnedType<u16>>,
 }
 
 impl Iterator for DocumentFieldsCountsIter<'_> {
-    type Item = ZResult<(SchemaAttr, u64)>;
+    type Item = ZResult<(IndexedPos, u16)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter.next() {
             Some(Ok((key, count))) => {
-                let attr = SchemaAttr(key.attr.get());
-                Some(Ok((attr, count)))
+                let indexed_pos = IndexedPos(key.indexed_pos.get());
+                Some(Ok((indexed_pos, count)))
             }
             Some(Err(e)) => Some(Err(e)),
             None => None,
@@ -98,11 +99,11 @@ impl Iterator for DocumentFieldsCountsIter<'_> {
 
 pub struct DocumentsIdsIter<'txn> {
     last_seen_id: Option<DocumentId>,
-    iter: heed::RoIter<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+    iter: heed::RoIter<'txn, OwnedType<DocumentFieldIndexedKey>, OwnedType<u16>>,
 }
 
 impl Iterator for DocumentsIdsIter<'_> {
-    type Item = ZResult<DocumentId>;
+    type Item = MResult<DocumentId>;
 
     fn next(&mut self) -> Option<Self::Item> {
         for result in &mut self.iter {
@@ -114,7 +115,7 @@ impl Iterator for DocumentsIdsIter<'_> {
                         return Some(Ok(document_id));
                     }
                 }
-                Err(e) => return Some(Err(e)),
+                Err(e) => return Some(Err(e.into())),
             }
         }
         None
@@ -122,18 +123,18 @@ impl Iterator for DocumentsIdsIter<'_> {
 }
 
 pub struct AllDocumentsFieldsCountsIter<'txn> {
-    iter: heed::RoIter<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+    iter: heed::RoIter<'txn, OwnedType<DocumentFieldIndexedKey>, OwnedType<u16>>,
 }
 
 impl Iterator for AllDocumentsFieldsCountsIter<'_> {
-    type Item = ZResult<(DocumentId, SchemaAttr, u64)>;
+    type Item = ZResult<(DocumentId, IndexedPos, u16)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.iter.next() {
             Some(Ok((key, count))) => {
                 let docid = DocumentId(key.docid.get());
-                let attr = SchemaAttr(key.attr.get());
-                Some(Ok((docid, attr, count)))
+                let indexed_pos = IndexedPos(key.indexed_pos.get());
+                Some(Ok((docid, indexed_pos, count)))
             }
             Some(Err(e)) => Some(Err(e)),
             None => None,

meilisearch-core/src/store/documents_ids.rs

@@ -0,0 +1,75 @@
+use std::borrow::Cow;
+
+use heed::{BytesDecode, BytesEncode};
+use sdset::Set;
+
+use crate::DocumentId;
+use super::cow_set::CowSet;
+
+pub struct DocumentsIds;
+
+impl BytesEncode<'_> for DocumentsIds {
+    type EItem = Set<DocumentId>;
+
+    fn bytes_encode(item: &Self::EItem) -> Option<Cow<[u8]>> {
+        CowSet::bytes_encode(item)
+    }
+}
+
+impl<'a> BytesDecode<'a> for DocumentsIds {
+    type DItem = Cow<'a, Set<DocumentId>>;
+
+    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+        CowSet::bytes_decode(bytes)
+    }
+}
+
+pub struct DiscoverIds<'a> {
+    ids_iter: std::slice::Iter<'a, DocumentId>,
+    left_id: Option<u32>,
+    right_id: Option<u32>,
+    available_range: std::ops::Range<u32>,
+}
+
+impl DiscoverIds<'_> {
+    pub fn new(ids: &Set<DocumentId>) -> DiscoverIds {
+        let mut ids_iter = ids.iter();
+        let right_id = ids_iter.next().map(|id| id.0);
+        let available_range = 0..right_id.unwrap_or(u32::max_value());
+        DiscoverIds { ids_iter, left_id: None, right_id, available_range }
+    }
+}
+
+impl Iterator for DiscoverIds<'_> {
+    type Item = DocumentId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.available_range.next() {
+                // The available range gives us a new id, we return it.
+                Some(id) => return Some(DocumentId(id)),
+                // The available range is exhausted, we need to find the next one.
+                None if self.available_range.end == u32::max_value() => return None,
+                None => loop {
+                    self.left_id = self.right_id.take();
+                    self.right_id = self.ids_iter.next().map(|id| id.0);
+                    match (self.left_id, self.right_id) {
+                        // We found a gap in the used ids, we can yield all ids
+                        // until the end of the gap
+                        (Some(l), Some(r)) => if l.saturating_add(1) != r {
+                            self.available_range = (l + 1)..r;
+                            break;
+                        },
+                        // The last used id has been reached, we can use all ids
+                        // until u32 MAX
+                        (Some(l), None) => {
+                            self.available_range = l.saturating_add(1)..u32::max_value();
+                            break;
+                        },
+                        _ => (),
+                    }
+                },
+            }
+        }
+    }
+}

meilisearch-core/src/store/facets.rs

@@ -0,0 +1,97 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::mem;
+
+use heed::{RwTxn, RoTxn, RoPrefix, types::Str, BytesEncode, BytesDecode};
+use sdset::{SetBuf, Set, SetOperation};
+
+use meilisearch_types::DocumentId;
+use meilisearch_schema::FieldId;
+
+use crate::MResult;
+use crate::database::MainT;
+use crate::facets::FacetKey;
+use super::cow_set::CowSet;
+
+/// contains facet info
+#[derive(Clone, Copy)]
+pub struct Facets {
+    pub(crate) facets: heed::Database<FacetKey, FacetData>,
+}
+
+pub struct FacetData;
+
+impl<'a> BytesEncode<'a> for FacetData {
+    type EItem = (&'a str, &'a Set<DocumentId>);
+
+    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<'a, [u8]>> {
+        // get size of the first item
+        let first_size =  item.0.as_bytes().len();
+        let size = mem::size_of::<u64>()
+            + first_size
+            + item.1.len() * mem::size_of::<DocumentId>();
+        let mut buffer = Vec::with_capacity(size);
+        // encode the length of the first item
+        buffer.extend_from_slice(&first_size.to_be_bytes());
+        buffer.extend_from_slice(Str::bytes_encode(&item.0)?.as_ref());
+        let second_slice = CowSet::bytes_encode(&item.1)?;
+        buffer.extend_from_slice(second_slice.as_ref());
+        Some(Cow::Owned(buffer))
+    }
+}
+
+impl<'a> BytesDecode<'a> for FacetData {
+    type DItem = (&'a str, Cow<'a, Set<DocumentId>>);
+
+    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+        const LEN: usize = mem::size_of::<u64>();
+        let mut size_buf = [0; LEN];
+        size_buf.copy_from_slice(bytes.get(0..LEN)?);
+        // decode size of the first item from the bytes
+        let first_size = usize::from_be_bytes(size_buf);
+        // decode first and second items
+        let first_item = Str::bytes_decode(bytes.get(LEN..(LEN + first_size))?)?;
+        let second_item = CowSet::bytes_decode(bytes.get((LEN + first_size)..)?)?;
+        Some((first_item, second_item))
+    }
+}
+
+impl Facets {
+    // we use sdset::SetBuf to ensure the docids are sorted.
+    pub fn put_facet_document_ids(&self, writer: &mut RwTxn<MainT>, facet_key: FacetKey, doc_ids: &Set<DocumentId>, facet_value: &str) -> MResult<()> {
+        Ok(self.facets.put(writer, &facet_key, &(facet_value, doc_ids))?)
+    }
+
+    pub fn field_document_ids<'txn>(&self, reader: &'txn RoTxn<MainT>, field_id: FieldId) -> MResult<RoPrefix<'txn, FacetKey, FacetData>> {
+        Ok(self.facets.prefix_iter(reader, &FacetKey::new(field_id, String::new()))?)
+    }
+
+    pub fn facet_document_ids<'txn>(&self, reader: &'txn RoTxn<MainT>, facet_key: &FacetKey) -> MResult<Option<(&'txn str,Cow<'txn, Set<DocumentId>>)>> {
+        Ok(self.facets.get(reader, &facet_key)?)
+    }
+
+    /// updates the facets  store, revmoving the documents from the facets provided in the
+    /// `facet_map` argument
+    pub fn remove(&self, writer: &mut RwTxn<MainT>, facet_map: HashMap<FacetKey, (String, Vec<DocumentId>)>) -> MResult<()> {
+        for (key, (name, document_ids)) in facet_map {
+            if let Some((_, old)) = self.facets.get(writer, &key)? {
+                let to_remove = SetBuf::from_dirty(document_ids);
+                let new = sdset::duo::OpBuilder::new(old.as_ref(), to_remove.as_set()).difference().into_set_buf();
+                self.facets.put(writer, &key, &(&name, new.as_set()))?;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn add(&self, writer: &mut RwTxn<MainT>, facet_map: HashMap<FacetKey, (String, Vec<DocumentId>)>) -> MResult<()> {
+        for (key, (facet_name, document_ids)) in facet_map {
+            let set = SetBuf::from_dirty(document_ids);
+            self.put_facet_document_ids(writer, key, set.as_set(), &facet_name)?;
+        }
+        Ok(())
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
+        Ok(self.facets.clear(writer)?)
+    }
+}

meilisearch-core/src/store/main.rs

@@ -1,24 +1,37 @@
-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;
+use std::borrow::Cow;
+use std::collections::BTreeMap;
 
+use chrono::{DateTime, Utc};
+use heed::types::{ByteSlice, OwnedType, SerdeBincode, Str, CowSlice};
+use meilisearch_schema::{FieldId, Schema};
+use meilisearch_types::DocumentId;
+use sdset::Set;
+
+use crate::database::MainT;
+use crate::{RankedMap, MResult};
+use crate::settings::RankingRule;
+use crate::{FstSetCow, FstMapCow};
+use super::{CowSet, DocumentsIds};
+
+const ATTRIBUTES_FOR_FACETING_KEY: &str = "attributes-for-faceting";
 const CREATED_AT_KEY: &str = "created-at";
-const CUSTOMS_KEY: &str = "customs-key";
-const FIELDS_FREQUENCY_KEY: &str = "fields-frequency";
+const CUSTOMS_KEY: &str = "customs";
+const DISTINCT_ATTRIBUTE_KEY: &str = "distinct-attribute";
+const EXTERNAL_DOCIDS_KEY: &str = "external-docids";
+const FIELDS_DISTRIBUTION_KEY: &str = "fields-distribution";
+const INTERNAL_DOCIDS_KEY: &str = "internal-docids";
 const NAME_KEY: &str = "name";
 const NUMBER_OF_DOCUMENTS_KEY: &str = "number-of-documents";
 const RANKED_MAP_KEY: &str = "ranked-map";
+const RANKING_RULES_KEY: &str = "ranking-rules";
 const SCHEMA_KEY: &str = "schema";
+const SORTED_DOCUMENT_IDS_CACHE_KEY: &str = "sorted-document-ids-cache";
 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>;
+pub type FreqsMap = BTreeMap<String, usize>;
 type SerdeFreqsMap = SerdeBincode<FreqsMap>;
 type SerdeDatetime = SerdeBincode<DateTime<Utc>>;
 
@@ -28,156 +41,280 @@ pub struct Main {
 }
 
 impl Main {
-    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
-        self.main.clear(writer)
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
+        Ok(self.main.clear(writer)?)
     }
 
-    pub fn put_name(self, writer: &mut heed::RwTxn, name: &str) -> ZResult<()> {
-        self.main.put::<Str, Str>(writer, NAME_KEY, name)
+    pub fn put_name(self, writer: &mut heed::RwTxn<MainT>, name: &str) -> MResult<()> {
+        Ok(self.main.put::<_, Str, Str>(writer, NAME_KEY, name)?)
     }
 
-    pub fn name(self, reader: &heed::RoTxn) -> ZResult<Option<String>> {
+    pub fn name(self, reader: &heed::RoTxn<MainT>) -> MResult<Option<String>> {
         Ok(self
             .main
-            .get::<Str, Str>(reader, NAME_KEY)?
+            .get::<_, Str, Str>(reader, NAME_KEY)?
             .map(|name| name.to_owned()))
     }
 
-    pub fn put_created_at(self, writer: &mut heed::RwTxn) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeDatetime>(writer, CREATED_AT_KEY, &Utc::now())
+    pub fn put_created_at(self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeDatetime>(writer, CREATED_AT_KEY, &Utc::now())?)
     }
 
-    pub fn created_at(self, reader: &heed::RoTxn) -> ZResult<Option<DateTime<Utc>>> {
-        self.main.get::<Str, SerdeDatetime>(reader, CREATED_AT_KEY)
+    pub fn created_at(self, reader: &heed::RoTxn<MainT>) -> MResult<Option<DateTime<Utc>>> {
+        Ok(self.main.get::<_, Str, SerdeDatetime>(reader, CREATED_AT_KEY)?)
     }
 
-    pub fn put_updated_at(self, writer: &mut heed::RwTxn) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeDatetime>(writer, UPDATED_AT_KEY, &Utc::now())
+    pub fn put_updated_at(self, writer: &mut heed::RwTxn<MainT>) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeDatetime>(writer, UPDATED_AT_KEY, &Utc::now())?)
     }
 
-    pub fn updated_at(self, reader: &heed::RoTxn) -> ZResult<Option<DateTime<Utc>>> {
-        self.main.get::<Str, SerdeDatetime>(reader, UPDATED_AT_KEY)
+    pub fn updated_at(self, reader: &heed::RoTxn<MainT>) -> MResult<Option<DateTime<Utc>>> {
+        Ok(self.main.get::<_, Str, SerdeDatetime>(reader, UPDATED_AT_KEY)?)
     }
 
-    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 put_internal_docids(self, writer: &mut heed::RwTxn<MainT>, ids: &sdset::Set<DocumentId>) -> MResult<()> {
+        Ok(self.main.put::<_, Str, DocumentsIds>(writer, INTERNAL_DOCIDS_KEY, ids)?)
     }
 
-    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::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 internal_docids<'txn>(self, reader: &'txn heed::RoTxn<MainT>) -> MResult<Cow<'txn, sdset::Set<DocumentId>>> {
+        match self.main.get::<_, Str, DocumentsIds>(reader, INTERNAL_DOCIDS_KEY)? {
+            Some(ids) => Ok(ids),
+            None => Ok(Cow::default()),
         }
     }
 
-    pub fn put_schema(self, writer: &mut heed::RwTxn, schema: &Schema) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeBincode<Schema>>(writer, SCHEMA_KEY, schema)
+    pub fn merge_internal_docids(self, writer: &mut heed::RwTxn<MainT>, new_ids: &sdset::Set<DocumentId>) -> MResult<()> {
+        use sdset::SetOperation;
+
+        // We do an union of the old and new internal ids.
+        let internal_docids = self.internal_docids(writer)?;
+        let internal_docids = sdset::duo::Union::new(&internal_docids, new_ids).into_set_buf();
+        Ok(self.put_internal_docids(writer, &internal_docids)?)
     }
 
-    pub fn schema(self, reader: &heed::RoTxn) -> ZResult<Option<Schema>> {
-        self.main
-            .get::<Str, SerdeBincode<Schema>>(reader, SCHEMA_KEY)
+    pub fn remove_internal_docids(self, writer: &mut heed::RwTxn<MainT>, ids: &sdset::Set<DocumentId>) -> MResult<()> {
+        use sdset::SetOperation;
+
+        // We do a difference of the old and new internal ids.
+        let internal_docids = self.internal_docids(writer)?;
+        let internal_docids = sdset::duo::Difference::new(&internal_docids, ids).into_set_buf();
+        Ok(self.put_internal_docids(writer, &internal_docids)?)
     }
 
-    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 put_external_docids<A>(self, writer: &mut heed::RwTxn<MainT>, ids: &fst::Map<A>) -> MResult<()>
+    where A: AsRef<[u8]>,
+    {
+        Ok(self.main.put::<_, Str, ByteSlice>(writer, EXTERNAL_DOCIDS_KEY, ids.as_fst().as_bytes())?)
     }
 
-    pub fn ranked_map(self, reader: &heed::RoTxn) -> ZResult<Option<RankedMap>> {
-        self.main
-            .get::<Str, SerdeBincode<RankedMap>>(reader, RANKED_MAP_KEY)
+    pub fn merge_external_docids<A>(self, writer: &mut heed::RwTxn<MainT>, new_docids: &fst::Map<A>) -> MResult<()>
+    where A: AsRef<[u8]>,
+    {
+        use fst::{Streamer, IntoStreamer};
+
+        // Do an union of the old and the new set of external docids.
+        let external_docids = self.external_docids(writer)?;
+        let mut op = external_docids.op().add(new_docids.into_stream()).r#union();
+        let mut build = fst::MapBuilder::memory();
+        while let Some((docid, values)) = op.next() {
+            build.insert(docid, values[0].value).unwrap();
+        }
+        drop(op);
+
+        let external_docids = build.into_map();
+        Ok(self.put_external_docids(writer, &external_docids)?)
     }
 
-    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 remove_external_docids<A>(self, writer: &mut heed::RwTxn<MainT>, ids: &fst::Map<A>) -> MResult<()>
+    where A: AsRef<[u8]>,
+    {
+        use fst::{Streamer, IntoStreamer};
+
+        // Do an union of the old and the new set of external docids.
+        let external_docids = self.external_docids(writer)?;
+        let mut op = external_docids.op().add(ids.into_stream()).difference();
+        let mut build = fst::MapBuilder::memory();
+        while let Some((docid, values)) = op.next() {
+            build.insert(docid, values[0].value).unwrap();
+        }
+        drop(op);
+
+        let external_docids = build.into_map();
+        self.put_external_docids(writer, &external_docids)
     }
 
-    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::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 external_docids<'a>(self, reader: &'a heed::RoTxn<'a, MainT>) -> MResult<FstMapCow> {
+        match self.main.get::<_, Str, ByteSlice>(reader, EXTERNAL_DOCIDS_KEY)? {
+            Some(bytes) => Ok(fst::Map::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Map::default().map_data(Cow::Owned).unwrap()),
         }
     }
 
-    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 external_to_internal_docid(self, reader: &heed::RoTxn<MainT>, external_docid: &str) -> MResult<Option<DocumentId>> {
+        let external_ids = self.external_docids(reader)?;
+        Ok(external_ids.get(external_docid).map(|id| DocumentId(id as u32)))
     }
 
-    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::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 words_fst<'a>(self, reader: &'a heed::RoTxn<'a, MainT>) -> MResult<FstSetCow> {
+        match self.main.get::<_, Str, ByteSlice>(reader, WORDS_KEY)? {
+            Some(bytes) => Ok(fst::Set::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Set::default().map_data(Cow::Owned).unwrap()),
         }
     }
 
-    pub fn put_number_of_documents<F>(self, writer: &mut heed::RwTxn, f: F) -> ZResult<u64>
+    pub fn put_words_fst<A: AsRef<[u8]>>(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set<A>) -> MResult<()> {
+        Ok(self.main.put::<_, Str, ByteSlice>(writer, WORDS_KEY, fst.as_fst().as_bytes())?)
+    }
+
+    pub fn put_sorted_document_ids_cache(self, writer: &mut heed::RwTxn<MainT>, documents_ids: &[DocumentId]) -> MResult<()> {
+        Ok(self.main.put::<_, Str, CowSlice<DocumentId>>(writer, SORTED_DOCUMENT_IDS_CACHE_KEY, documents_ids)?)
+    }
+
+    pub fn sorted_document_ids_cache<'a>(self, reader: &'a heed::RoTxn<'a, MainT>) -> MResult<Option<Cow<[DocumentId]>>> {
+        Ok(self.main.get::<_, Str, CowSlice<DocumentId>>(reader, SORTED_DOCUMENT_IDS_CACHE_KEY)?)
+    }
+
+    pub fn put_schema(self, writer: &mut heed::RwTxn<MainT>, schema: &Schema) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeBincode<Schema>>(writer, SCHEMA_KEY, schema)?)
+    }
+
+    pub fn schema(self, reader: &heed::RoTxn<MainT>) -> MResult<Option<Schema>> {
+        Ok(self.main.get::<_, Str, SerdeBincode<Schema>>(reader, SCHEMA_KEY)?)
+    }
+
+    pub fn delete_schema(self, writer: &mut heed::RwTxn<MainT>) -> MResult<bool> {
+        Ok(self.main.delete::<_, Str>(writer, SCHEMA_KEY)?)
+    }
+
+    pub fn put_ranked_map(self, writer: &mut heed::RwTxn<MainT>, ranked_map: &RankedMap) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeBincode<RankedMap>>(writer, RANKED_MAP_KEY, &ranked_map)?)
+    }
+
+    pub fn ranked_map(self, reader: &heed::RoTxn<MainT>) -> MResult<Option<RankedMap>> {
+        Ok(self.main.get::<_, Str, SerdeBincode<RankedMap>>(reader, RANKED_MAP_KEY)?)
+    }
+
+    pub fn put_synonyms_fst<A: AsRef<[u8]>>(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set<A>) -> MResult<()> {
+        let bytes = fst.as_fst().as_bytes();
+        Ok(self.main.put::<_, Str, ByteSlice>(writer, SYNONYMS_KEY, bytes)?)
+    }
+
+    pub(crate) fn synonyms_fst<'a>(self, reader: &'a heed::RoTxn<'a, MainT>) -> MResult<FstSetCow> {
+        match self.main.get::<_, Str, ByteSlice>(reader, SYNONYMS_KEY)? {
+            Some(bytes) => Ok(fst::Set::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Set::default().map_data(Cow::Owned).unwrap()),
+        }
+    }
+
+    pub fn synonyms(self, reader: &heed::RoTxn<MainT>) -> MResult<Vec<String>> {
+        let synonyms = self
+            .synonyms_fst(&reader)?
+            .stream()
+            .into_strs()?;
+        Ok(synonyms)
+    }
+
+    pub fn put_stop_words_fst<A: AsRef<[u8]>>(self, writer: &mut heed::RwTxn<MainT>, fst: &fst::Set<A>) -> MResult<()> {
+        let bytes = fst.as_fst().as_bytes();
+        Ok(self.main.put::<_, Str, ByteSlice>(writer, STOP_WORDS_KEY, bytes)?)
+    }
+
+    pub(crate) fn stop_words_fst<'a>(self, reader: &'a heed::RoTxn<'a, MainT>) -> MResult<FstSetCow> {
+        match self.main.get::<_, Str, ByteSlice>(reader, STOP_WORDS_KEY)? {
+            Some(bytes) => Ok(fst::Set::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Set::default().map_data(Cow::Owned).unwrap()),
+        }
+    }
+
+    pub fn stop_words(self, reader: &heed::RoTxn<MainT>) -> MResult<Vec<String>> {
+        let stop_word_list = self
+            .stop_words_fst(reader)?
+            .stream()
+            .into_strs()?;
+        Ok(stop_word_list)
+    }
+
+    pub fn put_number_of_documents<F>(self, writer: &mut heed::RwTxn<MainT>, f: F) -> MResult<u64>
     where
         F: Fn(u64) -> u64,
     {
-        let new = self.number_of_documents(writer).map(f)?;
+        let new = self.number_of_documents(&*writer).map(f)?;
         self.main
-            .put::<Str, OwnedType<u64>>(writer, NUMBER_OF_DOCUMENTS_KEY, &new)?;
+            .put::<_, Str, OwnedType<u64>>(writer, NUMBER_OF_DOCUMENTS_KEY, &new)?;
         Ok(new)
     }
 
-    pub fn number_of_documents(self, reader: &heed::RoTxn) -> ZResult<u64> {
+    pub fn number_of_documents(self, reader: &heed::RoTxn<MainT>) -> MResult<u64> {
         match self
             .main
-            .get::<Str, OwnedType<u64>>(reader, NUMBER_OF_DOCUMENTS_KEY)?
-        {
+            .get::<_, Str, OwnedType<u64>>(reader, NUMBER_OF_DOCUMENTS_KEY)? {
             Some(value) => Ok(value),
             None => Ok(0),
         }
     }
 
-    pub fn put_fields_frequency(
+    pub fn put_fields_distribution(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         fields_frequency: &FreqsMap,
-    ) -> ZResult<()> {
-        self.main
-            .put::<Str, SerdeFreqsMap>(writer, FIELDS_FREQUENCY_KEY, fields_frequency)
+    ) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeFreqsMap>(writer, FIELDS_DISTRIBUTION_KEY, fields_frequency)?)
     }
 
-    pub fn fields_frequency(&self, reader: &heed::RoTxn) -> ZResult<Option<FreqsMap>> {
+    pub fn fields_distribution(&self, reader: &heed::RoTxn<MainT>) -> MResult<Option<FreqsMap>> {
         match self
             .main
-            .get::<Str, SerdeFreqsMap>(reader, FIELDS_FREQUENCY_KEY)?
+            .get::<_, Str, SerdeFreqsMap>(reader, FIELDS_DISTRIBUTION_KEY)?
         {
             Some(freqs) => Ok(Some(freqs)),
             None => Ok(None),
         }
     }
 
-    pub fn put_customs(self, writer: &mut heed::RwTxn, customs: &[u8]) -> ZResult<()> {
-        self.main
-            .put::<Str, ByteSlice>(writer, CUSTOMS_KEY, customs)
+    pub fn attributes_for_faceting<'txn>(&self, reader: &'txn heed::RoTxn<MainT>) -> MResult<Option<Cow<'txn, Set<FieldId>>>> {
+        Ok(self.main.get::<_, Str, CowSet<FieldId>>(reader, ATTRIBUTES_FOR_FACETING_KEY)?)
     }
 
-    pub fn customs<'txn>(self, reader: &'txn heed::RoTxn) -> ZResult<Option<&'txn [u8]>> {
-        self.main.get::<Str, ByteSlice>(reader, CUSTOMS_KEY)
+    pub fn put_attributes_for_faceting(self, writer: &mut heed::RwTxn<MainT>, attributes: &Set<FieldId>) -> MResult<()> {
+        Ok(self.main.put::<_, Str, CowSet<FieldId>>(writer, ATTRIBUTES_FOR_FACETING_KEY, attributes)?)
+    }
+
+    pub fn delete_attributes_for_faceting(self, writer: &mut heed::RwTxn<MainT>) -> MResult<bool> {
+        Ok(self.main.delete::<_, Str>(writer, ATTRIBUTES_FOR_FACETING_KEY)?)
+    }
+
+    pub fn ranking_rules(&self, reader: &heed::RoTxn<MainT>) -> MResult<Option<Vec<RankingRule>>> {
+        Ok(self.main.get::<_, Str, SerdeBincode<Vec<RankingRule>>>(reader, RANKING_RULES_KEY)?)
+    }
+
+    pub fn put_ranking_rules(self, writer: &mut heed::RwTxn<MainT>, value: &[RankingRule]) -> MResult<()> {
+        Ok(self.main.put::<_, Str, SerdeBincode<Vec<RankingRule>>>(writer, RANKING_RULES_KEY, &value.to_vec())?)
+    }
+
+    pub fn delete_ranking_rules(self, writer: &mut heed::RwTxn<MainT>) -> MResult<bool> {
+        Ok(self.main.delete::<_, Str>(writer, RANKING_RULES_KEY)?)
+    }
+
+    pub fn distinct_attribute(&self, reader: &heed::RoTxn<MainT>) -> MResult<Option<FieldId>> {
+        match self.main.get::<_, Str, OwnedType<u16>>(reader, DISTINCT_ATTRIBUTE_KEY)? {
+            Some(value) => Ok(Some(FieldId(value.to_owned()))),
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_distinct_attribute(self, writer: &mut heed::RwTxn<MainT>, value: FieldId) -> MResult<()> {
+        Ok(self.main.put::<_, Str, OwnedType<u16>>(writer, DISTINCT_ATTRIBUTE_KEY, &value.0)?)
+    }
+
+    pub fn delete_distinct_attribute(self, writer: &mut heed::RwTxn<MainT>) -> MResult<bool> {
+        Ok(self.main.delete::<_, Str>(writer, DISTINCT_ATTRIBUTE_KEY)?)
+    }
+
+    pub fn put_customs(self, writer: &mut heed::RwTxn<MainT>, customs: &[u8]) -> MResult<()> {
+        Ok(self.main.put::<_, Str, ByteSlice>(writer, CUSTOMS_KEY, customs)?)
+    }
+
+    pub fn customs<'txn>(self, reader: &'txn heed::RoTxn<MainT>) -> MResult<Option<&'txn [u8]>> {
+        Ok(self.main.get::<_, Str, ByteSlice>(reader, CUSTOMS_KEY)?)
     }
 }

meilisearch-core/src/store/mod.rs

@@ -1,54 +1,166 @@
+mod cow_set;
 mod docs_words;
+mod documents_ids;
 mod documents_fields;
 mod documents_fields_counts;
+mod facets;
 mod main;
 mod postings_lists;
+mod prefix_documents_cache;
+mod prefix_postings_lists_cache;
 mod synonyms;
 mod updates;
 mod updates_results;
 
+pub use self::cow_set::CowSet;
 pub use self::docs_words::DocsWords;
 pub use self::documents_fields::{DocumentFieldsIter, DocumentsFields};
-pub use self::documents_fields_counts::{
-    DocumentFieldsCountsIter, DocumentsFieldsCounts, DocumentsIdsIter,
-};
+pub use self::documents_fields_counts::{DocumentFieldsCountsIter, DocumentsFieldsCounts, DocumentsIdsIter};
+pub use self::documents_ids::{DocumentsIds, DiscoverIds};
+pub use self::facets::Facets;
 pub use self::main::Main;
 pub use self::postings_lists::PostingsLists;
+pub use self::prefix_documents_cache::PrefixDocumentsCache;
+pub use self::prefix_postings_lists_cache::PrefixPostingsListsCache;
 pub use self::synonyms::Synonyms;
 pub use self::updates::Updates;
 pub use self::updates_results::UpdatesResults;
 
+use std::borrow::Cow;
 use std::collections::HashSet;
+use std::convert::TryInto;
+use std::{mem, ptr};
 
-use heed::Result as ZResult;
-use meilisearch_schema::{Schema, SchemaAttr};
+use heed::{BytesEncode, BytesDecode};
+use meilisearch_schema::{IndexedPos, FieldId};
+use sdset::{Set, SetBuf};
 use serde::de::{self, Deserialize};
 use zerocopy::{AsBytes, FromBytes};
 
 use crate::criterion::Criteria;
+use crate::database::{MainT, UpdateT};
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
 use crate::serde::Deserializer;
-use crate::{query_builder::QueryBuilder, update, DocumentId, Error, MResult};
+use crate::settings::SettingsUpdate;
+use crate::{query_builder::QueryBuilder, update, DocIndex, DocumentId, Error, MResult};
 
+type BEU32 = zerocopy::U32<byteorder::BigEndian>;
 type BEU64 = zerocopy::U64<byteorder::BigEndian>;
-type BEU16 = zerocopy::U16<byteorder::BigEndian>;
+pub type BEU16 = zerocopy::U16<byteorder::BigEndian>;
 
 #[derive(Debug, Copy, Clone, AsBytes, FromBytes)]
 #[repr(C)]
-pub struct DocumentAttrKey {
-    docid: BEU64,
-    attr: BEU16,
+pub struct DocumentFieldIndexedKey {
+    docid: BEU32,
+    indexed_pos: BEU16,
 }
 
-impl DocumentAttrKey {
-    fn new(docid: DocumentId, attr: SchemaAttr) -> DocumentAttrKey {
-        DocumentAttrKey {
-            docid: BEU64::new(docid.0),
-            attr: BEU16::new(attr.0),
+impl DocumentFieldIndexedKey {
+    fn new(docid: DocumentId, indexed_pos: IndexedPos) -> DocumentFieldIndexedKey {
+        DocumentFieldIndexedKey {
+            docid: BEU32::new(docid.0),
+            indexed_pos: BEU16::new(indexed_pos.0),
         }
     }
 }
 
+#[derive(Debug, Copy, Clone, AsBytes, FromBytes)]
+#[repr(C)]
+pub struct DocumentFieldStoredKey {
+    docid: BEU32,
+    field_id: BEU16,
+}
+
+impl DocumentFieldStoredKey {
+    fn new(docid: DocumentId, field_id: FieldId) -> DocumentFieldStoredKey {
+        DocumentFieldStoredKey {
+            docid: BEU32::new(docid.0),
+            field_id: BEU16::new(field_id.0),
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct Postings<'a> {
+    pub docids: Cow<'a, Set<DocumentId>>,
+    pub matches: Cow<'a, Set<DocIndex>>,
+}
+
+pub struct PostingsCodec;
+
+impl<'a> BytesEncode<'a> for PostingsCodec {
+    type EItem = Postings<'a>;
+
+    fn bytes_encode(item: &'a Self::EItem) -> Option<Cow<'a, [u8]>> {
+        let u64_size = mem::size_of::<u64>();
+        let docids_size = item.docids.len() * mem::size_of::<DocumentId>();
+        let matches_size = item.matches.len() * mem::size_of::<DocIndex>();
+
+        let mut buffer = Vec::with_capacity(u64_size + docids_size + matches_size);
+
+        let docids_len = item.docids.len() as u64;
+        buffer.extend_from_slice(&docids_len.to_be_bytes());
+        buffer.extend_from_slice(item.docids.as_bytes());
+        buffer.extend_from_slice(item.matches.as_bytes());
+
+        Some(Cow::Owned(buffer))
+    }
+}
+
+fn aligned_to(bytes: &[u8], align: usize) -> bool {
+    (bytes as *const _ as *const () as usize) % align == 0
+}
+
+fn from_bytes_to_set<'a, T: 'a>(bytes: &'a [u8]) -> Option<Cow<'a, Set<T>>>
+where T: Clone + FromBytes
+{
+    match zerocopy::LayoutVerified::<_, [T]>::new_slice(bytes) {
+        Some(layout) => Some(Cow::Borrowed(Set::new_unchecked(layout.into_slice()))),
+        None => {
+            let len = bytes.len();
+            let elem_size = mem::size_of::<T>();
+
+            // ensure that it is the alignment that is wrong
+            // and the length is valid
+            if len % elem_size == 0 && !aligned_to(bytes, mem::align_of::<T>()) {
+                let elems = len / elem_size;
+                let mut vec = Vec::<T>::with_capacity(elems);
+
+                unsafe {
+                    let dst = vec.as_mut_ptr() as *mut u8;
+                    ptr::copy_nonoverlapping(bytes.as_ptr(), dst, len);
+                    vec.set_len(elems);
+                }
+
+                return Some(Cow::Owned(SetBuf::new_unchecked(vec)));
+            }
+
+            None
+        }
+    }
+}
+
+impl<'a> BytesDecode<'a> for PostingsCodec {
+    type DItem = Postings<'a>;
+
+    fn bytes_decode(bytes: &'a [u8]) -> Option<Self::DItem> {
+        let u64_size = mem::size_of::<u64>();
+        let docid_size = mem::size_of::<DocumentId>();
+
+        let (len_bytes, bytes) = bytes.split_at(u64_size);
+        let docids_len = len_bytes.try_into().ok().map(u64::from_be_bytes)? as usize;
+        let docids_size = docids_len * docid_size;
+
+        let docids_bytes = &bytes[..docids_size];
+        let matches_bytes = &bytes[docids_size..];
+
+        let docids = from_bytes_to_set(docids_bytes)?;
+        let matches = from_bytes_to_set(matches_bytes)?;
+
+        Some(Postings { docids, matches })
+    }
+}
+
 fn main_name(name: &str) -> String {
     format!("store-{}", name)
 }
@@ -73,6 +185,14 @@ fn docs_words_name(name: &str) -> String {
     format!("store-{}-docs-words", name)
 }
 
+fn prefix_documents_cache_name(name: &str) -> String {
+    format!("store-{}-prefix-documents-cache", name)
+}
+
+fn prefix_postings_lists_cache_name(name: &str) -> String {
+    format!("store-{}-prefix-postings-lists-cache", name)
+}
+
 fn updates_name(name: &str) -> String {
     format!("store-{}-updates", name)
 }
@@ -81,14 +201,21 @@ fn updates_results_name(name: &str) -> String {
     format!("store-{}-updates-results", name)
 }
 
+fn facets_name(name: &str) -> String {
+    format!("store-{}-facets", name)
+}
+
 #[derive(Clone)]
 pub struct Index {
     pub main: Main,
     pub postings_lists: PostingsLists,
     pub documents_fields: DocumentsFields,
     pub documents_fields_counts: DocumentsFieldsCounts,
+    pub facets: Facets,
     pub synonyms: Synonyms,
     pub docs_words: DocsWords,
+    pub prefix_documents_cache: PrefixDocumentsCache,
+    pub prefix_postings_lists_cache: PrefixPostingsListsCache,
 
     pub updates: Updates,
     pub updates_results: UpdatesResults,
@@ -98,7 +225,7 @@ pub struct Index {
 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>> {
@@ -106,10 +233,7 @@ impl Index {
         let schema = schema.ok_or(Error::SchemaMissing)?;
 
         let attributes = match attributes {
-            Some(attributes) => attributes
-                .iter()
-                .map(|name| schema.attribute(name))
-                .collect(),
+            Some(attributes) => Some(attributes.iter().filter_map(|name| schema.id(*name)).collect()),
             None => None,
         };
 
@@ -118,7 +242,7 @@ impl Index {
             reader,
             documents_fields: self.documents_fields,
             schema: &schema,
-            attributes: attributes.as_ref(),
+            fields: attributes.as_ref(),
         };
 
         Ok(Option::<T>::deserialize(&mut deserializer)?)
@@ -126,9 +250,9 @@ impl Index {
 
     pub fn document_attribute<T: de::DeserializeOwned>(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<MainT>,
         document_id: DocumentId,
-        attribute: SchemaAttr,
+        attribute: FieldId,
     ) -> MResult<Option<T>> {
         let bytes = self
             .documents_fields
@@ -139,14 +263,29 @@ impl Index {
         }
     }
 
-    pub fn schema_update(&self, writer: &mut heed::RwTxn, schema: Schema) -> MResult<u64> {
-        let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
-        update::push_schema_update(writer, self.updates, self.updates_results, schema)
+    pub fn document_attribute_bytes<'txn>(
+        &self,
+        reader: &'txn heed::RoTxn<MainT>,
+        document_id: DocumentId,
+        attribute: FieldId,
+    ) -> MResult<Option<&'txn [u8]>> {
+        let bytes = self
+            .documents_fields
+            .document_attribute(reader, document_id, attribute)?;
+        match bytes {
+            Some(bytes) => Ok(Some(bytes)),
+            None => Ok(None),
+        }
     }
 
-    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>) -> MResult<u64> {
         let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
-        update::push_customs_update(writer, self.updates, self.updates_results, customs)
+        Ok(update::push_customs_update(writer, self.updates, self.updates_results, customs)?)
+    }
+
+    pub fn settings_update(&self, writer: &mut heed::RwTxn<UpdateT>, update: SettingsUpdate) -> MResult<u64> {
+        let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
+        Ok(update::push_settings_update(writer, self.updates, self.updates_results, update)?)
     }
 
     pub fn documents_addition<D>(&self) -> update::DocumentsAddition<D> {
@@ -173,45 +312,13 @@ 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)
     }
 
-    pub fn synonyms_addition(&self) -> update::SynonymsAddition {
-        update::SynonymsAddition::new(
-            self.updates,
-            self.updates_results,
-            self.updates_notifier.clone(),
-        )
-    }
-
-    pub fn synonyms_deletion(&self) -> update::SynonymsDeletion {
-        update::SynonymsDeletion::new(
-            self.updates,
-            self.updates_results,
-            self.updates_notifier.clone(),
-        )
-    }
-
-    pub fn stop_words_addition(&self) -> update::StopWordsAddition {
-        update::StopWordsAddition::new(
-            self.updates,
-            self.updates_results,
-            self.updates_notifier.clone(),
-        )
-    }
-
-    pub fn stop_words_deletion(&self) -> update::StopWordsDeletion {
-        update::StopWordsDeletion::new(
-            self.updates,
-            self.updates_results,
-            self.updates_notifier.clone(),
-        )
-    }
-
-    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,31 +326,31 @@ impl Index {
 
     pub fn update_status(
         &self,
-        reader: &heed::RoTxn,
+        reader: &heed::RoTxn<UpdateT>,
         update_id: u64,
     ) -> 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 {
                 if let Some(update) = self.update_status(reader, id)? {
                     updates.push(update);
-                    last_update_result_id = id;
+                    last_update_result_id = id + 1;
                 }
             }
         }
 
         // 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 {
+        if let Some((last_id, _)) = self.updates.last_update(reader)? {
+            for id in last_update_result_id..=last_id {
                 if let Some(update) = self.update_status(reader, id)? {
                     updates.push(update);
                 }
@@ -254,30 +361,20 @@ impl Index {
     }
 
     pub fn query_builder(&self) -> QueryBuilder {
-        QueryBuilder::new(
-            self.main,
-            self.postings_lists,
-            self.documents_fields_counts,
-            self.synonyms,
-        )
+        QueryBuilder::new(self)
     }
 
-    pub fn query_builder_with_criteria<'c, 'f, 'd>(
-        &self,
+    pub fn query_builder_with_criteria<'c, 'f, 'd, 'i>(
+        &'i self,
         criteria: Criteria<'c>,
-    ) -> QueryBuilder<'c, 'f, 'd> {
-        QueryBuilder::with_criteria(
-            self.main,
-            self.postings_lists,
-            self.documents_fields_counts,
-            self.synonyms,
-            criteria,
-        )
+    ) -> QueryBuilder<'c, 'f, 'd, 'i> {
+        QueryBuilder::with_criteria(self, criteria)
     }
 }
 
 pub fn create(
     env: &heed::Env,
+    update_env: &heed::Env,
     name: &str,
     updates_notifier: UpdateEventsEmitter,
 ) -> MResult<Index> {
@@ -288,28 +385,36 @@ pub fn create(
     let documents_fields_counts_name = documents_fields_counts_name(name);
     let synonyms_name = synonyms_name(name);
     let docs_words_name = docs_words_name(name);
+    let prefix_documents_cache_name = prefix_documents_cache_name(name);
+    let prefix_postings_lists_cache_name = prefix_postings_lists_cache_name(name);
     let updates_name = updates_name(name);
     let updates_results_name = updates_results_name(name);
+    let facets_name = facets_name(name);
 
     // open all the stores
     let main = env.create_poly_database(Some(&main_name))?;
     let postings_lists = env.create_database(Some(&postings_lists_name))?;
     let documents_fields = env.create_database(Some(&documents_fields_name))?;
     let documents_fields_counts = env.create_database(Some(&documents_fields_counts_name))?;
+    let facets = env.create_database(Some(&facets_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 prefix_documents_cache = env.create_database(Some(&prefix_documents_cache_name))?;
+    let prefix_postings_lists_cache = env.create_database(Some(&prefix_postings_lists_cache_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 },
         postings_lists: PostingsLists { postings_lists },
         documents_fields: DocumentsFields { documents_fields },
-        documents_fields_counts: DocumentsFieldsCounts {
-            documents_fields_counts,
-        },
+        documents_fields_counts: DocumentsFieldsCounts { documents_fields_counts },
         synonyms: Synonyms { synonyms },
         docs_words: DocsWords { docs_words },
+        prefix_postings_lists_cache: PrefixPostingsListsCache { prefix_postings_lists_cache },
+        prefix_documents_cache: PrefixDocumentsCache { prefix_documents_cache },
+        facets: Facets { facets },
+
         updates: Updates { updates },
         updates_results: UpdatesResults { updates_results },
         updates_notifier,
@@ -318,6 +423,7 @@ pub fn create(
 
 pub fn open(
     env: &heed::Env,
+    update_env: &heed::Env,
     name: &str,
     updates_notifier: UpdateEventsEmitter,
 ) -> MResult<Option<Index>> {
@@ -328,6 +434,9 @@ pub fn open(
     let documents_fields_counts_name = documents_fields_counts_name(name);
     let synonyms_name = synonyms_name(name);
     let docs_words_name = docs_words_name(name);
+    let prefix_documents_cache_name = prefix_documents_cache_name(name);
+    let facets_name = facets_name(name);
+    let prefix_postings_lists_cache_name = prefix_postings_lists_cache_name(name);
     let updates_name = updates_name(name);
     let updates_results_name = updates_results_name(name);
 
@@ -356,11 +465,23 @@ pub fn open(
         Some(docs_words) => docs_words,
         None => return Ok(None),
     };
-    let updates = match env.open_database(Some(&updates_name))? {
+    let prefix_documents_cache = match env.open_database(Some(&prefix_documents_cache_name))? {
+        Some(prefix_documents_cache) => prefix_documents_cache,
+        None => return Ok(None),
+    };
+    let facets = match env.open_database(Some(&facets_name))? {
+        Some(facets) => facets,
+        None => return Ok(None),
+    };
+    let prefix_postings_lists_cache = match env.open_database(Some(&prefix_postings_lists_cache_name))? {
+        Some(prefix_postings_lists_cache) => prefix_postings_lists_cache,
+        None => return Ok(None),
+    };
+    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),
     };
@@ -369,18 +490,23 @@ pub fn open(
         main: Main { main },
         postings_lists: PostingsLists { postings_lists },
         documents_fields: DocumentsFields { documents_fields },
-        documents_fields_counts: DocumentsFieldsCounts {
-            documents_fields_counts,
-        },
+        documents_fields_counts: DocumentsFieldsCounts { documents_fields_counts },
         synonyms: Synonyms { synonyms },
         docs_words: DocsWords { docs_words },
+        prefix_documents_cache: PrefixDocumentsCache { prefix_documents_cache },
+        facets: Facets { facets },
+        prefix_postings_lists_cache: PrefixPostingsListsCache { prefix_postings_lists_cache },
         updates: Updates { updates },
         updates_results: UpdatesResults { updates_results },
         updates_notifier,
     }))
 }
 
-pub fn clear(writer: &mut heed::RwTxn, index: &Index) -> MResult<()> {
+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)?;
@@ -388,7 +514,9 @@ 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.prefix_documents_cache.clear(writer)?;
+    index.prefix_postings_lists_cache.clear(writer)?;
+    index.updates.clear(update_writer)?;
+    index.updates_results.clear(update_writer)?;
     Ok(())
 }

meilisearch-core/src/store/postings_lists.rs

@@ -1,41 +1,47 @@
-use crate::DocIndex;
-use heed::types::{ByteSlice, CowSlice};
-use heed::Result as ZResult;
-use sdset::{Set, SetBuf};
 use std::borrow::Cow;
 
+use heed::Result as ZResult;
+use heed::types::ByteSlice;
+use sdset::{Set, SetBuf};
+use slice_group_by::GroupBy;
+
+use crate::database::MainT;
+use crate::DocIndex;
+use crate::store::{Postings, PostingsCodec};
+
 #[derive(Copy, Clone)]
 pub struct PostingsLists {
-    pub(crate) postings_lists: heed::Database<ByteSlice, CowSlice<DocIndex>>,
+    pub(crate) postings_lists: heed::Database<ByteSlice, PostingsCodec>,
 }
 
 impl PostingsLists {
     pub fn put_postings_list(
         self,
-        writer: &mut heed::RwTxn,
+        writer: &mut heed::RwTxn<MainT>,
         word: &[u8],
-        words_indexes: &Set<DocIndex>,
+        matches: &Set<DocIndex>,
     ) -> ZResult<()> {
-        self.postings_lists.put(writer, word, words_indexes)
+        let docids = matches.linear_group_by_key(|m| m.document_id).map(|g| g[0].document_id).collect();
+        let docids = Cow::Owned(SetBuf::new_unchecked(docids));
+        let matches = Cow::Borrowed(matches);
+        let postings = Postings { docids, matches };
+
+        self.postings_lists.put(writer, word, &postings)
     }
 
-    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)? {
-            Some(Cow::Borrowed(slice)) => Ok(Some(Cow::Borrowed(Set::new_unchecked(slice)))),
-            Some(Cow::Owned(vec)) => Ok(Some(Cow::Owned(SetBuf::new_unchecked(vec)))),
-            None => Ok(None),
-        }
+    ) -> ZResult<Option<Postings<'txn>>> {
+        self.postings_lists.get(reader, word)
     }
 }

meilisearch-core/src/store/prefix_documents_cache.rs

@@ -0,0 +1,80 @@
+use std::borrow::Cow;
+
+use heed::types::{OwnedType, CowSlice};
+use heed::Result as ZResult;
+use zerocopy::{AsBytes, FromBytes};
+
+use super::{BEU64, BEU32};
+use crate::{DocumentId, Highlight};
+use crate::database::MainT;
+
+#[derive(Debug, Copy, Clone, AsBytes, FromBytes)]
+#[repr(C)]
+pub struct PrefixKey {
+    prefix: [u8; 4],
+    index: BEU64,
+    docid: BEU32,
+}
+
+impl PrefixKey {
+    pub fn new(prefix: [u8; 4], index: u64, docid: u32) -> PrefixKey {
+        PrefixKey {
+            prefix,
+            index: BEU64::new(index),
+            docid: BEU32::new(docid),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct PrefixDocumentsCache {
+    pub(crate) prefix_documents_cache: heed::Database<OwnedType<PrefixKey>, CowSlice<Highlight>>,
+}
+
+impl PrefixDocumentsCache {
+    pub fn put_prefix_document(
+        self,
+        writer: &mut heed::RwTxn<MainT>,
+        prefix: [u8; 4],
+        index: usize,
+        docid: DocumentId,
+        highlights: &[Highlight],
+    ) -> ZResult<()> {
+        let key = PrefixKey::new(prefix, index as u64, docid.0);
+        self.prefix_documents_cache.put(writer, &key, highlights)
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
+        self.prefix_documents_cache.clear(writer)
+    }
+
+    pub fn prefix_documents<'txn>(
+        self,
+        reader: &'txn heed::RoTxn<MainT>,
+        prefix: [u8; 4],
+    ) -> ZResult<PrefixDocumentsIter<'txn>> {
+        let start = PrefixKey::new(prefix, 0, 0);
+        let end = PrefixKey::new(prefix, u64::max_value(), u32::max_value());
+        let iter = self.prefix_documents_cache.range(reader, &(start..=end))?;
+        Ok(PrefixDocumentsIter { iter })
+    }
+}
+
+pub struct PrefixDocumentsIter<'txn> {
+    iter: heed::RoRange<'txn, OwnedType<PrefixKey>, CowSlice<Highlight>>,
+}
+
+impl<'txn> Iterator for PrefixDocumentsIter<'txn> {
+    type Item = ZResult<(DocumentId, Cow<'txn, [Highlight]>)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.iter.next() {
+            Some(Ok((key, highlights))) => {
+                let docid = DocumentId(key.docid.get());
+                Some(Ok((docid, highlights)))
+            }
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}

meilisearch-core/src/store/prefix_postings_lists_cache.rs

@@ -0,0 +1,45 @@
+use std::borrow::Cow;
+
+use heed::Result as ZResult;
+use heed::types::OwnedType;
+use sdset::{Set, SetBuf};
+use slice_group_by::GroupBy;
+
+use crate::database::MainT;
+use crate::DocIndex;
+use crate::store::{PostingsCodec, Postings};
+
+#[derive(Copy, Clone)]
+pub struct PrefixPostingsListsCache {
+    pub(crate) prefix_postings_lists_cache: heed::Database<OwnedType<[u8; 4]>, PostingsCodec>,
+}
+
+impl PrefixPostingsListsCache {
+    pub fn put_prefix_postings_list(
+        self,
+        writer: &mut heed::RwTxn<MainT>,
+        prefix: [u8; 4],
+        matches: &Set<DocIndex>,
+    ) -> ZResult<()>
+    {
+        let docids = matches.linear_group_by_key(|m| m.document_id).map(|g| g[0].document_id).collect();
+        let docids = Cow::Owned(SetBuf::new_unchecked(docids));
+        let matches = Cow::Borrowed(matches);
+        let postings = Postings { docids, matches };
+
+        self.prefix_postings_lists_cache.put(writer, &prefix, &postings)
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn<MainT>) -> ZResult<()> {
+        self.prefix_postings_lists_cache.clear(writer)
+    }
+
+    pub fn prefix_postings_list<'txn>(
+        self,
+        reader: &'txn heed::RoTxn<MainT>,
+        prefix: [u8; 4],
+    ) -> ZResult<Option<Postings<'txn>>>
+    {
+        self.prefix_postings_lists_cache.get(reader, &prefix)
+    }
+}

meilisearch-core/src/store/synonyms.rs

@@ -1,6 +1,10 @@
-use heed::types::ByteSlice;
+use std::borrow::Cow;
+
 use heed::Result as ZResult;
-use std::sync::Arc;
+use heed::types::ByteSlice;
+
+use crate::database::MainT;
+use crate::{FstSetCow, MResult};
 
 #[derive(Copy, Clone)]
 pub struct Synonyms {
@@ -8,33 +12,33 @@ pub struct Synonyms {
 }
 
 impl Synonyms {
-    pub fn put_synonyms(
-        self,
-        writer: &mut heed::RwTxn,
-        word: &[u8],
-        synonyms: &fst::Set,
-    ) -> ZResult<()> {
+    pub fn put_synonyms<A>(self, writer: &mut heed::RwTxn<MainT>, word: &[u8], synonyms: &fst::Set<A>) -> ZResult<()>
+    where A: AsRef<[u8]>,
+    {
         let bytes = synonyms.as_fst().as_bytes();
         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(crate) fn synonyms_fst<'txn>(self, reader: &'txn heed::RoTxn<MainT>, word: &[u8]) -> ZResult<FstSetCow<'txn>> {
         match self.synonyms.get(reader, word)? {
-            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),
+            Some(bytes) => Ok(fst::Set::new(bytes).unwrap().map_data(Cow::Borrowed).unwrap()),
+            None => Ok(fst::Set::default().map_data(Cow::Owned).unwrap()),
         }
     }
+
+    pub fn synonyms(self, reader: &heed::RoTxn<MainT>, word: &[u8]) -> MResult<Vec<String>> {
+        let synonyms = self
+            .synonyms_fst(&reader, word)?
+            .stream()
+            .into_strs()?;
+        Ok(synonyms)
+    }
 }

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,4 +1,5 @@
 use super::BEU64;
+use crate::database::UpdateT;
 use crate::update::ProcessedUpdateResult;
 use heed::types::{OwnedType, SerdeJson};
 use heed::Result as ZResult;
@@ -9,9 +10,9 @@ pub struct UpdatesResults {
 }
 
 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))),
@@ -21,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<()> {
@@ -31,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,27 +1,30 @@
+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,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
 ) -> MResult<()> {
-    main_store.put_words_fst(writer, &fst::Set::default())?;
-    main_store.put_ranked_map(writer, &RankedMap::default())?;
-    main_store.put_number_of_documents(writer, |_| 0)?;
-    documents_fields_store.clear(writer)?;
-    documents_fields_counts_store.clear(writer)?;
-    postings_lists_store.clear(writer)?;
-    docs_words_store.clear(writer)?;
+    index.main.put_words_fst(writer, &fst::Set::default())?;
+    index.main.put_external_docids(writer, &fst::Map::default())?;
+    index.main.put_internal_docids(writer, &sdset::SetBuf::default())?;
+    index.main.put_ranked_map(writer, &RankedMap::default())?;
+    index.main.put_number_of_documents(writer, |_| 0)?;
+    index.main.put_sorted_document_ids_cache(writer, &[])?;
+    index.documents_fields.clear(writer)?;
+    index.documents_fields_counts.clear(writer)?;
+    index.postings_lists.clear(writer)?;
+    index.docs_words.clear(writer)?;
+    index.prefix_documents_cache.clear(writer)?;
+    index.prefix_postings_lists_cache.clear(writer)?;
+    index.facets.clear(writer)?;
 
     Ok(())
 }
 
 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> {

meilisearch-core/src/update/customs_update.rs

@@ -1,21 +1,22 @@
-use crate::store;
+
+use crate::database::{MainT, UpdateT};
+use crate::{store, MResult};
 use crate::update::{next_update_id, Update};
-use heed::Result as ZResult;
 
 pub fn apply_customs_update(
-    writer: &mut heed::RwTxn,
+    writer: &mut heed::RwTxn<MainT>,
     main_store: store::Main,
     customs: &[u8],
-) -> ZResult<()> {
+) -> MResult<()> {
     main_store.put_customs(writer, customs)
 }
 
 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> {
+) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
     let update = Update::customs(customs);

meilisearch-core/src/update/documents_addition.rs

@@ -1,20 +1,30 @@
-use std::collections::HashMap;
+use std::borrow::Cow;
+use std::collections::{HashMap, BTreeMap};
 
 use fst::{set::OpBuilder, SetBuilder};
+use indexmap::IndexMap;
+use meilisearch_schema::{Schema, FieldId};
+use meilisearch_types::DocumentId;
 use sdset::{duo::Union, SetOperation};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use serde_json::Value;
 
+use crate::database::{MainT, UpdateT};
 use crate::database::{UpdateEvent, UpdateEventsEmitter};
+use crate::facets;
 use crate::raw_indexer::RawIndexer;
-use crate::serde::{extract_document_id, serialize_value, Deserializer, Serializer};
-use crate::store;
-use crate::update::{apply_documents_deletion, next_update_id, Update};
+use crate::serde::Deserializer;
+use crate::store::{self, DocumentsFields, DocumentsFieldsCounts, DiscoverIds};
+use crate::update::helpers::{index_value, value_to_number, extract_document_id};
+use crate::update::{apply_documents_deletion, compute_short_prefixes, next_update_id, Update};
 use crate::{Error, MResult, RankedMap};
 
 pub struct DocumentsAddition<D> {
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     updates_notifier: UpdateEventsEmitter,
+    // Whether the user explicitly set the primary key in the update
+    primary_key: Option<String>,
     documents: Vec<D>,
     is_partial: bool,
 }
@@ -31,6 +41,7 @@ impl<D> DocumentsAddition<D> {
             updates_notifier,
             documents: Vec::new(),
             is_partial: false,
+            primary_key: None,
         }
     }
 
@@ -45,14 +56,19 @@ impl<D> DocumentsAddition<D> {
             updates_notifier,
             documents: Vec::new(),
             is_partial: true,
+            primary_key: None,
         }
     }
 
+    pub fn set_primary_key(&mut self, primary_key: String) {
+        self.primary_key = Some(primary_key);
+    }
+
     pub fn update_document(&mut self, document: 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,
     {
@@ -63,6 +79,7 @@ impl<D> DocumentsAddition<D> {
             self.updates_results_store,
             self.documents,
             self.is_partial,
+            self.primary_key,
         )?;
         Ok(update_id)
     }
@@ -75,11 +92,12 @@ 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>,
     is_partial: bool,
+    primary_key: Option<String>,
 ) -> MResult<u64> {
     let mut values = Vec::with_capacity(addition.len());
     for add in addition {
@@ -91,9 +109,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::documents_partial(values)
+        Update::documents_partial(primary_key, values)
     } else {
-        Update::documents_addition(values)
+        Update::documents_addition(primary_key, values)
     };
 
     updates_store.put_update(writer, last_update_id, &update)?;
@@ -101,190 +119,196 @@ pub fn push_documents_addition<D: serde::Serialize>(
     Ok(last_update_id)
 }
 
-pub fn apply_documents_addition<'a, 'b>(
-    writer: &'a mut heed::RwTxn<'b>,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
-    addition: Vec<HashMap<String, serde_json::Value>>,
-) -> MResult<()> {
-    let mut documents_additions = HashMap::new();
+#[allow(clippy::too_many_arguments)]
+fn index_document<A: AsRef<[u8]>>(
+    writer: &mut heed::RwTxn<MainT>,
+    documents_fields: DocumentsFields,
+    documents_fields_counts: DocumentsFieldsCounts,
+    ranked_map: &mut RankedMap,
+    indexer: &mut RawIndexer<A>,
+    schema: &Schema,
+    field_id: FieldId,
+    document_id: DocumentId,
+    value: &Value,
+) -> MResult<()>
+{
+    let serialized = serde_json::to_vec(value)?;
+    documents_fields.put_document_field(writer, document_id, field_id, &serialized)?;
 
-    let schema = match main_store.schema(writer)? {
-        Some(schema) => schema,
-        None => return Err(Error::SchemaMissing),
-    };
-
-    let identifier = schema.identifier_name();
-
-    // 1. store documents ids for future deletion
-    for document in addition {
-        let document_id = match extract_document_id(identifier, &document)? {
-            Some(id) => id,
-            None => return Err(Error::MissingDocumentId),
-        };
-
-        documents_additions.insert(document_id, document);
+    if let Some(indexed_pos) = schema.is_searchable(field_id) {
+        let number_of_words = index_value(indexer, document_id, indexed_pos, value);
+        if let Some(number_of_words) = number_of_words {
+            documents_fields_counts.put_document_field_count(
+                writer,
+                document_id,
+                indexed_pos,
+                number_of_words as u16,
+            )?;
+        }
     }
 
-    // 2. remove the documents posting lists
-    let number_of_inserted_documents = documents_additions.len();
-    let documents_ids = documents_additions.iter().map(|(id, _)| *id).collect();
-    apply_documents_deletion(
-        writer,
-        main_store,
-        documents_fields_store,
-        documents_fields_counts_store,
-        postings_lists_store,
-        docs_words_store,
-        documents_ids,
-    )?;
-
-    let mut ranked_map = match main_store.ranked_map(writer)? {
-        Some(ranked_map) => ranked_map,
-        None => RankedMap::default(),
-    };
-
-    let stop_words = match main_store.stop_words_fst(writer)? {
-        Some(stop_words) => stop_words,
-        None => fst::Set::default(),
-    };
-
-    // 3. index the documents fields in the stores
-    let mut indexer = RawIndexer::new(stop_words);
-
-    for (document_id, document) in documents_additions {
-        let serializer = Serializer {
-            txn: writer,
-            schema: &schema,
-            document_store: documents_fields_store,
-            document_fields_counts: documents_fields_counts_store,
-            indexer: &mut indexer,
-            ranked_map: &mut ranked_map,
-            document_id,
-        };
-
-        document.serialize(serializer)?;
+    if schema.is_ranked(field_id) {
+        let number = value_to_number(value).unwrap_or_default();
+        ranked_map.insert(document_id, field_id, number);
     }
 
-    write_documents_addition_index(
-        writer,
-        main_store,
-        postings_lists_store,
-        docs_words_store,
-        &ranked_map,
-        number_of_inserted_documents,
-        indexer,
-    )
+    Ok(())
 }
 
-pub fn apply_documents_partial_addition<'a, 'b>(
-    writer: &'a mut heed::RwTxn<'b>,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
-    addition: Vec<HashMap<String, serde_json::Value>>,
-) -> MResult<()> {
-    let mut documents_additions = HashMap::new();
-
-    let schema = match main_store.schema(writer)? {
+pub fn apply_addition(
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
+    new_documents: Vec<IndexMap<String, Value>>,
+    partial: bool,
+    primary_key: Option<String>,
+) -> MResult<()>
+{
+    let mut schema = match index.main.schema(writer)? {
         Some(schema) => schema,
         None => return Err(Error::SchemaMissing),
     };
 
-    let identifier = schema.identifier_name();
+    // Retrieve the documents ids related structures
+    let external_docids = index.main.external_docids(writer)?;
+    let internal_docids = index.main.internal_docids(writer)?;
+    let mut available_ids = DiscoverIds::new(&internal_docids);
+
+    let primary_key = match schema.primary_key() {
+        Some(primary_key) => primary_key.to_string(),
+        None => {
+            let name = primary_key.ok_or(Error::MissingPrimaryKey)?;
+            schema.set_primary_key(&name)?;
+            name
+        }
+    };
 
     // 1. store documents ids for future deletion
-    for mut document in addition {
-        let document_id = match extract_document_id(identifier, &document)? {
-            Some(id) => id,
-            None => return Err(Error::MissingDocumentId),
+    let mut documents_additions = HashMap::new();
+    let mut new_external_docids = BTreeMap::new();
+    let mut new_internal_docids = Vec::with_capacity(new_documents.len());
+
+    for mut document in new_documents {
+        let external_docids_get = |docid: &str| {
+            match (external_docids.get(docid), new_external_docids.get(docid)) {
+                (_, Some(&id))
+                | (Some(id), _) => Some(id as u32),
+                (None, None) => None,
+            }
         };
 
-        let mut deserializer = Deserializer {
-            document_id,
-            reader: writer,
-            documents_fields: documents_fields_store,
-            schema: &schema,
-            attributes: None,
-        };
+        let (internal_docid, external_docid) =
+            extract_document_id(
+                &primary_key,
+                &document,
+                &external_docids_get,
+                &mut available_ids,
+            )?;
 
-        // retrieve the old document and
-        // update the new one with missing keys found in the old one
-        let result = Option::<HashMap<String, serde_json::Value>>::deserialize(&mut deserializer)?;
-        if let Some(old_document) = result {
-            for (key, value) in old_document {
-                document.entry(key).or_insert(value);
+        new_external_docids.insert(external_docid, internal_docid.0 as u64);
+        new_internal_docids.push(internal_docid);
+
+        if partial {
+            let mut deserializer = Deserializer {
+                document_id: internal_docid,
+                reader: writer,
+                documents_fields: index.documents_fields,
+                schema: &schema,
+                fields: None,
+            };
+
+            let old_document = Option::<HashMap<String, Value>>::deserialize(&mut deserializer)?;
+            if let Some(old_document) = old_document {
+                for (key, value) in old_document {
+                    document.entry(key).or_insert(value);
+                }
             }
         }
-
-        documents_additions.insert(document_id, document);
+        documents_additions.insert(internal_docid, document);
     }
 
-    // 2. remove the documents posting lists
+    // 2. remove the documents postings lists
     let number_of_inserted_documents = documents_additions.len();
-    let documents_ids = documents_additions.iter().map(|(id, _)| *id).collect();
-    apply_documents_deletion(
-        writer,
-        main_store,
-        documents_fields_store,
-        documents_fields_counts_store,
-        postings_lists_store,
-        docs_words_store,
-        documents_ids,
-    )?;
+    let documents_ids = new_external_docids.iter().map(|(id, _)| id.clone()).collect();
+    apply_documents_deletion(writer, index, documents_ids)?;
 
-    let mut ranked_map = match main_store.ranked_map(writer)? {
+    let mut ranked_map = match index.main.ranked_map(writer)? {
         Some(ranked_map) => ranked_map,
         None => RankedMap::default(),
     };
 
-    let stop_words = match main_store.stop_words_fst(writer)? {
-        Some(stop_words) => stop_words,
-        None => fst::Set::default(),
-    };
+    let stop_words = index.main.stop_words_fst(writer)?.map_data(Cow::into_owned)?;
 
-    // 3. index the documents fields in the stores
-    let mut indexer = RawIndexer::new(stop_words);
 
-    for (document_id, document) in documents_additions {
-        let serializer = Serializer {
-            txn: writer,
-            schema: &schema,
-            document_store: documents_fields_store,
-            document_fields_counts: documents_fields_counts_store,
-            indexer: &mut indexer,
-            ranked_map: &mut ranked_map,
-            document_id,
-        };
+    let mut indexer = RawIndexer::new(&stop_words);
 
-        document.serialize(serializer)?;
+    // For each document in this update
+    for (document_id, document) in &documents_additions {
+        // For each key-value pair in the document.
+        for (attribute, value) in document {
+            let (field_id, _) = schema.insert_with_position(&attribute)?;
+            index_document(
+                writer,
+                index.documents_fields,
+                index.documents_fields_counts,
+                &mut ranked_map,
+                &mut indexer,
+                &schema,
+                field_id,
+                *document_id,
+                &value,
+            )?;
+        }
     }
 
     write_documents_addition_index(
         writer,
-        main_store,
-        postings_lists_store,
-        docs_words_store,
+        index,
         &ranked_map,
         number_of_inserted_documents,
         indexer,
-    )
+    )?;
+
+    index.main.put_schema(writer, &schema)?;
+
+    let new_external_docids = fst::Map::from_iter(new_external_docids.iter().map(|(ext, id)| (ext, *id as u64)))?;
+    let new_internal_docids = sdset::SetBuf::from_dirty(new_internal_docids);
+    index.main.merge_external_docids(writer, &new_external_docids)?;
+    index.main.merge_internal_docids(writer, &new_internal_docids)?;
+
+    // recompute all facet attributes after document update.
+    if let Some(attributes_for_facetting) = index.main.attributes_for_faceting(writer)? {
+        let docids = index.main.internal_docids(writer)?;
+        let facet_map = facets::facet_map_from_docids(writer, index, &docids, attributes_for_facetting.as_ref())?;
+        index.facets.add(writer, facet_map)?;
+    }
+
+    // update is finished; update sorted document id cache with new state
+    let mut document_ids = index.main.internal_docids(writer)?.to_vec();
+    super::cache_document_ids_sorted(writer, &ranked_map, index, &mut document_ids)?;
+
+    Ok(())
 }
 
-pub fn reindex_all_documents(
-    writer: &mut heed::RwTxn,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
+pub fn apply_documents_partial_addition(
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
+    new_documents: Vec<IndexMap<String, Value>>,
+    primary_key: Option<String>,
 ) -> MResult<()> {
-    let schema = match main_store.schema(writer)? {
+    apply_addition(writer, index, new_documents, true, primary_key)
+}
+
+pub fn apply_documents_addition(
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
+    new_documents: Vec<IndexMap<String, Value>>,
+    primary_key: Option<String>,
+) -> MResult<()> {
+    apply_addition(writer, index, new_documents, false, primary_key)
+}
+
+pub fn reindex_all_documents(writer: &mut heed::RwTxn<MainT>, index: &store::Index) -> MResult<()> {
+    let schema = match index.main.schema(writer)? {
         Some(schema) => schema,
         None => return Err(Error::SchemaMissing),
     };
@@ -293,118 +317,128 @@ pub fn reindex_all_documents(
 
     // 1. retrieve all documents ids
     let mut documents_ids_to_reindex = Vec::new();
-    for result in documents_fields_counts_store.documents_ids(writer)? {
+    for result in index.documents_fields_counts.documents_ids(writer)? {
         let document_id = result?;
         documents_ids_to_reindex.push(document_id);
     }
 
     // 2. remove the documents posting lists
-    main_store.put_words_fst(writer, &fst::Set::default())?;
-    main_store.put_ranked_map(writer, &ranked_map)?;
-    main_store.put_number_of_documents(writer, |_| 0)?;
-    postings_lists_store.clear(writer)?;
-    docs_words_store.clear(writer)?;
+    index.main.put_words_fst(writer, &fst::Set::default())?;
+    index.main.put_ranked_map(writer, &ranked_map)?;
+    index.main.put_number_of_documents(writer, |_| 0)?;
+    index.facets.clear(writer)?;
+    index.postings_lists.clear(writer)?;
+    index.docs_words.clear(writer)?;
 
-    // 3. re-index chunks of documents (otherwise we make the borrow checker unhappy)
-    for documents_ids in documents_ids_to_reindex.chunks(100) {
-        let stop_words = match main_store.stop_words_fst(writer)? {
-            Some(stop_words) => stop_words,
-            None => fst::Set::default(),
-        };
+    let stop_words = index.main
+        .stop_words_fst(writer)?
+        .map_data(Cow::into_owned)
+        .unwrap();
 
-        let number_of_inserted_documents = documents_ids.len();
-        let mut indexer = RawIndexer::new(stop_words);
-        let mut ram_store = HashMap::new();
+    let number_of_inserted_documents = documents_ids_to_reindex.len();
+    let mut indexer = RawIndexer::new(&stop_words);
+    let mut ram_store = HashMap::new();
 
-        for document_id in documents_ids {
-            for result in documents_fields_store.document_fields(writer, *document_id)? {
-                let (attr, bytes) = result?;
-                let value: serde_json::Value = serde_json::from_slice(bytes)?;
-                ram_store.insert((document_id, attr), value);
-            }
-
-            for ((docid, attr), value) in ram_store.drain() {
-                serialize_value(
-                    writer,
-                    attr,
-                    schema.props(attr),
-                    *docid,
-                    documents_fields_store,
-                    documents_fields_counts_store,
-                    &mut indexer,
-                    &mut ranked_map,
-                    &value,
-                )?;
-            }
+    if let Some(ref attributes_for_facetting) = index.main.attributes_for_faceting(writer)? {
+        let facet_map = facets::facet_map_from_docids(writer, &index, &documents_ids_to_reindex, &attributes_for_facetting)?;
+        index.facets.add(writer, facet_map)?;
+    }
+    // ^-- https://github.com/meilisearch/MeiliSearch/pull/631#issuecomment-626624470 --v
+    for document_id in &documents_ids_to_reindex {
+        for result in index.documents_fields.document_fields(writer, *document_id)? {
+            let (field_id, bytes) = result?;
+            let value: Value = serde_json::from_slice(bytes)?;
+            ram_store.insert((document_id, field_id), value);
         }
 
-        // 4. write the new index in the main store
-        write_documents_addition_index(
-            writer,
-            main_store,
-            postings_lists_store,
-            docs_words_store,
-            &ranked_map,
-            number_of_inserted_documents,
-            indexer,
-        )?;
+        // For each key-value pair in the document.
+        for ((document_id, field_id), value) in ram_store.drain() {
+            index_document(
+                writer,
+                index.documents_fields,
+                index.documents_fields_counts,
+                &mut ranked_map,
+                &mut indexer,
+                &schema,
+                field_id,
+                *document_id,
+                &value,
+            )?;
+        }
     }
 
+    // 4. write the new index in the main store
+    write_documents_addition_index(
+        writer,
+        index,
+        &ranked_map,
+        number_of_inserted_documents,
+        indexer,
+    )?;
+
+    index.main.put_schema(writer, &schema)?;
+
+    // recompute all facet attributes after document update.
+    if let Some(attributes_for_facetting) = index.main.attributes_for_faceting(writer)? {
+        let docids = index.main.internal_docids(writer)?;
+        let facet_map = facets::facet_map_from_docids(writer, index, &docids, attributes_for_facetting.as_ref())?;
+        index.facets.add(writer, facet_map)?;
+    }
+
+    // update is finished; update sorted document id cache with new state
+    let mut document_ids = index.main.internal_docids(writer)?.to_vec();
+    super::cache_document_ids_sorted(writer, &ranked_map, index, &mut document_ids)?;
+
     Ok(())
 }
 
-pub fn write_documents_addition_index(
-    writer: &mut heed::RwTxn,
-    main_store: store::Main,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
+pub fn write_documents_addition_index<A: AsRef<[u8]>>(
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
     ranked_map: &RankedMap,
     number_of_inserted_documents: usize,
-    indexer: RawIndexer,
-) -> MResult<()> {
+    indexer: RawIndexer<A>,
+) -> MResult<()>
+{
     let indexed = indexer.build();
     let mut delta_words_builder = SetBuilder::memory();
 
     for (word, delta_set) in indexed.words_doc_indexes {
         delta_words_builder.insert(&word).unwrap();
 
-        let set = match postings_lists_store.postings_list(writer, &word)? {
-            Some(set) => Union::new(&set, &delta_set).into_set_buf(),
+        let set = match index.postings_lists.postings_list(writer, &word)? {
+            Some(postings) => Union::new(&postings.matches, &delta_set).into_set_buf(),
             None => delta_set,
         };
 
-        postings_lists_store.put_postings_list(writer, &word, &set)?;
+        index.postings_lists.put_postings_list(writer, &word, &set)?;
     }
 
     for (id, words) in indexed.docs_words {
-        docs_words_store.put_doc_words(writer, id, &words)?;
+        index.docs_words.put_doc_words(writer, id, &words)?;
     }
 
-    let delta_words = delta_words_builder
-        .into_inner()
-        .and_then(fst::Set::from_bytes)
-        .unwrap();
+    let delta_words = delta_words_builder.into_set();
 
-    let words = match main_store.words_fst(writer)? {
-        Some(words) => {
-            let op = OpBuilder::new()
-                .add(words.stream())
-                .add(delta_words.stream())
-                .r#union();
+    let words_fst = index.main.words_fst(writer)?;
+    let words = if !words_fst.is_empty() {
+        let op = OpBuilder::new()
+            .add(words_fst.stream())
+            .add(delta_words.stream())
+            .r#union();
 
-            let mut words_builder = SetBuilder::memory();
-            words_builder.extend_stream(op).unwrap();
-            words_builder
-                .into_inner()
-                .and_then(fst::Set::from_bytes)
-                .unwrap()
-        }
-        None => delta_words,
+        let mut words_builder = SetBuilder::memory();
+        words_builder.extend_stream(op).unwrap();
+        words_builder.into_set()
+    } else {
+        delta_words
     };
 
-    main_store.put_words_fst(writer, &words)?;
-    main_store.put_ranked_map(writer, ranked_map)?;
-    main_store.put_number_of_documents(writer, |old| old + number_of_inserted_documents as u64)?;
+    index.main.put_words_fst(writer, &words)?;
+    index.main.put_ranked_map(writer, ranked_map)?;
+    index.main.put_number_of_documents(writer, |old| old + number_of_inserted_documents as u64)?;
+
+    compute_short_prefixes(writer, &words, index)?;
 
     Ok(())
 }

meilisearch-core/src/update/documents_deletion.rs

@@ -1,20 +1,20 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
 
 use fst::{SetBuilder, Streamer};
-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::facets;
 use crate::store;
-use crate::update::{next_update_id, Update};
-use crate::{DocumentId, Error, MResult, RankedMap};
+use crate::update::{next_update_id, compute_short_prefixes, Update};
+use crate::{DocumentId, Error, MResult, RankedMap, MainWriter, Index};
 
 pub struct DocumentsDeletion {
     updates_store: store::Updates,
     updates_results_store: store::UpdatesResults,
     updates_notifier: UpdateEventsEmitter,
-    documents: Vec<DocumentId>,
+    external_docids: Vec<String>,
 }
 
 impl DocumentsDeletion {
@@ -27,104 +27,95 @@ impl DocumentsDeletion {
             updates_store,
             updates_results_store,
             updates_notifier,
-            documents: Vec::new(),
+            external_docids: Vec::new(),
         }
     }
 
-    pub fn delete_document_by_id(&mut self, document_id: DocumentId) {
-        self.documents.push(document_id);
+    pub fn delete_document_by_external_docid(&mut self, document_id: String) {
+        self.external_docids.push(document_id);
     }
 
-    pub fn delete_document<D>(&mut self, schema: &Schema, document: D) -> MResult<()>
-    where
-        D: serde::Serialize,
-    {
-        let identifier = schema.identifier_name();
-        let document_id = match extract_document_id(identifier, &document)? {
-            Some(id) => id,
-            None => return Err(Error::MissingDocumentId),
-        };
-
-        self.delete_document_by_id(document_id);
-
-        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,
             self.updates_store,
             self.updates_results_store,
-            self.documents,
+            self.external_docids,
         )?;
         Ok(update_id)
     }
 }
 
-impl Extend<DocumentId> for DocumentsDeletion {
-    fn extend<T: IntoIterator<Item = DocumentId>>(&mut self, iter: T) {
-        self.documents.extend(iter)
+impl Extend<String> for DocumentsDeletion {
+    fn extend<T: IntoIterator<Item=String>>(&mut self, iter: T) {
+        self.external_docids.extend(iter)
     }
 }
 
 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>,
+    external_docids: Vec<String>,
 ) -> MResult<u64> {
     let last_update_id = next_update_id(writer, updates_store, updates_results_store)?;
 
-    let update = Update::documents_deletion(deletion);
+    let update = Update::documents_deletion(external_docids);
     updates_store.put_update(writer, last_update_id, &update)?;
 
     Ok(last_update_id)
 }
 
 pub fn apply_documents_deletion(
-    writer: &mut heed::RwTxn,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
-    deletion: Vec<DocumentId>,
-) -> MResult<()> {
-    let idset = SetBuf::from_dirty(deletion);
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
+    external_docids: Vec<String>,
+) -> MResult<()>
+{
+    let (external_docids, internal_docids) = {
+        let new_external_docids = SetBuf::from_dirty(external_docids);
+        let mut internal_docids = Vec::new();
 
-    let schema = match main_store.schema(writer)? {
+        let old_external_docids = index.main.external_docids(writer)?;
+        for external_docid in new_external_docids.as_slice() {
+            if let Some(id) = old_external_docids.get(external_docid) {
+                internal_docids.push(DocumentId(id as u32));
+            }
+        }
+
+        let new_external_docids = fst::Map::from_iter(new_external_docids.into_iter().map(|k| (k, 0))).unwrap();
+        (new_external_docids, SetBuf::from_dirty(internal_docids))
+    };
+
+    let schema = match index.main.schema(writer)? {
         Some(schema) => schema,
         None => return Err(Error::SchemaMissing),
     };
 
-    let mut ranked_map = match main_store.ranked_map(writer)? {
+    let mut ranked_map = match index.main.ranked_map(writer)? {
         Some(ranked_map) => ranked_map,
         None => RankedMap::default(),
     };
 
+    // facet filters deletion
+    if let Some(attributes_for_facetting) = index.main.attributes_for_faceting(writer)? {
+        let facet_map = facets::facet_map_from_docids(writer, &index, &internal_docids, &attributes_for_facetting)?;
+        index.facets.remove(writer, facet_map)?;
+    }
+
     // collect the ranked attributes according to the schema
-    let ranked_attrs: Vec<_> = schema
-        .iter()
-        .filter_map(
-            |(_, attr, prop)| {
-                if prop.is_ranked() {
-                    Some(attr)
-                } else {
-                    None
-                }
-            },
-        )
-        .collect();
+    let ranked_fields = schema.ranked();
 
     let mut words_document_ids = HashMap::new();
-    for id in idset {
+    for id in internal_docids.iter().cloned() {
         // remove all the ranked attributes from the ranked_map
-        for ranked_attr in &ranked_attrs {
+        for ranked_attr in ranked_fields {
             ranked_map.remove(id, *ranked_attr);
         }
 
-        if let Some(words) = docs_words_store.doc_words(writer, id)? {
+        let words = index.docs_words.doc_words(writer, id)?;
+        if !words.is_empty() {
             let mut stream = words.stream();
             while let Some(word) = stream.next() {
                 let word = word.to_vec();
@@ -141,52 +132,76 @@ pub fn apply_documents_deletion(
     for (word, document_ids) in words_document_ids {
         let document_ids = SetBuf::from_dirty(document_ids);
 
-        if let Some(doc_indexes) = postings_lists_store.postings_list(writer, &word)? {
-            let op = DifferenceByKey::new(&doc_indexes, &document_ids, |d| d.document_id, |id| *id);
+        if let Some(postings) = index.postings_lists.postings_list(writer, &word)? {
+            let op = DifferenceByKey::new(&postings.matches, &document_ids, |d| d.document_id, |id| *id);
             let doc_indexes = op.into_set_buf();
 
             if !doc_indexes.is_empty() {
-                postings_lists_store.put_postings_list(writer, &word, &doc_indexes)?;
+                index.postings_lists.put_postings_list(writer, &word, &doc_indexes)?;
             } else {
-                postings_lists_store.del_postings_list(writer, &word)?;
+                index.postings_lists.del_postings_list(writer, &word)?;
                 removed_words.insert(word);
             }
         }
 
         for id in document_ids {
-            documents_fields_counts_store.del_all_document_fields_counts(writer, id)?;
-            if documents_fields_store.del_all_document_fields(writer, id)? != 0 {
+            index.documents_fields_counts.del_all_document_fields_counts(writer, id)?;
+            if index.documents_fields.del_all_document_fields(writer, id)? != 0 {
                 deleted_documents.insert(id);
             }
         }
     }
 
     let deleted_documents_len = deleted_documents.len() as u64;
-    for id in deleted_documents {
-        docs_words_store.del_doc_words(writer, id)?;
+    for id in &deleted_documents {
+        index.docs_words.del_doc_words(writer, *id)?;
     }
 
     let removed_words = fst::Set::from_iter(removed_words).unwrap();
-    let words = match main_store.words_fst(writer)? {
-        Some(words_set) => {
-            let op = fst::set::OpBuilder::new()
-                .add(words_set.stream())
-                .add(removed_words.stream())
-                .difference();
+    let words = {
+        let words_set = index.main.words_fst(writer)?;
+        let op = fst::set::OpBuilder::new()
+            .add(words_set.stream())
+            .add(removed_words.stream())
+            .difference();
 
-            let mut words_builder = SetBuilder::memory();
-            words_builder.extend_stream(op).unwrap();
-            words_builder
-                .into_inner()
-                .and_then(fst::Set::from_bytes)
-                .unwrap()
-        }
-        None => fst::Set::default(),
+        let mut words_builder = SetBuilder::memory();
+        words_builder.extend_stream(op).unwrap();
+        words_builder.into_set()
     };
 
-    main_store.put_words_fst(writer, &words)?;
-    main_store.put_ranked_map(writer, &ranked_map)?;
-    main_store.put_number_of_documents(writer, |old| old - deleted_documents_len)?;
+    index.main.put_words_fst(writer, &words)?;
+    index.main.put_ranked_map(writer, &ranked_map)?;
+    index.main.put_number_of_documents(writer, |old| old - deleted_documents_len)?;
+
+    // We apply the changes to the user and internal ids
+    index.main.remove_external_docids(writer, &external_docids)?;
+    index.main.remove_internal_docids(writer, &internal_docids)?;
+
+    compute_short_prefixes(writer, &words, index)?;
+
+    // update is finished; update sorted document id cache with new state
+    document_cache_remove_deleted(writer, index, &ranked_map, &deleted_documents)?;
 
     Ok(())
 }
+
+/// rebuilds the document id cache by either removing deleted documents from the existing cache,
+/// and generating a new one from docs in store
+fn document_cache_remove_deleted(writer: &mut MainWriter, index: &Index, ranked_map: &RankedMap, documents_to_delete: &HashSet<DocumentId>) -> MResult<()> {
+    let new_cache = match index.main.sorted_document_ids_cache(writer)? {
+        // only keep documents that are not in the list of deleted documents. Order is preserved,
+        // no need to resort
+        Some(old_cache) => {
+            old_cache.iter().filter(|docid| !documents_to_delete.contains(docid)).cloned().collect::<Vec<_>>()
+        }
+        // couldn't find cached documents, try building a new cache from documents in store
+        None => {
+            let mut document_ids = index.main.internal_docids(writer)?.to_vec();
+            super::cache_document_ids_sorted(writer, ranked_map, index, &mut document_ids)?;
+            document_ids
+        }
+    };
+    index.main.put_sorted_document_ids_cache(writer, &new_cache)?;
+    Ok(())
+}

meilisearch-core/src/update/helpers.rs

@@ -0,0 +1,142 @@
+use std::fmt::Write as _;
+
+use indexmap::IndexMap;
+use meilisearch_schema::IndexedPos;
+use meilisearch_types::DocumentId;
+use ordered_float::OrderedFloat;
+use serde_json::Value;
+
+use crate::Number;
+use crate::raw_indexer::RawIndexer;
+use crate::serde::SerializerError;
+use crate::store::DiscoverIds;
+
+/// Returns the number of words indexed or `None` if the type is unindexable.
+pub fn index_value<A: AsRef<[u8]>>(
+    indexer: &mut RawIndexer<A>,
+    document_id: DocumentId,
+    indexed_pos: IndexedPos,
+    value: &Value,
+) -> Option<usize>
+{
+    match value {
+        Value::Null => None,
+        Value::Bool(boolean) => {
+            let text = boolean.to_string();
+            let number_of_words = indexer.index_text(document_id, indexed_pos, &text);
+            Some(number_of_words)
+        },
+        Value::Number(number) => {
+            let text = number.to_string();
+            Some(indexer.index_text(document_id, indexed_pos, &text))
+        },
+        Value::String(string) => {
+            Some(indexer.index_text(document_id, indexed_pos, &string))
+        },
+        Value::Array(_) => {
+            let text = value_to_string(value);
+            Some(indexer.index_text(document_id, indexed_pos, &text))
+        },
+        Value::Object(_) => {
+            let text = value_to_string(value);
+            Some(indexer.index_text(document_id, indexed_pos, &text))
+        },
+    }
+}
+
+/// Transforms the JSON Value type into a String.
+pub fn value_to_string(value: &Value) -> String {
+    fn internal_value_to_string(string: &mut String, value: &Value) {
+        match value {
+            Value::Null => (),
+            Value::Bool(boolean) => { let _ = write!(string, "{}", &boolean); },
+            Value::Number(number) => { let _ = write!(string, "{}", &number); },
+            Value::String(text) => string.push_str(&text),
+            Value::Array(array) => {
+                for value in array {
+                    internal_value_to_string(string, value);
+                    let _ = string.write_str(". ");
+                }
+            },
+            Value::Object(object) => {
+                for (key, value) in object {
+                    string.push_str(key);
+                    let _ = string.write_str(". ");
+                    internal_value_to_string(string, value);
+                    let _ = string.write_str(". ");
+                }
+            },
+        }
+    }
+
+    let mut string = String::new();
+    internal_value_to_string(&mut string, value);
+    string
+}
+
+/// Transforms the JSON Value type into a Number.
+pub fn value_to_number(value: &Value) -> Option<Number> {
+    use std::str::FromStr;
+
+    match value {
+        Value::Null => None,
+        Value::Bool(boolean) => Some(Number::Unsigned(*boolean as u64)),
+        Value::Number(number) => {
+            match (number.as_i64(), number.as_u64(), number.as_f64()) {
+                (Some(n), _, _) => Some(Number::Signed(n)),
+                (_, Some(n), _) => Some(Number::Unsigned(n)),
+                (_, _, Some(n)) => Some(Number::Float(OrderedFloat(n))),
+                (None, None, None) => None,
+            }
+        },
+        Value::String(string) => Number::from_str(string).ok(),
+        Value::Array(_array) => None,
+        Value::Object(_object) => None,
+    }
+}
+
+/// Validates a string representation to be a correct document id and returns
+/// the corresponding id or generate a new one, this is the way we produce documents ids.
+pub fn discover_document_id<F>(
+    docid: &str,
+    external_docids_get: F,
+    available_docids: &mut DiscoverIds<'_>,
+) -> Result<DocumentId, SerializerError>
+where
+    F: FnOnce(&str) -> Option<u32>
+{
+    if docid.chars().all(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_') {
+        match external_docids_get(docid) {
+            Some(id) => Ok(DocumentId(id)),
+            None => {
+                let internal_id = available_docids.next().expect("no more ids available");
+                Ok(internal_id)
+            },
+        }
+    } else {
+        Err(SerializerError::InvalidDocumentIdFormat)
+    }
+}
+
+/// Extracts and validates the document id of a document.
+pub fn extract_document_id<F>(
+    primary_key: &str,
+    document: &IndexMap<String, Value>,
+    external_docids_get: F,
+    available_docids: &mut DiscoverIds<'_>,
+) -> Result<(DocumentId, String), SerializerError>
+where
+    F: FnOnce(&str) -> Option<u32>
+{
+    match document.get(primary_key) {
+        Some(value) => {
+            let docid = match value {
+                Value::Number(number) => number.to_string(),
+                Value::String(string) => string.clone(),
+                _ => return Err(SerializerError::InvalidDocumentIdFormat),
+            };
+            discover_document_id(&docid, external_docids_get, available_docids).map(|id| (id, docid))
+        }
+        None => Err(SerializerError::DocumentIdNotFound),
+    }
+}

meilisearch-core/src/update/mod.rs

@@ -2,35 +2,34 @@ mod clear_all;
 mod customs_update;
 mod documents_addition;
 mod documents_deletion;
-mod schema_update;
-mod stop_words_addition;
-mod stop_words_deletion;
-mod synonyms_addition;
-mod synonyms_deletion;
+mod settings_update;
+mod helpers;
 
 pub use self::clear_all::{apply_clear_all, push_clear_all};
 pub use self::customs_update::{apply_customs_update, push_customs_update};
-pub use self::documents_addition::{
-    apply_documents_addition, apply_documents_partial_addition, DocumentsAddition,
-};
+pub use self::documents_addition::{apply_documents_addition, apply_documents_partial_addition, DocumentsAddition};
 pub use self::documents_deletion::{apply_documents_deletion, DocumentsDeletion};
-pub use self::schema_update::{apply_schema_update, push_schema_update};
-pub use self::stop_words_addition::{apply_stop_words_addition, StopWordsAddition};
-pub use self::stop_words_deletion::{apply_stop_words_deletion, StopWordsDeletion};
-pub use self::synonyms_addition::{apply_synonyms_addition, SynonymsAddition};
-pub use self::synonyms_deletion::{apply_synonyms_deletion, SynonymsDeletion};
+pub use self::helpers::{index_value, value_to_string, value_to_number, discover_document_id, extract_document_id};
+pub use self::settings_update::{apply_settings_update, push_settings_update};
 
 use std::cmp;
-use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::time::Instant;
 
 use chrono::{DateTime, Utc};
+use fst::{IntoStreamer, Streamer};
 use heed::Result as ZResult;
+use indexmap::IndexMap;
 use log::debug;
+use sdset::Set;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 
-use crate::{store, DocumentId, MResult};
-use meilisearch_schema::Schema;
+use meilisearch_error::ErrorCode;
+use meilisearch_types::DocumentId;
+
+use crate::{store, MResult, RankedMap};
+use crate::database::{MainT, UpdateT};
+use crate::settings::SettingsUpdate;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Update {
@@ -46,13 +45,6 @@ impl Update {
         }
     }
 
-    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),
@@ -60,51 +52,30 @@ impl Update {
         }
     }
 
-    fn documents_addition(data: Vec<HashMap<String, serde_json::Value>>) -> Update {
+    fn documents_addition(primary_key: Option<String>, documents: Vec<IndexMap<String, Value>>) -> Update {
         Update {
-            data: UpdateData::DocumentsAddition(data),
+            data: UpdateData::DocumentsAddition{ documents, primary_key },
             enqueued_at: Utc::now(),
         }
     }
 
-    fn documents_partial(data: Vec<HashMap<String, serde_json::Value>>) -> Update {
+    fn documents_partial(primary_key: Option<String>, documents: Vec<IndexMap<String, Value>>) -> Update {
         Update {
-            data: UpdateData::DocumentsPartial(data),
+            data: UpdateData::DocumentsPartial{ documents, primary_key },
             enqueued_at: Utc::now(),
         }
     }
 
-    fn documents_deletion(data: Vec<DocumentId>) -> Update {
+    fn documents_deletion(data: Vec<String>) -> Update {
         Update {
             data: UpdateData::DocumentsDeletion(data),
             enqueued_at: Utc::now(),
         }
     }
 
-    fn synonyms_addition(data: BTreeMap<String, Vec<String>>) -> Update {
+    fn settings(data: SettingsUpdate) -> 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),
+            data: UpdateData::Settings(Box::new(data)),
             enqueued_at: Utc::now(),
         }
     }
@@ -113,43 +84,36 @@ impl Update {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum UpdateData {
     ClearAll,
-    Schema(Schema),
     Customs(Vec<u8>),
-    DocumentsAddition(Vec<HashMap<String, serde_json::Value>>),
-    DocumentsPartial(Vec<HashMap<String, serde_json::Value>>),
-    DocumentsDeletion(Vec<DocumentId>),
-    SynonymsAddition(BTreeMap<String, Vec<String>>),
-    SynonymsDeletion(BTreeMap<String, Option<Vec<String>>>),
-    StopWordsAddition(BTreeSet<String>),
-    StopWordsDeletion(BTreeSet<String>),
+    // (primary key, documents)
+    DocumentsAddition {
+        primary_key: Option<String>,
+        documents: Vec<IndexMap<String, Value>>
+    },
+    DocumentsPartial {
+        primary_key: Option<String>,
+        documents: Vec<IndexMap<String, Value>>,
+    },
+    DocumentsDeletion(Vec<String>),
+    Settings(Box<SettingsUpdate>)
 }
 
 impl UpdateData {
     pub fn update_type(&self) -> UpdateType {
         match self {
             UpdateData::ClearAll => UpdateType::ClearAll,
-            UpdateData::Schema(_) => UpdateType::Schema,
             UpdateData::Customs(_) => UpdateType::Customs,
-            UpdateData::DocumentsAddition(addition) => UpdateType::DocumentsAddition {
-                number: addition.len(),
+            UpdateData::DocumentsAddition{ documents, .. } => UpdateType::DocumentsAddition {
+                number: documents.len(),
             },
-            UpdateData::DocumentsPartial(addition) => UpdateType::DocumentsPartial {
-                number: addition.len(),
+            UpdateData::DocumentsPartial{ documents, .. } => UpdateType::DocumentsPartial {
+                number: documents.len(),
             },
             UpdateData::DocumentsDeletion(deletion) => UpdateType::DocumentsDeletion {
                 number: deletion.len(),
             },
-            UpdateData::SynonymsAddition(addition) => UpdateType::SynonymsAddition {
-                number: addition.len(),
-            },
-            UpdateData::SynonymsDeletion(deletion) => UpdateType::SynonymsDeletion {
-                number: deletion.len(),
-            },
-            UpdateData::StopWordsAddition(addition) => UpdateType::StopWordsAddition {
-                number: addition.len(),
-            },
-            UpdateData::StopWordsDeletion(deletion) => UpdateType::StopWordsDeletion {
-                number: deletion.len(),
+            UpdateData::Settings(update) => UpdateType::Settings {
+                settings: update.clone(),
             },
         }
     }
@@ -159,32 +123,37 @@ impl UpdateData {
 #[serde(tag = "name")]
 pub enum UpdateType {
     ClearAll,
-    Schema,
     Customs,
     DocumentsAddition { number: usize },
     DocumentsPartial { number: usize },
     DocumentsDeletion { number: usize },
-    SynonymsAddition { number: usize },
-    SynonymsDeletion { number: usize },
-    StopWordsAddition { number: usize },
-    StopWordsDeletion { number: usize },
+    Settings { settings: Box<SettingsUpdate> },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ProcessedUpdateResult {
     pub update_id: u64,
     #[serde(rename = "type")]
     pub update_type: UpdateType,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub error: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error_link: Option<String>,
     pub duration: f64, // in seconds
     pub enqueued_at: DateTime<Utc>,
     pub processed_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct EnqueuedUpdateResult {
     pub update_id: u64,
+    #[serde(rename = "type")]
     pub update_type: UpdateType,
     pub enqueued_at: DateTime<Utc>,
 }
@@ -196,6 +165,10 @@ pub enum UpdateStatus {
         #[serde(flatten)]
         content: EnqueuedUpdateResult,
     },
+    Failed {
+        #[serde(flatten)]
+        content: ProcessedUpdateResult,
+    },
     Processed {
         #[serde(flatten)]
         content: ProcessedUpdateResult,
@@ -203,14 +176,20 @@ pub enum UpdateStatus {
 }
 
 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<Option<UpdateStatus>> {
-    match updates_results_store.update_result(reader, update_id)? {
-        Some(result) => Ok(Some(UpdateStatus::Processed { content: result })),
-        None => match updates_store.get(reader, update_id)? {
+    match updates_results_store.update_result(update_reader, update_id)? {
+        Some(result) => {
+            if result.error.is_some() {
+                Ok(Some(UpdateStatus::Failed { content: result }))
+            } else {
+                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,
@@ -224,25 +203,25 @@ pub fn update_status(
 }
 
 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,
+pub fn update_task(
+    writer: &mut heed::RwTxn<MainT>,
+    index: &store::Index,
     update_id: u64,
     update: Update,
 ) -> MResult<ProcessedUpdateResult> {
@@ -255,30 +234,7 @@ pub fn update_task<'a, 'b>(
             let start = Instant::now();
 
             let update_type = UpdateType::ClearAll;
-            let result = apply_clear_all(
-                writer,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-            );
-
-            (update_type, result, start.elapsed())
-        }
-        UpdateData::Schema(schema) => {
-            let start = Instant::now();
-
-            let update_type = UpdateType::Schema;
-            let result = apply_schema_update(
-                writer,
-                &schema,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-            );
+            let result = apply_clear_all(writer, index);
 
             (update_type, result, start.elapsed())
         }
@@ -290,41 +246,25 @@ pub fn update_task<'a, 'b>(
 
             (update_type, result, start.elapsed())
         }
-        UpdateData::DocumentsAddition(documents) => {
+        UpdateData::DocumentsAddition { documents, primary_key } => {
             let start = Instant::now();
 
             let update_type = UpdateType::DocumentsAddition {
                 number: documents.len(),
             };
 
-            let result = apply_documents_addition(
-                writer,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-                documents,
-            );
+            let result = apply_documents_addition(writer, index, documents, primary_key);
 
             (update_type, result, start.elapsed())
         }
-        UpdateData::DocumentsPartial(documents) => {
+        UpdateData::DocumentsPartial{ documents, primary_key } => {
             let start = Instant::now();
 
             let update_type = UpdateType::DocumentsPartial {
                 number: documents.len(),
             };
 
-            let result = apply_documents_partial_addition(
-                writer,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-                documents,
-            );
+            let result = apply_documents_partial_addition(writer, index, documents, primary_key);
 
             (update_type, result, start.elapsed())
         }
@@ -335,67 +275,21 @@ pub fn update_task<'a, 'b>(
                 number: documents.len(),
             };
 
-            let result = apply_documents_deletion(
+            let result = apply_documents_deletion(writer, index, documents);
+
+            (update_type, result, start.elapsed())
+        }
+        UpdateData::Settings(settings) => {
+            let start = Instant::now();
+
+            let update_type = UpdateType::Settings {
+                settings: settings.clone(),
+            };
+
+            let result = apply_settings_update(
                 writer,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-                documents,
-            );
-
-            (update_type, result, start.elapsed())
-        }
-        UpdateData::SynonymsAddition(synonyms) => {
-            let start = Instant::now();
-
-            let update_type = UpdateType::SynonymsAddition {
-                number: synonyms.len(),
-            };
-
-            let result = apply_synonyms_addition(writer, index.main, index.synonyms, synonyms);
-
-            (update_type, result, start.elapsed())
-        }
-        UpdateData::SynonymsDeletion(synonyms) => {
-            let start = Instant::now();
-
-            let update_type = UpdateType::SynonymsDeletion {
-                number: synonyms.len(),
-            };
-
-            let result = apply_synonyms_deletion(writer, index.main, index.synonyms, synonyms);
-
-            (update_type, result, start.elapsed())
-        }
-        UpdateData::StopWordsAddition(stop_words) => {
-            let start = Instant::now();
-
-            let update_type = UpdateType::StopWordsAddition {
-                number: stop_words.len(),
-            };
-
-            let result =
-                apply_stop_words_addition(writer, index.main, index.postings_lists, stop_words);
-
-            (update_type, result, start.elapsed())
-        }
-        UpdateData::StopWordsDeletion(stop_words) => {
-            let start = Instant::now();
-
-            let update_type = UpdateType::StopWordsDeletion {
-                number: stop_words.len(),
-            };
-
-            let result = apply_stop_words_deletion(
-                writer,
-                index.main,
-                index.documents_fields,
-                index.documents_fields_counts,
-                index.postings_lists,
-                index.docs_words,
-                stop_words,
+                index,
+                *settings,
             );
 
             (update_type, result, start.elapsed())
@@ -410,7 +304,10 @@ pub fn update_task<'a, 'b>(
     let status = ProcessedUpdateResult {
         update_id,
         update_type,
-        error: result.map_err(|e| e.to_string()).err(),
+        error: result.as_ref().map_err(|e| e.to_string()).err(),
+        error_code: result.as_ref().map_err(|e| e.error_name()).err(),
+        error_type: result.as_ref().map_err(|e| e.error_type()).err(),
+        error_link: result.as_ref().map_err(|e| e.error_url()).err(),
         duration: duration.as_secs_f64(),
         enqueued_at,
         processed_at: Utc::now(),
@@ -418,3 +315,77 @@ pub fn update_task<'a, 'b>(
 
     Ok(status)
 }
+
+fn compute_short_prefixes<A>(
+    writer: &mut heed::RwTxn<MainT>,
+    words_fst: &fst::Set<A>,
+    index: &store::Index,
+) -> MResult<()>
+where A: AsRef<[u8]>,
+{
+    // clear the prefixes
+    let pplc_store = index.prefix_postings_lists_cache;
+    pplc_store.clear(writer)?;
+
+    for prefix_len in 1..=2 {
+        // compute prefixes and store those in the PrefixPostingsListsCache store.
+        let mut previous_prefix: Option<([u8; 4], Vec<_>)> = None;
+        let mut stream = words_fst.into_stream();
+        while let Some(input) = stream.next() {
+
+            // We skip the prefixes that are shorter than the current length
+            // we want to cache (<). We must ignore the input when it is exactly the
+            // same word as the prefix because if we match exactly on it we need
+            // to consider it as an exact match and not as a prefix (=).
+            if input.len() <= prefix_len { continue }
+
+            if let Some(postings_list) = index.postings_lists.postings_list(writer, input)?.map(|p| p.matches.into_owned()) {
+                let prefix = &input[..prefix_len];
+
+                let mut arr_prefix = [0; 4];
+                arr_prefix[..prefix_len].copy_from_slice(prefix);
+
+                match previous_prefix {
+                    Some((ref mut prev_prefix, ref mut prev_pl)) if *prev_prefix != arr_prefix => {
+                        prev_pl.sort_unstable();
+                        prev_pl.dedup();
+
+                        if let Ok(prefix) = std::str::from_utf8(&prev_prefix[..prefix_len]) {
+                            debug!("writing the prefix of {:?} of length {}", prefix, prev_pl.len());
+                        }
+
+                        let pls = Set::new_unchecked(&prev_pl);
+                        pplc_store.put_prefix_postings_list(writer, *prev_prefix, &pls)?;
+
+                        *prev_prefix = arr_prefix;
+                        prev_pl.clear();
+                        prev_pl.extend_from_slice(&postings_list);
+                    },
+                    Some((_, ref mut prev_pl)) => prev_pl.extend_from_slice(&postings_list),
+                    None => previous_prefix = Some((arr_prefix, postings_list.to_vec())),
+                }
+            }
+        }
+
+        // write the last prefix postings lists
+        if let Some((prev_prefix, mut prev_pl)) = previous_prefix.take() {
+            prev_pl.sort_unstable();
+            prev_pl.dedup();
+
+            let pls = Set::new_unchecked(&prev_pl);
+            pplc_store.put_prefix_postings_list(writer, prev_prefix, &pls)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn cache_document_ids_sorted(
+    writer: &mut heed::RwTxn<MainT>,
+    ranked_map: &RankedMap,
+    index: &store::Index,
+    document_ids: &mut [DocumentId],
+) -> MResult<()> {
+    crate::bucket_sort::placeholder_document_sort(document_ids, index, writer, ranked_map)?;
+    index.main.put_sorted_document_ids_cache(writer, &document_ids)
+}

meilisearch-core/src/update/schema_update.rs

@@ -1,75 +0,0 @@
-use meilisearch_schema::{Diff, Schema};
-
-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,
-    new_schema: &Schema,
-    main_store: store::Main,
-    documents_fields_store: store::DocumentsFields,
-    documents_fields_counts_store: store::DocumentsFieldsCounts,
-    postings_lists_store: store::PostingsLists,
-    docs_words_store: store::DocsWords,
-) -> MResult<()> {
-    use UnsupportedOperation::{
-        CanOnlyIntroduceNewSchemaAttributesAtEnd, CannotRemoveSchemaAttribute,
-        CannotReorderSchemaAttribute, CannotUpdateSchemaIdentifier,
-    };
-
-    let mut need_full_reindexing = false;
-
-    if let Some(old_schema) = main_store.schema(writer)? {
-        for diff in meilisearch_schema::diff(&old_schema, new_schema) {
-            match diff {
-                Diff::IdentChange { .. } => return Err(CannotUpdateSchemaIdentifier.into()),
-                Diff::AttrMove { .. } => return Err(CannotReorderSchemaAttribute.into()),
-                Diff::AttrPropsChange { old, new, .. } => {
-                    if new.indexed != old.indexed {
-                        need_full_reindexing = true;
-                    }
-                    if new.ranked != old.ranked {
-                        need_full_reindexing = true;
-                    }
-                }
-                Diff::NewAttr { pos, .. } => {
-                    // new attribute not at the end of the schema
-                    if pos < old_schema.number_of_attributes() {
-                        return Err(CanOnlyIntroduceNewSchemaAttributesAtEnd.into());
-                    }
-                }
-                Diff::RemovedAttr { .. } => return Err(CannotRemoveSchemaAttribute.into()),
-            }
-        }
-    }
-
-    main_store.put_schema(writer, new_schema)?;
-
-    if need_full_reindexing {
-        reindex_all_documents(
-            writer,
-            main_store,
-            documents_fields_store,
-            documents_fields_counts_store,
-            postings_lists_store,
-            docs_words_store,
-        )?
-    }
-
-    Ok(())
-}
-
-pub fn push_schema_update(
-    writer: &mut heed::RwTxn,
-    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);
-    updates_store.put_update(writer, last_update_id, &update)?;
-
-    Ok(last_update_id)
-}