Introduce many SingleStore wrappers

src/store/docs_words.rs

@@ -0,0 +1,37 @@
+use crate::DocumentId;
+
+#[derive(Copy, Clone)]
+pub struct DocsWords {
+    pub(crate) docs_words: rkv::SingleStore,
+}
+
+impl DocsWords {
+    pub fn doc_words<T: rkv::Readable>(
+        &self,
+        reader: &T,
+        document_id: DocumentId,
+    ) -> Result<Option<fst::Set>, rkv::StoreError>
+    {
+        Ok(Some(fst::Set::default()))
+    }
+
+    pub fn put_doc_words(
+        &self,
+        writer: &mut rkv::Writer,
+        document_id: DocumentId,
+        words: &fst::Set,
+    ) -> Result<(), rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn del_doc_words(
+        &self,
+        writer: &mut rkv::Writer,
+        document_id: DocumentId,
+    ) -> Result<(), rkv::StoreError>
+    {
+        let document_id_bytes = document_id.0.to_be_bytes();
+        self.docs_words.delete(writer, document_id_bytes)
+    }
+}

src/store/documents_fields.rs

@@ -2,16 +2,28 @@ use std::convert::TryFrom;
 use meilidb_schema::SchemaAttr;
 use crate::DocumentId;
 
+#[derive(Copy, Clone)]
 pub struct DocumentsFields {
     pub(crate) documents_fields: rkv::SingleStore,
 }
 
 impl DocumentsFields {
     pub fn del_all_document_fields(
-        &mut self,
+        &self,
         writer: &mut rkv::Writer,
         document_id: DocumentId,
-    ) -> Result<(), rkv::StoreError>
+    ) -> Result<usize, rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn put_document_field(
+        &self,
+        writer: &mut rkv::Writer,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+        value: &[u8],
+    ) -> Result<Option<&[u8]>, rkv::StoreError>
     {
         unimplemented!()
     }

src/store/main.rs

@@ -0,0 +1,63 @@
+use std::sync::Arc;
+use crate::store::WORDS_KEY;
+use crate::RankedMap;
+
+#[derive(Copy, Clone)]
+pub struct Main {
+    pub(crate) main: rkv::SingleStore,
+}
+
+impl Main {
+    pub fn put_words_fst(
+        &self,
+        writer: &mut rkv::Writer,
+        fst: &fst::Set,
+    ) -> Result<(), rkv::StoreError>
+    {
+        let blob = rkv::Value::Blob(fst.as_fst().as_bytes());
+        self.main.put(writer, WORDS_KEY, &blob)
+    }
+
+    pub fn words_fst<T: rkv::Readable>(
+        &self,
+        reader: &T,
+    ) -> Result<Option<fst::Set>, rkv::StoreError>
+    {
+        match self.main.get(reader, WORDS_KEY)? {
+            Some(rkv::Value::Blob(bytes)) => {
+                let len = bytes.len();
+                let bytes = Arc::from(bytes);
+                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
+                Ok(Some(fst::Set::from(fst)))
+            },
+            Some(value) => panic!("invalid type {:?}", value),
+            None => Ok(None),
+        }
+    }
+
+    pub fn put_ranked_map(
+        &self,
+        writer: &mut rkv::Writer,
+        ranked_map: &RankedMap,
+    ) -> Result<(), rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn ranked_map<T: rkv::Readable>(
+        &self,
+        reader: &T,
+    ) -> Result<RankedMap, rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn put_number_of_documents<F: Fn(u64) -> u64>(
+        &self,
+        writer: &mut rkv::Writer,
+        func: F,
+    ) -> Result<(), rkv::StoreError>
+    {
+        unimplemented!()
+    }
+}

src/store/mod.rs

@@ -1,10 +1,16 @@
+mod docs_words;
 mod documents_fields;
+mod main;
+mod postings_lists;
 mod synonyms;
-mod words;
+mod updates;
 
+pub use self::docs_words::DocsWords;
 pub use self::documents_fields::{DocumentsFields, DocumentFieldsIter};
+pub use self::main::Main;
+pub use self::postings_lists::PostingsLists;
 pub use self::synonyms::Synonyms;
-pub use self::words::Words;
+pub use self::updates::Updates;
 
 const NUMBER_OF_DOCUMENTS_KEY: &str = "number-of-documents";
 const RANKED_MAP_KEY:          &str = "ranked-map";
