Rename MeiliDB into MeiliSearch

meilisearch-core/src/store/docs_words.rs

@@ -0,0 +1,49 @@
+use super::BEU64;
+use crate::DocumentId;
+use heed::types::{ByteSlice, OwnedType};
+use heed::Result as ZResult;
+use std::sync::Arc;
+
+#[derive(Copy, Clone)]
+pub struct DocsWords {
+    pub(crate) docs_words: heed::Database<OwnedType<BEU64>, ByteSlice>,
+}
+
+impl DocsWords {
+    pub fn put_doc_words(
+        self,
+        writer: &mut heed::RwTxn,
+        document_id: DocumentId,
+        words: &fst::Set,
+    ) -> ZResult<()> {
+        let document_id = BEU64::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);
+        self.docs_words.delete(writer, &document_id)
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> 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);
+        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),
+        }
+    }
+}

meilisearch-core/src/store/documents_fields.rs

@@ -0,0 +1,78 @@
+use heed::types::{ByteSlice, OwnedType};
+use heed::Result as ZResult;
+use meilisearch_schema::SchemaAttr;
+
+use super::DocumentAttrKey;
+use crate::DocumentId;
+
+#[derive(Copy, Clone)]
+pub struct DocumentsFields {
+    pub(crate) documents_fields: heed::Database<OwnedType<DocumentAttrKey>, ByteSlice>,
+}
+
+impl DocumentsFields {
+    pub fn put_document_field(
+        self,
+        writer: &mut heed::RwTxn,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+        value: &[u8],
+    ) -> ZResult<()> {
+        let key = DocumentAttrKey::new(document_id, attribute);
+        self.documents_fields.put(writer, &key, value)
+    }
+
+    pub fn del_all_document_fields(
+        self,
+        writer: &mut heed::RwTxn,
+        document_id: DocumentId,
+    ) -> ZResult<usize> {
+        let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
+        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
+        self.documents_fields.delete_range(writer, &(start..=end))
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+        self.documents_fields.clear(writer)
+    }
+
+    pub fn document_attribute<'txn>(
+        self,
+        reader: &'txn heed::RoTxn,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+    ) -> ZResult<Option<&'txn [u8]>> {
+        let key = DocumentAttrKey::new(document_id, attribute);
+        self.documents_fields.get(reader, &key)
+    }
+
+    pub fn document_fields<'txn>(
+        self,
+        reader: &'txn heed::RoTxn,
+        document_id: DocumentId,
+    ) -> ZResult<DocumentFieldsIter<'txn>> {
+        let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
+        let end = DocumentAttrKey::new(document_id, SchemaAttr::max());
+        let iter = self.documents_fields.range(reader, &(start..=end))?;
+        Ok(DocumentFieldsIter { iter })
+    }
+}
+
+pub struct DocumentFieldsIter<'txn> {
+    iter: heed::RoRange<'txn, OwnedType<DocumentAttrKey>, ByteSlice>,
+}
+
+impl<'txn> Iterator for DocumentFieldsIter<'txn> {
+    type Item = ZResult<(SchemaAttr, &'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)))
+            }
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}

meilisearch-core/src/store/documents_fields_counts.rs

