More bson deserialization work

Author: simolus3

crates/core/Cargo.toml

@@ -34,7 +34,7 @@ features = []
 
 
 [features]
-default = ["getrandom"]
+default = ["getrandom", "loadable_extension"]
 
 loadable_extension = ["sqlite_nostd/loadable_extension"]
 static = ["sqlite_nostd/static"]

crates/core/src/bson/de.rs

@@ -1,28 +1,97 @@
+use core::assert_matches::debug_assert_matches;
+
 use serde::{
-    de::{self, DeserializeSeed, MapAccess, Visitor},
+    de::{
+        self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess,
+        Visitor,
+    },
     forward_to_deserialize_any,
 };
 
 use super::{
+    error::ErrorKind,
     parser::{ElementType, Parser},
     BsonError,
 };
 
 pub struct Deserializer<'de> {
     parser: Parser<'de>,
-    is_outside_of_document: bool,
-    pending_value_type: Option<ElementType>,
-    consumed_name: bool,
+    position: DeserializerPosition,
+}
+
+#[derive(Clone, Debug)]
+enum DeserializerPosition {
+    /// The deserializer is outside of the initial document header.
+    OutsideOfDocument,
+    /// The deserializer expects the beginning of a key-value pair, or the end of the current
+    /// document.
+    BeforeTypeOrAtEndOfDocument,
+    /// The deserializer has read past the type of a key-value pair, but did not scan the name yet.
+    BeforeName { pending_type: ElementType },
+    /// Read type and name of a key-value pair, position is before the value now.
+    BeforeValue { pending_type: ElementType },
 }
 
 impl<'de> Deserializer<'de> {
     pub fn outside_of_document(parser: Parser<'de>) -> Self {
         Self {
             parser,
-            is_outside_of_document: true,
-            pending_value_type: None,
-            consumed_name: false,
+            position: DeserializerPosition::OutsideOfDocument,
+        }
+    }
+
+    /// Prepares to read a value without actually reading it, returning the [ElementType] of the
+    /// upcoming key-value pair.
+    fn prepare_to_read_value(&mut self) -> Result<ElementType, BsonError> {
+        match self.position.clone() {
+            DeserializerPosition::OutsideOfDocument => {
+                // The next value we're reading is a document
+                self.position = DeserializerPosition::BeforeValue {
+                    pending_type: ElementType::Document,
+                };
+                Ok(ElementType::Document)
+            }
+            DeserializerPosition::BeforeValue { pending_type } => Ok(pending_type),
+            DeserializerPosition::BeforeTypeOrAtEndOfDocument { .. } => {
+                Err(self.parser.error(ErrorKind::InvalidStateExpectedType))
+            }
+            DeserializerPosition::BeforeName { .. } => {
+                Err(self.parser.error(ErrorKind::InvalidStateExpectedName))
+            }
+        }
+    }
+
+    /// If the deserializer is in a suitable position, read the upcoming key.
+    fn read_entry_key(&mut self) -> Result<Option<&'de str>, BsonError> {
+        match self.position.clone() {
+            DeserializerPosition::BeforeName { pending_type } => {
+                self.position = DeserializerPosition::BeforeValue {
+                    pending_type: pending_type,
+                };
+                Ok(Some(self.parser.read_cstr()?))
+            }
+            _ => Ok(None),
+        }
+    }
+
+    fn object_reader(&mut self) -> Result<BsonObject<'de>, BsonError> {
+        let parser = self.parser.document_scope()?;
+        let deserializer = Deserializer {
+            parser,
+            position: DeserializerPosition::BeforeTypeOrAtEndOfDocument,
+        };
+        Ok(BsonObject { de: deserializer })
+    }
+
+    fn advance_to_next_name(&mut self) -> Result<Option<()>, BsonError> {
+        if self.parser.end_document()? {
+            return Ok(None);
         }
+
+        self.position = DeserializerPosition::BeforeName {
+            pending_type: self.parser.read_element_type()?,
+        };
+        Ok(Some(()))
     }
 }
 
