Support serde deserialize row

Author: wyhaya

README.md

@@ -6,28 +6,36 @@ crossdb = { git = "https://github.com/crossdb-org/crossdb-rust" }
 ```
 
 ```rs
-use crossdb::{Connection, Result};
+#[derive(Debug, serde::Deserialize)]
+struct User {
+    id: i32,
+    name: String,
+    age: Option<i8>,
+}
 
-fn main() -> Result<()> {
-    let mut conn = Connection::open_with_memory()?;
+fn main() -> crossdb::Result<()> {
+    let mut conn = crossdb::Connection::open_with_memory()?;
 
-    conn.execute("create table if not exists users(id int, name CHAR(255));")?;
-    let stmt = conn.prepare("insert into users (id, name) values (?, ?);")?;
+    conn.execute("CREATE TABLE IF NOT EXISTS users(id INT, name CHAR(255), age TINYINT);")?;
+    let stmt = conn.prepare("INSERT INTO users (id, name, age) values (?, ?, ?);")?;
 
-    stmt.execute((1, "Alex"))?;
-    stmt.execute((2, "Thorne"))?;
-    stmt.execute((3, "Ryder"))?;
+    stmt.execute((1, "Alex", 18))?;
+    stmt.execute((2, "Thorne", 22))?;
+    stmt.execute((3, "Ryder", 36))?;
 
-    let mut query = conn.query("select * from users;")?;
+    let mut query = conn.query("SELECT * FROM users;")?;
 
-    for (name, datatype) in query.columns() {
-        println!("Column : {} {}", name, datatype);
+    for col in query.columns() {
+        println!("Column: {col}");
     }
 
-    while let Some(row) = query.fetch_row() {
-        println!("User: {}, Name: {}", row.get("id"), row.get("name"));
+    while let Some(user) = query.fetch_row_as::<User>() {
+        dbg!(user);
     }
 
+    let affected_rows = conn.execute("DELETE FROM users;")?;
+    assert_eq!(affected_rows, 3);
+
     Ok(())
 }
 ```

examples/basic.rs

@@ -4,11 +4,11 @@ fn main() {
     let conn = Connection::open("test").unwrap();
     let mut query = conn.query("select * from system.databases;").unwrap();
 
-    for (name, datatype) in query.columns() {
-        println!("Column : {} {}", name, datatype);
+    for col in query.columns() {
+        println!("Column: {col}");
     }
 
     while let Some(row) = query.fetch_row() {
-        dbg!(row.values());
+        dbg!(row);
     }
 }

src/column.rs

@@ -77,7 +77,7 @@ impl DataType {
 
 #[derive(Debug, Clone)]
 pub struct Columns {
-    inner: Rc<Vec<(String, DataType)>>,
+    inner: Rc<Vec<Column>>,
 }
 
 impl Columns {
@@ -91,7 +91,7 @@ impl Columns {
                     .unwrap()
                     .to_string();
                 let datatype = DataType::from_meta(res.col_meta, i);
-                columns.push((name, datatype));
+                columns.push(Column::new(name, datatype));
             }
         }
         Self {
@@ -104,11 +104,11 @@ impl Columns {
     }
 
     pub fn name(&self, i: usize) -> &str {
-        self.inner[i].0.as_str()
+        self.inner[i].name()
     }
 
     pub fn datatype(&self, i: usize) -> DataType {
-        self.inner[i].1
+        self.inner[i].datatype()
     }
 
     pub fn iter(&self) -> ColumnsIter {
@@ -117,27 +117,53 @@ impl Columns {
         }
     }
 
-    pub fn into_inner(self) -> Option<Vec<(String, DataType)>> {
+    pub fn into_inner(self) -> Option<Vec<Column>> {
         Rc::into_inner(self.inner)
     }
 }
 
 pub struct ColumnsIter<'a> {
-    inner: Iter<'a, (String, DataType)>,
+    inner: Iter<'a, Column>,
 }
 
 impl<'a> Iterator for ColumnsIter<'a> {
-    type Item = &'a (String, DataType);
+    type Item = &'a Column;
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next()
     }
 }
 
 impl<'a> IntoIterator for &'a Columns {
-    type Item = &'a (String, DataType);
+    type Item = &'a Column;
     type IntoIter = ColumnsIter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct Column {
+    name: String,
+    datatype: DataType,
+}
+
+impl Column {
+    pub fn new(name: String, datatype: DataType) -> Self {
+        Self { name, datatype }
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn datatype(&self) -> DataType {
+        self.datatype
+    }
+}
+
+impl Display for Column {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} [{}]", self.name, self.datatype)
+    }
+}

src/de.rs

@@ -1,9 +1,18 @@
-use crate::Row;
-use serde::de::{value::Error as DeError, Error, Visitor};
-use serde::Deserializer;
+use crate::{Row, Value};
+use serde::de::{
+    self, value::Error as DeError, DeserializeSeed, Deserializer, Error, IntoDeserializer,
+    MapAccess, Visitor,
+};
 
 pub(crate) struct RowDeserializer<'de> {
-    pub(crate) row: &'de Row<'de>,
+    row: &'de Row<'de>,
+    index: usize,
+}
+
+impl<'de> RowDeserializer<'de> {
+    pub(crate) fn new(row: &'de Row<'de>) -> Self {
+        Self { row, index: 0 }
+    }
 }
 
 impl<'de> Deserializer<'de> for RowDeserializer<'de> {
@@ -20,17 +29,125 @@ impl<'de> Deserializer<'de> for RowDeserializer<'de> {
         self,
         _name: &'static str,
         _fields: &'static [&'static str],
-        _visitor: V,
+        visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
-        todo!()
+        visitor.visit_map(self)
     }
 
     serde::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
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string option
+        bytes byte_buf unit unit_struct newtype_struct seq tuple
         tuple_struct map enum identifier ignored_any
     }
 }
+
+impl<'de> MapAccess<'de> for RowDeserializer<'de> {
+    type Error = DeError;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+    where
+        K: DeserializeSeed<'de>,
+    {
+        if self.index >= self.row.columns.len() {
+            return Ok(None);
+        }
+        let name = self.row.columns.name(self.index);
+        seed.deserialize(name.into_deserializer()).map(Some)
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        if self.index >= self.row.values.len() {
+            return Err(de::Error::custom("Value index out of bounds"));
+        }
+        let value = &self.row.values[self.index];
+        let result = seed.deserialize(ValueDeserializer(value));
+        self.index += 1;
+        result
+    }
+}
+
+struct ValueDeserializer<'a>(&'a Value<'a>);
+
+impl<'de> Deserializer<'de> for ValueDeserializer<'de> {
+    type Error = DeError;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        match *self.0 {
+            Value::Null => visitor.visit_none(),
+            Value::I8(v) => visitor.visit_i8(v),
+            Value::I16(v) => visitor.visit_i16(v),
+            Value::I32(v) => visitor.visit_i32(v),
+            Value::I64(v) => visitor.visit_i64(v),
+            Value::F32(v) => visitor.visit_f32(v),
+            Value::F64(v) => visitor.visit_f64(v),
+            Value::Char(v) => visitor.visit_str(v),
+        }
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        match *self.0 {
+            Value::Null => visitor.visit_none(),
+            _ => visitor.visit_some(self),
+        }
+    }
+
+    serde::forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf unit_struct newtype_struct seq tuple
+        tuple_struct map enum identifier ignored_any struct
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::Deserialize;
+    use std::fmt::Debug;
+
+    #[test]
+    fn test_deserialize_value() {
+        fn de<'a, T: Debug + PartialEq + Deserialize<'a>>(v: &'a Value<'a>, expected: T) {
+            let v = ValueDeserializer(v);
+            assert_eq!(Deserialize::deserialize(v), Ok(expected));
+        }
+
+        de(&Value::Null, ());
+        de(&Value::Null, None::<i8>);
+        de(&Value::Null, None::<String>);
+
+        de(&Value::I8(1), 1i8);
+        de(&Value::I8(1), Some(1i8));
+        de(&Value::I8(1), Some(1_u128));
+
+        de(&Value::I16(1), 1i16);
+        de(&Value::I16(1), Some(1i16));
+        de(&Value::I16(1), Some(1_u128));
+
+        de(&Value::Char("Hello"), String::from("Hello"));
+        de(&Value::Char("Hello"), Some(String::from("Hello")));
+    }
+
+    #[test]
+    fn test_deserialize_row() {
+        // TODO
+    }
+}

src/lib.rs

@@ -17,7 +17,7 @@ mod row;
 mod statement;
 mod value;
 
-pub use column::{Columns, DataType};
+pub use column::{Column, Columns, ColumnsIter, DataType};
 pub use error::{Error, Result};
 pub use params::{IntoParams, Params, Value as ParamValue};
 pub use row::{IntoValueIndex, Row, ValueIndex};
@@ -170,7 +170,7 @@ impl Query {
         self.fetch_row().map(|row| row.deserialize())
     }
 
-    pub fn fetch_rows_as<'a, T: DeserializeOwned>(mut self) -> Result<Vec<T>, DeError> {
+    pub fn fetch_rows_as<'a, T: DeserializeOwned>(&mut self) -> Result<Vec<T>, DeError> {
         let mut rows = Vec::with_capacity(self.row_count());
         while let Some(row) = self.fetch_row() {
             rows.push(row.deserialize()?);

src/row.rs

@@ -17,22 +17,21 @@ impl Row<'_> {
     }
 
     pub fn get<'i>(&self, index: impl IntoValueIndex<'i>) -> &Value<'_> {
-        unsafe { self.try_get(index).unwrap_unchecked() }
+        self.try_get(index).expect("Row index out of bounds")
     }
 
     pub fn try_get<'i>(&self, index: impl IntoValueIndex<'i>) -> Option<&Value<'_>> {
         match index.into_index() {
             ValueIndex::ColumnName(name) => {
-                let i = self.columns.iter().position(|(n, _)| n == name)?;
+                let i = self.columns.iter().position(|c| c.name() == name)?;
                 self.values.get(i)
             }
             ValueIndex::ColumnIndex(i) => self.values.get(i),
         }
     }
 
     pub fn deserialize<T: DeserializeOwned>(&self) -> Result<T, DeError> {
-        let deserializer = RowDeserializer { row: self };
-        T::deserialize(deserializer)
+        T::deserialize(RowDeserializer::new(self))
     }
 }