@@ -0,0 +1,142 @@
+use super::DocumentAttrKey;
+use crate::DocumentId;
+use heed::types::OwnedType;
+use heed::Result as ZResult;
+use meilisearch_schema::SchemaAttr;
+
+#[derive(Copy, Clone)]
+pub struct DocumentsFieldsCounts {
+    pub(crate) documents_fields_counts: heed::Database<OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+}
+
+impl DocumentsFieldsCounts {
+    pub fn put_document_field_count(
+        self,
+        writer: &mut heed::RwTxn,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+        value: u64,
+    ) -> ZResult<()> {
+        let key = DocumentAttrKey::new(document_id, attribute);
+        self.documents_fields_counts.put(writer, &key, &value)
+    }
+
+    pub fn del_all_document_fields_counts(
+        self,
+        writer: &mut heed::RwTxn,
+        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))
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+        self.documents_fields_counts.clear(writer)
+    }
+
+    pub fn document_field_count(
+        self,
+        reader: &heed::RoTxn,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+    ) -> ZResult<Option<u64>> {
+        let key = DocumentAttrKey::new(document_id, attribute);
+        match self.documents_fields_counts.get(reader, &key)? {
+            Some(count) => Ok(Some(count)),
+            None => Ok(None),
+        }
+    }
+
+    pub fn document_fields_counts<'txn>(
+        self,
+        reader: &'txn heed::RoTxn,
+        document_id: DocumentId,
+    ) -> ZResult<DocumentFieldsCountsIter<'txn>> {
+        let start = DocumentAttrKey::new(document_id, SchemaAttr::min());
+        let end = DocumentAttrKey::new(document_id, SchemaAttr::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>> {
+        let iter = self.documents_fields_counts.iter(reader)?;
+        Ok(DocumentsIdsIter {
+            last_seen_id: None,
+            iter,
+        })
+    }
+
+    pub fn all_documents_fields_counts<'txn>(
+        self,
+        reader: &'txn heed::RoTxn,
+    ) -> ZResult<AllDocumentsFieldsCountsIter<'txn>> {
+        let iter = self.documents_fields_counts.iter(reader)?;
+        Ok(AllDocumentsFieldsCountsIter { iter })
+    }
+}
+
+pub struct DocumentFieldsCountsIter<'txn> {
+    iter: heed::RoRange<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+}
+
+impl Iterator for DocumentFieldsCountsIter<'_> {
+    type Item = ZResult<(SchemaAttr, u64)>;
+
+    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)))
+            }
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}
+
+pub struct DocumentsIdsIter<'txn> {
+    last_seen_id: Option<DocumentId>,
+    iter: heed::RoIter<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+}
+
+impl Iterator for DocumentsIdsIter<'_> {
+    type Item = ZResult<DocumentId>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        for result in &mut self.iter {
+            match result {
+                Ok((key, _)) => {
+                    let document_id = DocumentId(key.docid.get());
+                    if Some(document_id) != self.last_seen_id {
+                        self.last_seen_id = Some(document_id);
+                        return Some(Ok(document_id));
+                    }
+                }
+                Err(e) => return Some(Err(e)),
+            }
+        }
+        None
+    }
+}
+
+pub struct AllDocumentsFieldsCountsIter<'txn> {
+    iter: heed::RoIter<'txn, OwnedType<DocumentAttrKey>, OwnedType<u64>>,
+}
+
+impl Iterator for AllDocumentsFieldsCountsIter<'_> {
+    type Item = ZResult<(DocumentId, SchemaAttr, u64)>;
+
+    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)))
+            }
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}

meilisearch-core/src/store/main.rs

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

meilisearch-core/src/store/mod.rs