@@ -33,91 +102,185 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        // BSON always start with a document, so we need this for the outermost visit_map.
-        if self.is_outside_of_document {
-            self.parser = self.parser.document_scope()?;
-            self.is_outside_of_document = false;
+        let element_type = self.prepare_to_read_value()?;
 
-            let object = BsonObject { de: self };
-            return visitor.visit_map(object);
+        match element_type {
+            ElementType::Double => visitor.visit_f64(self.parser.read_double()?),
+            ElementType::String => visitor.visit_borrowed_str(self.parser.read_string()?),
+            ElementType::Document => {
+                let object = self.object_reader()?;
+                visitor.visit_map(object)
+            }
+            ElementType::Array => {
+                let object = self.object_reader()?;
+                visitor.visit_seq(object)
+            }
+            ElementType::Binary => {
+                let (_, bytes) = self.parser.read_binary()?;
+                visitor.visit_borrowed_bytes(bytes)
+            }
+            ElementType::ObjectId => todo!(),
+            ElementType::Boolean => visitor.visit_bool(self.parser.read_bool()?),
+            ElementType::DatetimeUtc => todo!(),
+            ElementType::Null | ElementType::Undefined => visitor.visit_none(),
+            ElementType::Int32 => visitor.visit_i32(self.parser.read_int32()?),
+            ElementType::Int64 => visitor.visit_i64(self.parser.read_int64()?),
+            ElementType::Timestamp => todo!(),
         }
+    }
 
-        if !self.consumed_name {
-            self.consumed_name = true;
-            // We've read an element type, but not the associated name. Do that now.
-            return visitor.visit_borrowed_str(self.parser.read_cstr()?);
-        }
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let Some(key) = self.read_entry_key()? else {
+            return Err(self.parser.error(ErrorKind::InvalidStateExpectedName));
+        };
 
-        if let Some(element_type) = self.pending_value_type.take() {
-            return match element_type {
-                ElementType::Double => visitor.visit_f64(self.parser.read_double()?),
-                ElementType::String => visitor.visit_borrowed_str(self.parser.read_string()?),
-                ElementType::Document => {
-                    let parser = self.parser.document_scope()?;
-                    let mut deserializer = Deserializer {
-                        parser,
-                        is_outside_of_document: false,
-                        pending_value_type: None,
-                        consumed_name: false,
-                    };
-                    let object = BsonObject {
-                        de: &mut deserializer,
-                    };
-
-                    visitor.visit_map(object)
-                }
-                ElementType::Array => todo!(),
-                ElementType::Binary => {
-                    let (_, bytes) = self.parser.read_binary()?;
-                    visitor.visit_borrowed_bytes(bytes)
-                }
-                ElementType::ObjectId => todo!(),
-                ElementType::Boolean => visitor.visit_bool(self.parser.read_bool()?),
-                ElementType::DatetimeUtc => todo!(),
-                ElementType::Null | ElementType::Undefined => visitor.visit_none(),
-                ElementType::Int32 => visitor.visit_i32(self.parser.read_int32()?),
-                ElementType::Int64 => visitor.visit_i64(self.parser.read_int64()?),
-                ElementType::Timestamp => todo!(),
-            };
+        visitor.visit_borrowed_str(key)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let kind = self.prepare_to_read_value()?;
+        match kind {
+            ElementType::String => {
+                visitor.visit_enum(self.parser.read_string()?.into_deserializer())
+            }
+            ElementType::Document => {
+                let mut object = self.object_reader()?;
+                visitor.visit_enum(object)
+            }
+            _ => Err(self.parser.error(ErrorKind::ExpectedEnum { actual: kind })),
         }
+    }
 
-        todo!()
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let kind = self.prepare_to_read_value()?;
+        match kind {
+            ElementType::Null => visitor.visit_none(),
+            _ => visitor.visit_some(self),
+        }
     }
 
     forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