@@ -16,31 +22,41 @@ fn aligned_to(bytes: &[u8], align: usize) -> bool {
     (bytes as *const _ as *const () as usize) % align == 0
 }
 
-fn words_indexes_name(name: &str) -> String {
-    format!("{}-words-indexes", name)
-}
-
-fn synonyms_name(name: &str) -> String {
-    format!("{}-synonyms", name)
+fn postings_lists_name(name: &str) -> String {
+    format!("{}-postings-lists", name)
 }
 
 fn documents_fields_name(name: &str) -> String {
     format!("{}-documents-fields", name)
 }
 
-pub fn create(
-    env: &rkv::Rkv,
-    name: &str,
-) -> Result<(Words, Synonyms, DocumentsFields), rkv::StoreError>
-{
+fn synonyms_name(name: &str) -> String {
+    format!("{}-synonyms", name)
+}
+
+fn docs_words_name(name: &str) -> String {
+    format!("{}-docs-words", name)
+}
+
+fn updates_name(name: &str) -> String {
+    format!("{}-updates", name)
+}
+
+#[derive(Copy, Clone)]
+pub struct Index {
+    pub main: Main,
+    pub postings_lists: PostingsLists,
+    pub documents_fields: DocumentsFields,
+    pub synonyms: Synonyms,
+    pub docs_words: DocsWords,
+    pub updates: Updates,
+}
+
+pub fn create(env: &rkv::Rkv, name: &str) -> Result<Index, rkv::StoreError> {
     open_options(env, name, rkv::StoreOptions::create())
 }
 
-pub fn open(
-    env: &rkv::Rkv,
-    name: &str,
-) -> Result<(Words, Synonyms, DocumentsFields), rkv::StoreError>
-{
+pub fn open(env: &rkv::Rkv, name: &str) -> Result<Index, rkv::StoreError> {
     let mut options = rkv::StoreOptions::default();
     options.create = false;
     open_options(env, name, options)
@@ -50,23 +66,30 @@ fn open_options(
     env: &rkv::Rkv,
     name: &str,
     options: rkv::StoreOptions,
-) -> Result<(Words, Synonyms, DocumentsFields), rkv::StoreError>
+) -> Result<Index, rkv::StoreError>
 {
     // create all the database names
     let main_name = name;
-    let words_indexes_name = words_indexes_name(name);
-    let synonyms_name = synonyms_name(name);
+    let postings_lists_name = postings_lists_name(name);
     let documents_fields_name = documents_fields_name(name);
+    let synonyms_name = synonyms_name(name);
+    let docs_words_name = docs_words_name(name);
+    let updates_name = updates_name(name);
 
     // open all the database names
     let main = env.open_single(main_name, options)?;
-    let words_indexes = env.open_single(words_indexes_name.as_str(), options)?;
-    let synonyms = env.open_single(synonyms_name.as_str(), options)?;
+    let postings_lists = env.open_single(postings_lists_name.as_str(), options)?;
     let documents_fields = env.open_single(documents_fields_name.as_str(), options)?;
+    let synonyms = env.open_single(synonyms_name.as_str(), options)?;
+    let docs_words = env.open_single(docs_words_name.as_str(), options)?;
+    let updates = env.open_single(updates_name.as_str(), options)?;
 
-    let words = Words { main, words_indexes };
-    let synonyms = Synonyms { main, synonyms };
-    let documents_fields = DocumentsFields { documents_fields };
-
-    Ok((words, synonyms, documents_fields))
+    Ok(Index {
+        main: Main { main },
+        postings_lists: PostingsLists { postings_lists },
+        documents_fields: DocumentsFields { documents_fields },
+        synonyms: Synonyms { synonyms },
+        docs_words: DocsWords { docs_words },
+        updates: Updates { updates },
+    })
 }

src/store/postings_lists.rs

@@ -1,46 +1,17 @@
 use std::borrow::Cow;
-use std::sync::Arc;
 use std::{mem, ptr};
 use zerocopy::{AsBytes, LayoutVerified};
 
 use crate::DocIndex;
 use crate::store::aligned_to;
-use crate::store::WORDS_KEY;
 
-pub struct Words {
-    pub(crate) main: rkv::SingleStore,
-    pub(crate) words_indexes: rkv::SingleStore,
+#[derive(Copy, Clone)]
+pub struct PostingsLists {
+    pub(crate) postings_lists: rkv::SingleStore,
 }
 
-impl Words {
-    pub fn put_words_fst(
-        &self,
-        writer: &mut rkv::Writer,
-        fst: &fst::Set,
-    ) -> Result<(), rkv::StoreError>
-    {
-        let blob = rkv::Value::Blob(fst.as_fst().as_bytes());
-        self.main.put(writer, WORDS_KEY, &blob)
-    }
-
-    pub fn words_fst<T: rkv::Readable>(
-        &self,
-        reader: &T,
-    ) -> Result<fst::Set, rkv::StoreError>
-    {
-        match self.main.get(reader, WORDS_KEY)? {
-            Some(rkv::Value::Blob(bytes)) => {
-                let len = bytes.len();
-                let bytes = Arc::from(bytes);
-                let fst = fst::raw::Fst::from_shared_bytes(bytes, 0, len).unwrap();
-                Ok(fst::Set::from(fst))
-            },
-            Some(value) => panic!("invalid type {:?}", value),
-            None => panic!("could not find word index"),
-        }
-    }
-
-    pub fn put_words_indexes(
+impl PostingsLists {
+    pub fn put_postings_list(
         &self,
         writer: &mut rkv::Writer,
         word: &[u8],
@@ -48,23 +19,35 @@ impl Words {
     ) -> Result<(), rkv::StoreError>
     {
         let blob = rkv::Value::Blob(words_indexes.as_bytes());
-        self.main.put(writer, word, &blob)
+        self.postings_lists.put(writer, word, &blob)
     }
 
-    pub fn word_indexes<'a, T: rkv::Readable>(
+    pub fn del_postings_list(
+        &self,
+        writer: &mut rkv::Writer,
+        word: &[u8],
+    ) -> Result<(), rkv::StoreError>
+    {
+        self.postings_lists.delete(writer, word)
+    }
+
+    pub fn postings_list<'a, T: rkv::Readable>(
         &self,
         reader: &'a T,
         word: &[u8],
-    ) -> Result<Option<Cow<'a, [DocIndex]>>, rkv::StoreError>
+    ) -> Result<Option<Cow<'a, sdset::Set<DocIndex>>>, rkv::StoreError>
     {
-        let bytes = match self.main.get(reader, word)? {
+        let bytes = match self.postings_lists.get(reader, word)? {
             Some(rkv::Value::Blob(bytes)) => bytes,
             Some(value) => panic!("invalid type {:?}", value),
             None => return Ok(None),
         };
 
         match LayoutVerified::new_slice(bytes) {
-            Some(layout) => Ok(Some(Cow::Borrowed(layout.into_slice()))),
+            Some(layout) => {
+                let set = sdset::Set::new(layout.into_slice()).unwrap();
+                Ok(Some(Cow::Borrowed(set)))
+            },
             None => {
                 let len = bytes.len();
                 let elem_size = mem::size_of::<DocIndex>();
@@ -81,7 +64,8 @@ impl Words {
                         vec.set_len(elems);
                     }
 
-                    return Ok(Some(Cow::Owned(vec)))
+                    let setbuf = sdset::SetBuf::new(vec).unwrap();
+                    return Ok(Some(Cow::Owned(setbuf)))
                 }
 
                 Ok(None)

src/store/synonyms.rs

@@ -1,5 +1,5 @@
+#[derive(Copy, Clone)]
 pub struct Synonyms {
-    pub(crate) main: rkv::SingleStore,
     pub(crate) synonyms: rkv::SingleStore,
 }
 

src/store/updates.rs

@@ -0,0 +1,27 @@
+use crate::update::Update;
+
+#[derive(Copy, Clone)]
+pub struct Updates {
+    pub(crate) updates: rkv::SingleStore,
+}
+
+impl Updates {
+    pub fn push_back(
+        &self,
+        writer: &mut rkv::Writer,
+        update: &Update,
+    ) -> Result<u64, rkv::StoreError>
+    {
+        // let update = rmp_serde::to_vec_named(&addition)?;
+        unimplemented!()
+    }
+
+    pub fn alternatives_to<T: rkv::Readable>(
+        &self,
+        reader: &T,
+        word: &[u8],
+    ) -> Result<Option<fst::Set>, rkv::StoreError>
+    {
+        unimplemented!()
+    }
+}