@@ -0,0 +1,394 @@
+mod docs_words;
+mod documents_fields;
+mod documents_fields_counts;
+mod main;
+mod postings_lists;
+mod synonyms;
+mod updates;
+mod updates_results;
+
+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::main::Main;
+pub use self::postings_lists::PostingsLists;
+pub use self::synonyms::Synonyms;
+pub use self::updates::Updates;
+pub use self::updates_results::UpdatesResults;
+
+use std::collections::HashSet;
+
+use heed::Result as ZResult;
+use meilisearch_schema::{Schema, SchemaAttr};
+use serde::de::{self, Deserialize};
+use zerocopy::{AsBytes, FromBytes};
+
+use crate::criterion::Criteria;
+use crate::database::{UpdateEvent, UpdateEventsEmitter};
+use crate::serde::Deserializer;
+use crate::{query_builder::QueryBuilder, update, DocumentId, Error, MResult};
+
+type BEU64 = zerocopy::U64<byteorder::BigEndian>;
+type BEU16 = zerocopy::U16<byteorder::BigEndian>;
+
+#[derive(Debug, Copy, Clone, AsBytes, FromBytes)]
+#[repr(C)]
+pub struct DocumentAttrKey {
+    docid: BEU64,
+    attr: BEU16,
+}
+
+impl DocumentAttrKey {
+    fn new(docid: DocumentId, attr: SchemaAttr) -> DocumentAttrKey {
+        DocumentAttrKey {
+            docid: BEU64::new(docid.0),
+            attr: BEU16::new(attr.0),
+        }
+    }
+}
+
+fn main_name(name: &str) -> String {
+    format!("store-{}", name)
+}
+
+fn postings_lists_name(name: &str) -> String {
+    format!("store-{}-postings-lists", name)
+}
+
+fn documents_fields_name(name: &str) -> String {
+    format!("store-{}-documents-fields", name)
+}
+
+fn documents_fields_counts_name(name: &str) -> String {
+    format!("store-{}-documents-fields-counts", name)
+}
+
+fn synonyms_name(name: &str) -> String {
+    format!("store-{}-synonyms", name)
+}
+
+fn docs_words_name(name: &str) -> String {
+    format!("store-{}-docs-words", name)
+}
+
+fn updates_name(name: &str) -> String {
+    format!("store-{}-updates", name)
+}
+
+fn updates_results_name(name: &str) -> String {
+    format!("store-{}-updates-results", name)
+}
+
+#[derive(Clone)]
+pub struct Index {
+    pub main: Main,
+    pub postings_lists: PostingsLists,
+    pub documents_fields: DocumentsFields,
+    pub documents_fields_counts: DocumentsFieldsCounts,
+    pub synonyms: Synonyms,
+    pub docs_words: DocsWords,
+
+    pub updates: Updates,
+    pub updates_results: UpdatesResults,
+    pub(crate) updates_notifier: UpdateEventsEmitter,
+}
+
+impl Index {
+    pub fn document<T: de::DeserializeOwned>(
+        &self,
+        reader: &heed::RoTxn,
+        attributes: Option<&HashSet<&str>>,
+        document_id: DocumentId,
+    ) -> MResult<Option<T>> {
+        let schema = self.main.schema(reader)?;
+        let schema = schema.ok_or(Error::SchemaMissing)?;
+
+        let attributes = match attributes {
+            Some(attributes) => attributes
+                .iter()
+                .map(|name| schema.attribute(name))
+                .collect(),
+            None => None,
+        };
+
+        let mut deserializer = Deserializer {
+            document_id,
+            reader,
+            documents_fields: self.documents_fields,
+            schema: &schema,
+            attributes: attributes.as_ref(),
+        };
+
+        Ok(Option::<T>::deserialize(&mut deserializer)?)
+    }
+
+    pub fn document_attribute<T: de::DeserializeOwned>(
+        &self,
+        reader: &heed::RoTxn,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+    ) -> MResult<Option<T>> {
+        let bytes = self
+            .documents_fields
+            .document_attribute(reader, document_id, attribute)?;
+        match bytes {
+            Some(bytes) => Ok(Some(serde_json::from_slice(bytes)?)),
+            None => Ok(None),
+        }
+    }
+
+    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 customs_update(&self, writer: &mut heed::RwTxn, customs: Vec<u8>) -> ZResult<u64> {
+        let _ = self.updates_notifier.send(UpdateEvent::NewUpdate);
+        update::push_customs_update(writer, self.updates, self.updates_results, customs)
+    }
+
+    pub fn documents_addition<D>(&self) -> update::DocumentsAddition<D> {
+        update::DocumentsAddition::new(
+            self.updates,
+            self.updates_results,
+            self.updates_notifier.clone(),
+        )
+    }
+
+    pub fn documents_partial_addition<D>(&self) -> update::DocumentsAddition<D> {
+        update::DocumentsAddition::new_partial(
+            self.updates,
+            self.updates_results,
+            self.updates_notifier.clone(),
+        )
+    }
+
+    pub fn documents_deletion(&self) -> update::DocumentsDeletion {
+        update::DocumentsDeletion::new(
+            self.updates,
+            self.updates_results,
+            self.updates_notifier.clone(),
+        )
+    }
+
+    pub fn clear_all(&self, writer: &mut heed::RwTxn) -> 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)? {
+            Some((id, _)) => Ok(Some(id)),
+            None => Ok(None),
+        }
+    }
+
+    pub fn update_status(
+        &self,
+        reader: &heed::RoTxn,
+        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>> {
+        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)? {
+            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;
+                }
+            }
+        }
+
+        // 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(update) = self.update_status(reader, id)? {
+                    updates.push(update);
+                }
+            }
+        }
+
+        Ok(updates)
+    }
+
+    pub fn query_builder(&self) -> QueryBuilder {
+        QueryBuilder::new(
+            self.main,
+            self.postings_lists,
+            self.documents_fields_counts,
+            self.synonyms,
+        )
+    }
+
+    pub fn query_builder_with_criteria<'c, 'f, 'd>(
+        &self,
+        criteria: Criteria<'c>,
+    ) -> QueryBuilder<'c, 'f, 'd> {
+        QueryBuilder::with_criteria(
+            self.main,
+            self.postings_lists,
+            self.documents_fields_counts,
+            self.synonyms,
+            criteria,
+        )
+    }
+}
+
+pub fn create(
+    env: &heed::Env,
+    name: &str,
+    updates_notifier: UpdateEventsEmitter,
+) -> MResult<Index> {
+    // create all the store names
+    let main_name = main_name(name);
+    let postings_lists_name = postings_lists_name(name);
+    let documents_fields_name = documents_fields_name(name);
+    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 updates_name = updates_name(name);
+    let updates_results_name = updates_results_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 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))?;
+
+    Ok(Index {
+        main: Main { main },
+        postings_lists: PostingsLists { postings_lists },
+        documents_fields: DocumentsFields { documents_fields },
+        documents_fields_counts: DocumentsFieldsCounts {
+            documents_fields_counts,
+        },
+        synonyms: Synonyms { synonyms },
+        docs_words: DocsWords { docs_words },
+        updates: Updates { updates },
+        updates_results: UpdatesResults { updates_results },
+        updates_notifier,
+    })
+}
+
+pub fn open(
+    env: &heed::Env,
+    name: &str,
+    updates_notifier: UpdateEventsEmitter,
+) -> MResult<Option<Index>> {
+    // create all the store names
+    let main_name = main_name(name);
+    let postings_lists_name = postings_lists_name(name);
+    let documents_fields_name = documents_fields_name(name);
+    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 updates_name = updates_name(name);
+    let updates_results_name = updates_results_name(name);
+
+    // open all the stores
+    let main = match env.open_poly_database(Some(&main_name))? {
+        Some(main) => main,
+        None => return Ok(None),
+    };
+    let postings_lists = match env.open_database(Some(&postings_lists_name))? {
+        Some(postings_lists) => postings_lists,
+        None => return Ok(None),
+    };
+    let documents_fields = match env.open_database(Some(&documents_fields_name))? {
+        Some(documents_fields) => documents_fields,
+        None => return Ok(None),
+    };
+    let documents_fields_counts = match env.open_database(Some(&documents_fields_counts_name))? {
+        Some(documents_fields_counts) => documents_fields_counts,
+        None => return Ok(None),
+    };
+    let synonyms = match env.open_database(Some(&synonyms_name))? {
+        Some(synonyms) => synonyms,
+        None => return Ok(None),
+    };
+    let docs_words = match env.open_database(Some(&docs_words_name))? {
+        Some(docs_words) => docs_words,
+        None => return Ok(None),
+    };
+    let updates = match env.open_database(Some(&updates_name))? {
+        Some(updates) => updates,
+        None => return Ok(None),
+    };
+    let updates_results = match env.open_database(Some(&updates_results_name))? {
+        Some(updates_results) => updates_results,
+        None => return Ok(None),
+    };
+
+    Ok(Some(Index {
+        main: Main { main },
+        postings_lists: PostingsLists { postings_lists },
+        documents_fields: DocumentsFields { documents_fields },
+        documents_fields_counts: DocumentsFieldsCounts {
+            documents_fields_counts,
+        },
+        synonyms: Synonyms { synonyms },
+        docs_words: DocsWords { docs_words },
+        updates: Updates { updates },
+        updates_results: UpdatesResults { updates_results },
+        updates_notifier,
+    }))
+}
+
+pub fn clear(writer: &mut heed::RwTxn, index: &Index) -> MResult<()> {
+    // clear all the stores
+    index.main.clear(writer)?;
+    index.postings_lists.clear(writer)?;
+    index.documents_fields.clear(writer)?;
+    index.documents_fields_counts.clear(writer)?;
+    index.synonyms.clear(writer)?;
+    index.docs_words.clear(writer)?;
+    index.updates.clear(writer)?;
+    index.updates_results.clear(writer)?;
+    Ok(())
+}

