Implement documents format

document reader transform

remove update format

support document sequences

fix document transform

clean transform

improve error handling

add documents! macro

fix transform bug

fix tests

remove csv dependency

Add comments on the transform process

replace search cli

fmt

review edits

fix http ui

fix clippy warnings

Revert "fix clippy warnings"

This reverts commit a1ce3cd96e603633dbf43e9e0b12b2453c9c5620.

fix review comments

remove smallvec in transform loop

review edits

milli/src/documents/builder.rs

@@ -0,0 +1,80 @@
+use std::io;
+
+use byteorder::{BigEndian, WriteBytesExt};
+use serde::ser::Serialize;
+
+use super::serde::DocumentSerializer;
+use super::{ByteCounter, DocumentsBatchIndex, DocumentsMetadata, Error};
+
+/// The `DocumentsBatchBuilder` provides a way to build a documents batch in the intermediary
+/// format used by milli.
+///
+/// The writer used by the DocumentBatchBuilder can be read using a `DocumentBatchReader` to
+/// iterate other the documents.
+///
+/// ## example:
+/// ```
+/// use milli::documents::DocumentBatchBuilder;
+/// use serde_json::json;
+/// use std::io::Cursor;
+///
+/// let mut writer = Cursor::new(Vec::new());
+/// let mut builder = DocumentBatchBuilder::new(&mut writer).unwrap();
+/// builder.add_documents(json!({"id": 1, "name": "foo"})).unwrap();
+/// builder.finish().unwrap();
+/// ```
+pub struct DocumentBatchBuilder<W> {
+    serializer: DocumentSerializer<W>,
+}
+
+impl<W: io::Write + io::Seek> DocumentBatchBuilder<W> {
+    pub fn new(writer: W) -> Result<Self, Error> {
+        let index = DocumentsBatchIndex::new();
+        let mut writer = ByteCounter::new(writer);
+        // add space to write the offset of the metadata at the end of the writer
+        writer.write_u64::<BigEndian>(0)?;
+
+        let serializer =
+            DocumentSerializer { writer, buffer: Vec::new(), index, count: 0, allow_seq: true };
+
+        Ok(Self { serializer })
+    }
+
+    /// Returns the number of documents that have been written to the builder.
+    pub fn len(&self) -> usize {
+        self.serializer.count
+    }
+
+    /// This method must be called after the document addition is terminated. It will put the
+    /// metadata at the end of the file, and write the metadata offset at the beginning on the
+    /// file.
+    pub fn finish(self) -> Result<(), Error> {
+        let DocumentSerializer {
+            writer: ByteCounter { mut writer, count: offset },
+            index,
+            count,
+            ..
+        } = self.serializer;
+
+        let meta = DocumentsMetadata { count, index };
+
+        bincode::serialize_into(&mut writer, &meta)?;
+
+        writer.seek(io::SeekFrom::Start(0))?;
+        writer.write_u64::<BigEndian>(offset as u64)?;
+
+        writer.flush()?;
+
+        Ok(())
+    }
+
+    /// Adds documents to the builder.
+    ///
+    /// The internal index is updated with the fields found
+    /// in the documents. Document must either be a map or a sequences of map, anything else will
+    /// fail.
+    pub fn add_documents<T: Serialize>(&mut self, document: T) -> Result<(), Error> {
+        document.serialize(&mut self.serializer)?;
+        Ok(())
+    }
+}

milli/src/documents/mod.rs