+        bytes byte_buf unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct ignored_any
     }
 }
-struct BsonObject<'a, 'de: 'a> {
-    de: &'a mut Deserializer<'de>,
+
+struct BsonObject<'de> {
+    de: Deserializer<'de>,
 }
 
-impl<'de, 'a> MapAccess<'de> for BsonObject<'a, 'de> {
+impl<'de> MapAccess<'de> for BsonObject<'de> {
     type Error = BsonError;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
     where
         K: DeserializeSeed<'de>,
     {
-        if self.de.parser.end_document()? {
+        if let None = self.de.advance_to_next_name()? {
+            return Ok(None);
+        }
+        Ok(Some(seed.deserialize(&mut self.de)?))
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        seed.deserialize(&mut self.de)
+    }
+}
+
+impl<'de> SeqAccess<'de> for BsonObject<'de> {
+    type Error = BsonError;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        // Array elements are encoded as an object like `{"0": value, "1": another}`
+        if let None = self.de.advance_to_next_name()? {
             return Ok(None);
         }
 
-        self.de.pending_value_type = Some(self.de.parser.read_element_type()?);
-        self.de.consumed_name = false;
+        // Skip name
+        debug_assert_matches!(self.de.position, DeserializerPosition::BeforeName { .. });
+        self.de.read_entry_key()?;
 
-        Ok(Some(seed.deserialize(&mut *self.de)?))
+        // And deserialize value!
+        Ok(Some(seed.deserialize(&mut self.de)?))
     }
+}
 
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+impl<'de> EnumAccess<'de> for BsonObject<'de> {
+    type Error = BsonError;
+    type Variant = Self;
+
+    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
     where
         V: DeserializeSeed<'de>,
     {
-        debug_assert!(self.de.consumed_name);
-        debug_assert!(self.de.pending_value_type.is_some());
+        if let None = self.de.advance_to_next_name()? {
+            return Err(self
+                .de
+                .parser
+                .error(ErrorKind::UnexpectedEndOfDocumentForEnumVariant));
+        }
+
+        let value = seed.deserialize(&mut self.de)?;
+        Ok((value, self))
+    }
+}
+
+impl<'de> VariantAccess<'de> for BsonObject<'de> {
+    type Error = BsonError;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        // Unit variants are encoded as simple string values, which are handled directly in
+        // Deserializer::deserialize_enum.
+        Err(self.de.parser.error(ErrorKind::ExpectedString))
+    }
+
+    fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        // Newtype variants are represented as `{ NAME: VALUE }`, so we just have to deserialize the
+        // value here.
+        seed.deserialize(&mut self.de)
+    }
 
-        seed.deserialize(&mut *self.de)
+    fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        // Tuple variants are represented as `{ NAME: VALUES[] }`, so we deserialize the array here.
+        de::Deserializer::deserialize_seq(&mut self.de, visitor)
+    }
+
+    fn struct_variant<V>(
+        mut self,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        // Struct variants are represented as `{ NAME: { ... } }`, so we deserialize the struct.
+        de::Deserializer::deserialize_map(&mut self.de, visitor)
     }
 }

crates/core/src/bson/error.rs

@@ -8,6 +8,8 @@ use serde::de::{self, StdError};
 
 use crate::error::SQLiteError;
 
+use super::parser::ElementType;
+
 #[derive(Debug)]
 pub struct BsonError {
     /// Using a [Box] here keeps the size of this type as small, which makes results of this error
@@ -31,6 +33,12 @@ pub enum ErrorKind {
     UnexpectedEoF,
     InvalidEndOfDocument,
     InvalidSize,
+    InvalidStateExpectedType,
+    InvalidStateExpectedName,
+    InvalidStateExpectedValue,
+    ExpectedEnum { actual: ElementType },
+    ExpectedString,
+    UnexpectedEndOfDocumentForEnumVariant,
 }
 
 impl BsonError {