meilisearch-core/src/store/postings_lists.rs

@@ -0,0 +1,41 @@
+use crate::DocIndex;
+use heed::types::{ByteSlice, CowSlice};
+use heed::Result as ZResult;
+use sdset::{Set, SetBuf};
+use std::borrow::Cow;
+
+#[derive(Copy, Clone)]
+pub struct PostingsLists {
+    pub(crate) postings_lists: heed::Database<ByteSlice, CowSlice<DocIndex>>,
+}
+
+impl PostingsLists {
+    pub fn put_postings_list(
+        self,
+        writer: &mut heed::RwTxn,
+        word: &[u8],
+        words_indexes: &Set<DocIndex>,
+    ) -> ZResult<()> {
+        self.postings_lists.put(writer, word, words_indexes)
+    }
+
+    pub fn del_postings_list(self, writer: &mut heed::RwTxn, word: &[u8]) -> ZResult<bool> {
+        self.postings_lists.delete(writer, word)
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+        self.postings_lists.clear(writer)
+    }
+
+    pub fn postings_list<'txn>(
+        self,
+        reader: &'txn heed::RoTxn,
+        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),
+        }
+    }
+}

meilisearch-core/src/store/synonyms.rs

@@ -0,0 +1,40 @@
+use heed::types::ByteSlice;
+use heed::Result as ZResult;
+use std::sync::Arc;
+
+#[derive(Copy, Clone)]
+pub struct Synonyms {
+    pub(crate) synonyms: heed::Database<ByteSlice, ByteSlice>,
+}
+
+impl Synonyms {
+    pub fn put_synonyms(
+        self,
+        writer: &mut heed::RwTxn,
+        word: &[u8],
+        synonyms: &fst::Set,
+    ) -> ZResult<()> {
+        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> {
+        self.synonyms.delete(writer, word)
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+        self.synonyms.clear(writer)
+    }
+
+    pub fn synonyms(self, reader: &heed::RoTxn, word: &[u8]) -> ZResult<Option<fst::Set>> {
+        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),
+        }
+    }
+}

