Refactor: Implements serde::de::Deserializer and serde::ser::Serializer for RawJsonb

Author: b41sh

Cargo.toml

@@ -30,9 +30,11 @@ byteorder = "1.5.0"
 fast-float2 = "0.2.3"
 itoa = "1.0"
 nom = "7.1.3"
+num-traits = "0.2.19"
 ordered-float = { version = "4.5", default-features = false }
 rand = { version = "0.8.5", features = ["small_rng"] }
 ryu = "1.0"
+serde = "1.0"
 serde_json = { version = "1.0", default-features = false, features = ["std"] }
 
 [dev-dependencies]
@@ -44,7 +46,9 @@ mockalloc = "0.1.2"
 criterion = "0.5.1"
 
 [features]
-default = ["serde_json/preserve_order"]
+default = ["databend", "serde_json/preserve_order"]
+databend = []
+sqlite = []
 
 [[bench]]
 name = "parser"

src/de.rs

@@ -53,7 +53,7 @@ use super::value::Value;
 ///    Decode can be executed recursively.
 ///
 ///    Decode `JSONB` Value from binary bytes.
-pub fn from_slice(buf: &[u8]) -> Result<Value<'_>, Error> {
+pub fn from_slice(buf: &[u8]) -> Result<Value<'_>> {
     let mut decoder = Decoder::new(buf);
     match decoder.decode() {
         Ok(value) => Ok(value),
@@ -62,7 +62,7 @@ pub fn from_slice(buf: &[u8]) -> Result<Value<'_>, Error> {
     }
 }
 
-pub fn parse_jsonb(buf: &[u8]) -> Result<Value<'_>, Error> {
+pub fn parse_jsonb(buf: &[u8]) -> Result<Value<'_>> {
     let mut decoder = Decoder::new(buf);
     decoder.decode()
 }
@@ -77,7 +77,7 @@ impl<'a> Decoder<'a> {
         Self { buf }
     }
 