@@ -0,0 +1,233 @@
+mod builder;
+/// The documents module defines an intermediary document format that milli uses for indexation, and
+/// provides an API to easily build and read such documents.
+///
+/// The `DocumentBatchBuilder` interface allows to write batches of documents to a writer, that can
+/// later be read by milli using the `DocumentBatchReader` interface.
+mod reader;
+mod serde;
+
+use std::{fmt, io};
+
+use ::serde::{Deserialize, Serialize};
+use bimap::BiHashMap;
+pub use builder::DocumentBatchBuilder;
+pub use reader::DocumentBatchReader;
+
+use crate::FieldId;
+
+/// A bidirectional map that links field ids to their name in a document batch.
+pub type DocumentsBatchIndex = BiHashMap<FieldId, String>;
+
+#[derive(Debug, Serialize, Deserialize)]
+struct DocumentsMetadata {
+    count: usize,
+    index: DocumentsBatchIndex,
+}
+
+pub struct ByteCounter<W> {
+    count: usize,
+    writer: W,
+}
+
+impl<W> ByteCounter<W> {
+    fn new(writer: W) -> Self {
+        Self { count: 0, writer }
+    }
+}
+
+impl<W: io::Write> io::Write for ByteCounter<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let count = self.writer.write(buf)?;
+        self.count += count;
+        Ok(count)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.writer.flush()
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    InvalidDocumentFormat,
+    Custom(String),
+    JsonError(serde_json::Error),
+    Serialize(bincode::Error),
+    Io(io::Error),
+    DocumentTooLarge,
+}
+
+impl From<io::Error> for Error {
+    fn from(other: io::Error) -> Self {
+        Self::Io(other)
+    }
+}
+
+impl From<bincode::Error> for Error {
+    fn from(other: bincode::Error) -> Self {
+        Self::Serialize(other)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Custom(s) => write!(f, "Unexpected serialization error: {}", s),
+            Error::InvalidDocumentFormat => f.write_str("Invalid document addition format."),
+            Error::JsonError(err) => write!(f, "Couldn't serialize document value: {}", err),
+            Error::Io(e) => e.fmt(f),
+            Error::DocumentTooLarge => f.write_str("Provided document is too large (>2Gib)"),
+            Error::Serialize(e) => e.fmt(f),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+/// Macro used to generate documents, with the same syntax as `serde_json::json`
+#[cfg(test)]
+macro_rules! documents {
+    ($data:tt) => {{
+        let documents = serde_json::json!($data);
+        let mut writer = std::io::Cursor::new(Vec::new());
+        let mut builder = crate::documents::DocumentBatchBuilder::new(&mut writer).unwrap();
+        builder.add_documents(documents).unwrap();
+        builder.finish().unwrap();
+
+        writer.set_position(0);
+
+        crate::documents::DocumentBatchReader::from_reader(writer).unwrap()
+    }};
+}
+
+#[cfg(test)]
+mod test {
+    use serde_json::{json, Value};
+
+    use super::*;
+
+    #[test]
+    fn create_documents_no_errors() {
+        let json = json!({
+            "number": 1,
+            "string": "this is a field",
+            "array": ["an", "array"],
+            "object": {
+                "key": "value",
+            },
+            "bool": true
+        });
+
+        let mut v = Vec::new();
+        let mut cursor = io::Cursor::new(&mut v);
+
+        let mut builder = DocumentBatchBuilder::new(&mut cursor).unwrap();
+
+        builder.add_documents(json).unwrap();
+
+        builder.finish().unwrap();
+
+        let mut documents =
+            DocumentBatchReader::from_reader(io::Cursor::new(cursor.into_inner())).unwrap();
+
+        assert_eq!(documents.index().iter().count(), 5);
+
+        let reader = documents.next_document_with_index().unwrap().unwrap();
+
+        assert_eq!(reader.1.iter().count(), 5);
+        assert!(documents.next_document_with_index().unwrap().is_none());
+    }
+
+    #[test]
+    fn test_add_multiple_documents() {
+        let doc1 = json!({
+            "bool": true,
+        });
+        let doc2 = json!({
+            "toto": false,
+        });
+
+        let mut v = Vec::new();
+        let mut cursor = io::Cursor::new(&mut v);
+
+        let mut builder = DocumentBatchBuilder::new(&mut cursor).unwrap();
+
+        builder.add_documents(doc1).unwrap();
+        builder.add_documents(doc2).unwrap();
+
+        builder.finish().unwrap();
+
+        let mut documents =
+            DocumentBatchReader::from_reader(io::Cursor::new(cursor.into_inner())).unwrap();
+
+        assert_eq!(documents.index().iter().count(), 2);
+
+        let reader = documents.next_document_with_index().unwrap().unwrap();
+
+        assert_eq!(reader.1.iter().count(), 1);
+        assert!(documents.next_document_with_index().unwrap().is_some());
+        assert!(documents.next_document_with_index().unwrap().is_none());
+    }
+
+    #[test]
+    fn add_documents_array() {
+        let docs = json!([
+            { "toto": false },
+            { "tata": "hello" },
+        ]);
+
+        let mut v = Vec::new();
+        let mut cursor = io::Cursor::new(&mut v);
+
+        let mut builder = DocumentBatchBuilder::new(&mut cursor).unwrap();
+
+        builder.add_documents(docs).unwrap();
+
+        builder.finish().unwrap();
+
+        let mut documents =
+            DocumentBatchReader::from_reader(io::Cursor::new(cursor.into_inner())).unwrap();
+
+        assert_eq!(documents.index().iter().count(), 2);
+
+        let reader = documents.next_document_with_index().unwrap().unwrap();
+
+        assert_eq!(reader.1.iter().count(), 1);
+        assert!(documents.next_document_with_index().unwrap().is_some());
+        assert!(documents.next_document_with_index().unwrap().is_none());
+    }
+
+    #[test]
+    fn add_invalid_document_format() {
+        let mut v = Vec::new();
+        let mut cursor = io::Cursor::new(&mut v);
+
+        let mut builder = DocumentBatchBuilder::new(&mut cursor).unwrap();
+
+        let docs = json!([[
+            { "toto": false },
+            { "tata": "hello" },
+        ]]);
+
+        assert!(builder.add_documents(docs).is_err());
+
+        let docs = json!("hello");
+
+        assert!(builder.add_documents(docs).is_err());
+    }
+
+    #[test]
+    fn test_nested() {
+        let mut docs = documents!([{
+            "hello": {
+                "toto": ["hello"]
+            }
+        }]);
+
+        let (_index, doc) = docs.next_document_with_index().unwrap().unwrap();
+
+        let nested: Value = serde_json::from_slice(doc.get(0).unwrap()).unwrap();
+        assert_eq!(nested, json!({ "toto": ["hello"] }));
+    }
+}

milli/src/documents/reader.rs

@@ -0,0 +1,75 @@
+use std::io;
+use std::io::{BufReader, Read};
+use std::mem::size_of;
+
+use byteorder::{BigEndian, ReadBytesExt};
+use obkv::KvReader;
+
+use super::{DocumentsBatchIndex, DocumentsMetadata, Error};
+use crate::FieldId;
+
+/// The `DocumentsBatchReader` provides a way to iterate over documents that have been created with
+/// a `DocumentsBatchWriter`.
+///
+/// The documents are returned in the form of `obkv::Reader` where each field is identified with a
+/// `FieldId`. The mapping between the field ids and the field names is done thanks to the index.
+pub struct DocumentBatchReader<R> {
+    reader: BufReader<R>,
+    metadata: DocumentsMetadata,
+    buffer: Vec<u8>,
+    seen_documents: usize,
+}
+
+impl<R: io::Read + io::Seek> DocumentBatchReader<R> {
+    /// Construct a `DocumentsReader` from a reader.
+    ///
+    /// It first retrieves the index, then moves to the first document. Subsequent calls to
+    /// `next_document` advance the document reader until all the documents have been read.
+    pub fn from_reader(mut reader: R) -> Result<Self, Error> {
+        let mut buffer = Vec::new();
+
+        let meta_offset = reader.read_u64::<BigEndian>()?;
+        reader.seek(io::SeekFrom::Start(meta_offset))?;
+        reader.read_to_end(&mut buffer)?;
+        let metadata: DocumentsMetadata = bincode::deserialize(&buffer)?;
+
+        reader.seek(io::SeekFrom::Start(size_of::<u64>() as u64))?;
+        buffer.clear();
+
+        let reader = BufReader::new(reader);
+
+        Ok(Self { reader, metadata, buffer, seen_documents: 0 })
+    }
+
+    /// Returns the next document in the reader, and wraps it in an `obkv::KvReader`, along with a
+    /// reference to the addition index.
+    pub fn next_document_with_index<'a>(
+        &'a mut self,
+    ) -> io::Result<Option<(&'a DocumentsBatchIndex, KvReader<'a, FieldId>)>> {
+        if self.seen_documents < self.metadata.count {
+            let doc_len = self.reader.read_u32::<BigEndian>()?;
+            self.buffer.resize(doc_len as usize, 0);
+            self.reader.read_exact(&mut self.buffer)?;
+            self.seen_documents += 1;
+
+            let reader = KvReader::new(&self.buffer);
+            Ok(Some((&self.metadata.index, reader)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Return the fields index for the documents batch.
+    pub fn index(&self) -> &DocumentsBatchIndex {
+        &self.metadata.index
+    }
+
+    /// Returns the number of documents in the reader.
+    pub fn len(&self) -> usize {
+        self.metadata.count
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}

milli/src/documents/serde.rs

@@ -0,0 +1,465 @@
+use std::convert::TryInto;
+use std::{fmt, io};
+
+use byteorder::{BigEndian, WriteBytesExt};
+use obkv::KvWriter;
+use serde::ser::{Impossible, Serialize, SerializeMap, SerializeSeq, Serializer};
+
+use super::{ByteCounter, DocumentsBatchIndex, Error};
+use crate::FieldId;
+
+pub struct DocumentSerializer<W> {
+    pub writer: ByteCounter<W>,
+    pub buffer: Vec<u8>,
+    pub index: DocumentsBatchIndex,
+    pub count: usize,
+    pub allow_seq: bool,
+}
+
+impl<'a, W: io::Write> Serializer for &'a mut DocumentSerializer<W> {
+    type Ok = ();
+
+    type Error = Error;
+
+    type SerializeSeq = SeqSerializer<'a, W>;
+    type SerializeTuple = Impossible<(), Self::Error>;
+    type SerializeTupleStruct = Impossible<(), Self::Error>;
+    type SerializeTupleVariant = Impossible<(), Self::Error>;
+    type SerializeMap = MapSerializer<'a, &'a mut ByteCounter<W>>;
+    type SerializeStruct = Impossible<(), Self::Error>;
+    type SerializeStructVariant = Impossible<(), Self::Error>;
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        self.buffer.clear();
+        let cursor = io::Cursor::new(&mut self.buffer);
+        self.count += 1;
+        let map_serializer = MapSerializer {
+            map: KvWriter::new(cursor),
+            index: &mut self.index,
+            writer: &mut self.writer,
+            buffer: Vec::new(),
+        };
+
+        Ok(map_serializer)
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        if self.allow_seq {
+            // Only allow sequence of documents of depth 1.
+            self.allow_seq = false;
+            Ok(SeqSerializer { serializer: self })
+        } else {
+            Err(Error::InvalidDocumentFormat)
+        }
+    }
+
+    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    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(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+}
+
+pub struct SeqSerializer<'a, W> {
+    serializer: &'a mut DocumentSerializer<W>,
+}
+
+impl<'a, W: io::Write> SerializeSeq for SeqSerializer<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(&mut *self.serializer)?;
+        Ok(())
+    }
+
+    fn end(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+}
+
+pub struct MapSerializer<'a, W> {
+    map: KvWriter<io::Cursor<&'a mut Vec<u8>>, FieldId>,
+    index: &'a mut DocumentsBatchIndex,
+    writer: W,
+    buffer: Vec<u8>,
+}
+
+/// This implementation of SerializeMap uses serilialize_entry instead of seriliaze_key and
+/// serialize_value, therefore these to methods remain unimplemented.
+impl<'a, W: io::Write> SerializeMap for MapSerializer<'a, W> {
+    type Ok = ();
+    type Error = Error;
+
+    fn serialize_key<T: ?Sized + Serialize>(&mut self, _key: &T) -> Result<(), Self::Error> {
+        unreachable!()
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error> {
+        unreachable!()
+    }
+
+    fn end(mut self) -> Result<Self::Ok, Self::Error> {
+        let data = self.map.into_inner().map_err(Error::Io)?.into_inner();
+        let data_len: u32 = data.len().try_into().map_err(|_| Error::DocumentTooLarge)?;
+
+        self.writer.write_u32::<BigEndian>(data_len).map_err(Error::Io)?;
+        self.writer.write_all(&data).map_err(Error::Io)?;
+
+        Ok(())
+    }
+
+    fn serialize_entry<K: ?Sized, V: ?Sized>(
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<(), Self::Error>
+    where
+        K: Serialize,
+        V: Serialize,
+    {
+        let field_serializer = FieldSerializer { index: &mut self.index };
+        let field_id: FieldId = key.serialize(field_serializer)?;
+
+        self.buffer.clear();
+        let mut cursor = io::Cursor::new(&mut self.buffer);
+        serde_json::to_writer(&mut cursor, value).map_err(Error::JsonError)?;
+
+        self.map.insert(field_id, cursor.into_inner()).map_err(Error::Io)?;
+
+        Ok(())
+    }
+}
+
+struct FieldSerializer<'a> {
+    index: &'a mut DocumentsBatchIndex,
+}
+
+impl<'a> serde::Serializer for FieldSerializer<'a> {
+    type Ok = FieldId;
+
+    type Error = Error;
+
+    type SerializeSeq = Impossible<FieldId, Self::Error>;
+    type SerializeTuple = Impossible<FieldId, Self::Error>;
+    type SerializeTupleStruct = Impossible<FieldId, Self::Error>;
+    type SerializeTupleVariant = Impossible<FieldId, Self::Error>;
+    type SerializeMap = Impossible<FieldId, Self::Error>;
+    type SerializeStruct = Impossible<FieldId, Self::Error>;
+    type SerializeStructVariant = Impossible<FieldId, Self::Error>;
+
+    fn serialize_str(self, ws: &str) -> Result<Self::Ok, Self::Error> {
+        let field_id = match self.index.get_by_right(ws) {
+            Some(field_id) => *field_id,
+            None => {
+                let field_id = self.index.len() as FieldId;
+                self.index.insert(field_id, ws.to_string());
+                field_id
+            }
+        };
+
+        Ok(field_id)
+    }
+
+    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    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(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        Err(Error::InvalidDocumentFormat)
+    }
+}
+
+impl serde::ser::Error for Error {
+    fn custom<T: fmt::Display>(msg: T) -> Self {
+        Error::Custom(msg.to_string())
+    }
+}