meilisearch-core/src/store/updates.rs

@@ -0,0 +1,59 @@
+use super::BEU64;
+use crate::update::Update;
+use heed::types::{OwnedType, SerdeJson};
+use heed::Result as ZResult;
+
+#[derive(Copy, Clone)]
+pub struct Updates {
+    pub(crate) updates: heed::Database<OwnedType<BEU64>, SerdeJson<Update>>,
+}
+
+impl Updates {
+    // TODO do not trigger deserialize if possible
+    pub fn last_update_id(self, reader: &heed::RoTxn) -> ZResult<Option<(u64, Update)>> {
+        match self.updates.last(reader)? {
+            Some((key, data)) => Ok(Some((key.get(), data))),
+            None => Ok(None),
+        }
+    }
+
+    // TODO do not trigger deserialize if possible
+    fn first_update_id(self, reader: &heed::RoTxn) -> ZResult<Option<(u64, Update)>> {
+        match self.updates.first(reader)? {
+            Some((key, data)) => Ok(Some((key.get(), data))),
+            None => Ok(None),
+        }
+    }
+
+    // TODO do not trigger deserialize if possible
+    pub fn get(self, reader: &heed::RoTxn, 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,
+        update_id: u64,
+        update: &Update,
+    ) -> ZResult<()> {
+        // TODO prefer using serde_json?
+        let update_id = BEU64::new(update_id);
+        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)? {
+            Some((update_id, update)) => {
+                let key = BEU64::new(update_id);
+                self.updates.delete(writer, &key)?;
+                Ok(Some((update_id, update)))
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn clear(self, writer: &mut heed::RwTxn) -> ZResult<()> {
+        self.updates.clear(writer)
+    }
+}

meilisearch-core/src/store/updates_results.rs

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