Introduce the documents Deserializer

src/store/documents_fields.rs

@@ -0,0 +1,64 @@
+use std::convert::TryFrom;
+use meilidb_schema::SchemaAttr;
+use crate::DocumentId;
+
+pub struct DocumentsFields {
+    pub(crate) documents_fields: rkv::SingleStore,
+}
+
+impl DocumentsFields {
+    pub fn del_all_document_fields(
+        &mut self,
+        writer: &mut rkv::Writer,
+        document_id: DocumentId,
+    ) -> Result<(), rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn document_field<T: rkv::Readable>(
+        &self,
+        reader: &T,
+        document_id: DocumentId,
+        attribute: SchemaAttr,
+    ) -> Result<Option<&[u8]>, rkv::StoreError>
+    {
+        unimplemented!()
+    }
+
+    pub fn document_fields<'r, T: rkv::Readable>(
+        &self,
+        reader: &'r T,
+        document_id: DocumentId,
+    ) -> Result<DocumentFieldsIter<'r, T>, rkv::StoreError>
+    {
+        let document_id_bytes = document_id.0.to_be_bytes();
+        let iter = self.documents_fields.iter_from(reader, document_id_bytes)?;
+        Ok(DocumentFieldsIter { reader, document_id, iter })
+    }
+}
+
+pub struct DocumentFieldsIter<'r, T> {
+    reader: &'r T,
+    document_id: DocumentId,
+    iter: rkv::store::single::Iter<'r>,
+}
+
+impl<'r, T: rkv::Readable + 'r> Iterator for DocumentFieldsIter<'r, T> {
+    type Item = Result<(SchemaAttr, &'r [u8]), rkv::StoreError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.iter.next() {
+            Some(Ok((key, Some(rkv::Value::Blob(bytes))))) => {
+                let bytes = key.get(8..8+2).unwrap();
+                let array = <[u8; 2]>::try_from(bytes).unwrap();
+                let attr = u16::from_be_bytes(array);
+                let attr = SchemaAttr::new(attr);
+                Some(Ok((attr, bytes)))
+            },
+            Some(Ok((key, data))) => panic!("{:?}, {:?}", key, data),
+            Some(Err(e)) => Some(Err(e)),
+            None => None,
+        }
+    }
+}

src/store/mod.rs

@@ -1,26 +1,72 @@
-mod words;
+mod documents_fields;
 mod synonyms;
+mod words;
 
-pub use self::words::Words;
+pub use self::documents_fields::{DocumentsFields, DocumentFieldsIter};
 pub use self::synonyms::Synonyms;
+pub use self::words::Words;
 
-const SCHEMA_KEY:              &str = "schema";
-const WORDS_KEY:               &str = "words";
-const SYNONYMS_KEY:            &str = "synonyms";
-const RANKED_MAP_KEY:          &str = "ranked-map";
 const NUMBER_OF_DOCUMENTS_KEY: &str = "number-of-documents";
+const RANKED_MAP_KEY:          &str = "ranked-map";
+const SCHEMA_KEY:              &str = "schema";
+const SYNONYMS_KEY:            &str = "synonyms";
+const WORDS_KEY:               &str = "words";
 
 fn aligned_to(bytes: &[u8], align: usize) -> bool {
     (bytes as *const _ as *const () as usize) % align == 0
 }
 
-pub fn create(env: &rkv::Rkv, name: &str) -> Result<(Words, Synonyms), rkv::StoreError> {
-    let main = env.open_single(name, rkv::StoreOptions::create())?;
-    let words_indexes = env.open_single(format!("{}-words-indexes", name).as_str(), rkv::StoreOptions::create())?;
-    let synonyms = env.open_single(format!("{}-synonyms", name).as_str(), rkv::StoreOptions::create())?;
+fn words_indexes_name(name: &str) -> String {
+    format!("{}-words-indexes", name)
+}
+
+fn synonyms_name(name: &str) -> String {
+    format!("{}-synonyms", 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>
+{
+    open_options(env, name, rkv::StoreOptions::create())
+}
+
+pub fn open(
+    env: &rkv::Rkv,
+    name: &str,
+) -> Result<(Words, Synonyms, DocumentsFields), rkv::StoreError>
+{
+    let mut options = rkv::StoreOptions::default();
+    options.create = false;
+    open_options(env, name, options)
+}
+
+fn open_options(
+    env: &rkv::Rkv,
+    name: &str,
+    options: rkv::StoreOptions,
+) -> Result<(Words, Synonyms, DocumentsFields), 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 documents_fields_name = documents_fields_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 documents_fields = env.open_single(documents_fields_name.as_str(), options)?;
 
     let words = Words { main, words_indexes };
     let synonyms = Synonyms { main, synonyms };
+    let documents_fields = DocumentsFields { documents_fields };
 
-    Ok((words, synonyms))
+    Ok((words, synonyms, documents_fields))
 }