-    pub fn decode(&mut self) -> Result<Value<'a>, Error> {
+    pub fn decode(&mut self) -> Result<Value<'a>> {
         // Valid `JSONB` Value has at least one `Header`
         if self.buf.len() < 4 {
             return Err(Error::InvalidJsonb);
@@ -89,7 +89,7 @@ impl<'a> Decoder<'a> {
     // Read value type from the `Header`
     // `Scalar` has one `JEntry`
     // `Array` and `Object` store the numbers of elements
-    fn decode_jsonb(&mut self) -> Result<Value<'a>, Error> {
+    fn decode_jsonb(&mut self) -> Result<Value<'a>> {
         let container_header = self.buf.read_u32::<BigEndian>()?;
 
         match container_header & CONTAINER_HEADER_TYPE_MASK {
@@ -109,7 +109,7 @@ impl<'a> Decoder<'a> {
     // `Number` and `String` `JEntry` stores the length or offset of the data,
     // read them and decode to the `Value`
     // `Array` and `Object` need to read nested data from the lower-level `Header`
-    fn decode_scalar(&mut self, jentry: JEntry) -> Result<Value<'a>, Error> {
+    fn decode_scalar(&mut self, jentry: JEntry) -> Result<Value<'a>> {
         match jentry.type_code {
             NULL_TAG => Ok(Value::Null),
             TRUE_TAG => Ok(Value::Bool(true)),
@@ -135,7 +135,7 @@ impl<'a> Decoder<'a> {
 
     // Decode the numbers of values from the `Header`,
     // then read all `JEntries`, finally decode the `Value` by `JEntry`
-    fn decode_array(&mut self, container_header: u32) -> Result<Value<'a>, Error> {
+    fn decode_array(&mut self, container_header: u32) -> Result<Value<'a>> {
         let length = (container_header & CONTAINER_HEADER_LEN_MASK) as usize;
         let jentries = self.decode_jentries(length)?;
         let mut values: Vec<Value> = Vec::with_capacity(length);
@@ -151,7 +151,7 @@ impl<'a> Decoder<'a> {
 
     // The basic process is the same as that of `Array`
     // but first decode the keys and then decode the values
-    fn decode_object(&mut self, container_header: u32) -> Result<Value<'a>, Error> {
+    fn decode_object(&mut self, container_header: u32) -> Result<Value<'a>> {
         let length = (container_header & CONTAINER_HEADER_LEN_MASK) as usize;
         let mut jentries = self.decode_jentries(length * 2)?;
 
@@ -178,7 +178,7 @@ impl<'a> Decoder<'a> {
     }
 
     // Decode `JEntries` for `Array` and `Object`
-    fn decode_jentries(&mut self, length: usize) -> Result<VecDeque<JEntry>, Error> {
+    fn decode_jentries(&mut self, length: usize) -> Result<VecDeque<JEntry>> {
         let mut jentries: VecDeque<JEntry> = VecDeque::with_capacity(length);
         for _ in 0..length {
             let encoded = self.buf.read_u32::<BigEndian>()?;

src/error.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use core::fmt::Display;
+use serde::{de, ser};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ParseErrorCode {
@@ -34,6 +35,8 @@ pub enum ParseErrorCode {
     UnexpectedEndOfHexEscape,
 }
 
+pub type Result<T> = std::result::Result<T, Error>;
+
 impl Display for ParseErrorCode {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         match *self {
@@ -88,19 +91,47 @@ pub enum Error {
     InvalidJsonType,
     InvalidObject,
     ObjectDuplicateKey,
+    UnexpectedType,
 
+    Message(String),
     Syntax(ParseErrorCode, usize),
 }
 
+impl ser::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+}
+
+impl de::Error for Error {
+    fn custom<T: Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+}
+
 impl Display for Error {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
+            Error::Message(m) => write!(f, "{}", m),
             Error::Syntax(code, pos) => write!(f, "{}, pos {}", code, pos),
             _ => write!(f, "{:?}", self),
         }
     }
 }
 
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        //match self {
+        //    Error::JsonError(e) => Some(e),
+        //    Error::Json5Error(e) => Some(e),
+        //    Error::Io(e) => Some(e),
+        //    Error::Utf8(e) => Some(e),
+        //    _ => None,
+        //}
+        None
+    }
+}
+
 impl From<std::io::Error> for Error {
     fn from(_error: std::io::Error) -> Self {
         Error::InvalidUtf8

src/functions/array.rs

@@ -14,7 +14,6 @@
 
 // This file contains functions that specifically operate on JSONB array values.
 
-use core::convert::TryInto;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::VecDeque;
@@ -27,8 +26,14 @@ use crate::functions::core::read_u32;
 use crate::iterator::iterate_array;
 use crate::jentry::JEntry;
 
+use serde::ser::SerializeSeq;
+use serde::Serializer;
+
 use crate::OwnedJsonb;
 use crate::RawJsonb;
+use crate::ValueType;
+
+use crate::Serializer as JsonbSerializer;
 
 impl OwnedJsonb {
     /// Builds a JSONB array from a collection of RawJsonb values.
@@ -72,38 +77,17 @@ impl OwnedJsonb {
     /// let result = OwnedJsonb::build_array([invalid_data.as_raw()].into_iter());
     /// assert!(result.is_err());
     /// ```
-    pub fn build_array<'a>(
-        items: impl IntoIterator<Item = RawJsonb<'a>>,
-    ) -> Result<OwnedJsonb, Error> {
-        let mut jentries = Vec::new();
-        let mut data = Vec::new();
-        for value in items.into_iter() {
-            let header = read_u32(value.data, 0)?;
-            let encoded_jentry = match header & CONTAINER_HEADER_TYPE_MASK {
-                SCALAR_CONTAINER_TAG => {
-                    let jentry = &value.data[4..8];
-                    data.extend_from_slice(&value.data[8..]);
-                    jentry.try_into().unwrap()
-                }
-                ARRAY_CONTAINER_TAG | OBJECT_CONTAINER_TAG => {
-                    data.extend_from_slice(value.data);
-                    (CONTAINER_TAG | value.data.len() as u32).to_be_bytes()
-                }
-                _ => return Err(Error::InvalidJsonbHeader),
-            };
-            jentries.push(encoded_jentry);
+    pub fn build_array<'a>(items: impl IntoIterator<Item = RawJsonb<'a>>) -> Result<OwnedJsonb> {
+        // TODO
+        let len = 3;
+        let mut serializer = JsonbSerializer::default();
+        let mut seq = serializer.serialize_seq(Some(len))?;
+
+        for item in items.into_iter() {
+            seq.serialize_element(&item)?;
         }
-        let len = jentries.len();
-        // reserve space for header, jentries and value data
-        let mut buf = Vec::with_capacity(data.len() + len * 4 + 4);
-        // write header
-        let header = ARRAY_CONTAINER_TAG | (len as u32);
-        buf.extend_from_slice(&header.to_be_bytes());
-        // write jentries
-        for jentry in jentries.into_iter() {
-            buf.extend_from_slice(&jentry);
-        }
-        buf.extend_from_slice(&data);
+        let _ = seq.end();
+        let buf = serializer.buffer.clone();
         Ok(OwnedJsonb::new(buf))
     }
 }
@@ -131,19 +115,13 @@ impl RawJsonb<'_> {
     /// let len = raw_jsonb.array_length().unwrap();
     /// assert_eq!(len, None);
     /// ```
-    pub fn array_length(&self) -> Result<Option<usize>, Error> {
-        let header = read_u32(self.data, 0)?;
-        let len = match header & CONTAINER_HEADER_TYPE_MASK {
-            ARRAY_CONTAINER_TAG => {
-                let length = (header & CONTAINER_HEADER_LEN_MASK) as usize;
-                Some(length)
-            }
-            OBJECT_CONTAINER_TAG | SCALAR_CONTAINER_TAG => None,
-            _ => {
-                return Err(Error::InvalidJsonb);
-            }
-        };
-        Ok(len)
+    pub fn array_length(&self) -> Result<Option<usize>> {
+        let value_type = self.value_type()?;
+        if let ValueType::Array(len) = value_type {
+            Ok(Some(len))
+        } else {
+            Ok(None)
+        }
     }
 
     /// Extracts the values from a JSONB array.
@@ -193,7 +171,7 @@ impl RawJsonb<'_> {
     /// assert!(values_result.is_ok());
     /// assert!(values_result.unwrap().is_none());
     /// ```
-    pub fn array_values(&self) -> Result<Option<Vec<OwnedJsonb>>, Error> {
+    pub fn array_values(&self) -> Result<Option<Vec<OwnedJsonb>>> {
         let header = read_u32(self.data, 0)?;
         match header & CONTAINER_HEADER_TYPE_MASK {
             ARRAY_CONTAINER_TAG => {
@@ -269,7 +247,7 @@ impl RawJsonb<'_> {
     /// let result = invalid_raw_jsonb.array_distinct();
     /// assert!(result.is_err());
     /// ```
-    pub fn array_distinct(&self) -> Result<OwnedJsonb, Error> {
+    pub fn array_distinct(&self) -> Result<OwnedJsonb> {
         let mut buf = Vec::new();
         let value = self.data;
         let header = read_u32(value, 0)?;
@@ -358,7 +336,7 @@ impl RawJsonb<'_> {
     /// let contained = scalar1.as_raw().array_intersection(scalar2.as_raw()).unwrap();
     /// assert_eq!(contained.to_string(), "[]"); // Not contained
     /// ```
-    pub fn array_intersection(&self, other: RawJsonb) -> Result<OwnedJsonb, Error> {
+    pub fn array_intersection(&self, other: RawJsonb) -> Result<OwnedJsonb> {
         let mut buf = Vec::new();
         let left = self.data;
         let right = other.data;
@@ -480,7 +458,7 @@ impl RawJsonb<'_> {
     /// let not_contained = scalar1.as_raw().array_except(scalar2.as_raw()).unwrap();
     /// assert_eq!(not_contained.to_string(), "[1]"); // Not contained
     /// ```
-    pub fn array_except(&self, other: RawJsonb) -> Result<OwnedJsonb, Error> {
+    pub fn array_except(&self, other: RawJsonb) -> Result<OwnedJsonb> {
         let mut buf = Vec::new();
         let left = self.data;
         let right = other.data;
@@ -610,7 +588,7 @@ impl RawJsonb<'_> {
     /// let result = invalid_raw_jsonb.array_overlap(arr1.as_raw());
     /// assert!(result.is_err()); // Returns an error
     /// ```
-    pub fn array_overlap(&self, other: RawJsonb) -> Result<bool, Error> {
+    pub fn array_overlap(&self, other: RawJsonb) -> Result<bool> {
         let left = self.data;
         let right = other.data;
 
@@ -729,7 +707,7 @@ impl RawJsonb<'_> {
     /// let inserted = raw_jsonb.array_insert(0, new_raw_jsonb);
     /// assert_eq!(inserted.unwrap().to_string(), "[2,1]");
     /// ```
-    pub fn array_insert(&self, pos: i32, new_val: RawJsonb) -> Result<OwnedJsonb, Error> {
+    pub fn array_insert(&self, pos: i32, new_val: RawJsonb) -> Result<OwnedJsonb> {
         let mut buf = Vec::new();
         let value = self.data;
         let new_value = new_val.data;