Add row struct

Author: wyhaya

Cargo.toml

@@ -9,6 +9,7 @@ homepage = "hhttps://github.com/crossdb-org/crossdb-rust"
 repository = "https://github.com/crossdb-org/crossdb-rust.git"
 
 [dependencies]
+serde = { version = "1.0.210", features = ["derive"] }
 thiserror = "1.0"
 
 [build-dependencies]

README.md

@@ -12,12 +12,12 @@ fn main() {
     let conn = Connection::open_with_memory().unwrap();
     let mut rst = conn.exec("select * from system.databases;").unwrap();
 
-    for i in 0..rst.column_count() {
-        println!("Column {i}: {} {}", rst.column_name(i), rst.column_type(i));
+    for (name, datatype) in rst.columns() {
+        println!("Column : {} {}", name, datatype);
     }
 
     while let Some(row) = rst.fetch_row() {
-        dbg!(row);
+        dbg!(row.values());
     }
 }
 ```

examples/basic.rs

@@ -4,11 +4,11 @@ fn main() {
     let conn = Connection::open("test.db").unwrap();
     let mut rst = conn.exec("select * FROM system.databases;").unwrap();
 
-    for i in 0..rst.column_count() {
-        println!("Column {i}: {} {}", rst.column_name(i), rst.column_type(i));
+    for (name, datatype) in rst.columns() {
+        println!("Column : {} {}", name, datatype);
     }
 
     while let Some(row) = rst.fetch_row() {
-        dbg!(row);
+        dbg!(row.values());
     }
 }

src/column.rs

@@ -1,8 +1,10 @@
 use crate::*;
+use std::rc::Rc;
+use std::slice::Iter;
 
 // https://crossdb.org/client/api-c/#xdb_type_t
 #[derive(Debug, Clone, Copy)]
-pub enum ColumnType {
+pub enum DataType {
     Null,
     TinyInt,
     SmallInt,
@@ -22,65 +24,120 @@ pub enum ColumnType {
     Max,
 }
 
-impl From<u32> for ColumnType {
-    #[allow(non_upper_case_globals)]
-    fn from(value: u32) -> Self {
-        match value {
-            xdb_type_t_XDB_TYPE_NULL => ColumnType::Null,
-            xdb_type_t_XDB_TYPE_TINYINT => ColumnType::TinyInt,
-            xdb_type_t_XDB_TYPE_SMALLINT => ColumnType::SmallInt,
-            xdb_type_t_XDB_TYPE_INT => ColumnType::Int,
-            xdb_type_t_XDB_TYPE_BIGINT => ColumnType::BigInt,
-            xdb_type_t_XDB_TYPE_UTINYINT => ColumnType::UTinyInt,
-            xdb_type_t_XDB_TYPE_USMALLINT => ColumnType::USmallInt,
-            xdb_type_t_XDB_TYPE_UINT => ColumnType::UInt,
-            xdb_type_t_XDB_TYPE_UBIGINT => ColumnType::UBigInt,
-            xdb_type_t_XDB_TYPE_FLOAT => ColumnType::Float,
-            xdb_type_t_XDB_TYPE_DOUBLE => ColumnType::Double,
-            xdb_type_t_XDB_TYPE_TIMESTAMP => ColumnType::Timestamp,
-            xdb_type_t_XDB_TYPE_CHAR => ColumnType::Char,
-            xdb_type_t_XDB_TYPE_BINARY => ColumnType::Binary,
-            xdb_type_t_XDB_TYPE_VCHAR => ColumnType::VChar,
-            xdb_type_t_XDB_TYPE_VBINARY => ColumnType::VBinary,
-            xdb_type_t_XDB_TYPE_MAX => ColumnType::Max,
-            _ => unreachable!(),
+impl Display for DataType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DataType::Null => write!(f, "NULL"),
+            DataType::TinyInt => write!(f, "TINYINT"),
+            DataType::SmallInt => write!(f, "SMALLINT"),
+            DataType::Int => write!(f, "INT"),
+            DataType::BigInt => write!(f, "BIGINT"),
+            DataType::UTinyInt => write!(f, "UTINYINT"),
+            DataType::USmallInt => write!(f, "USMALLINT"),
+            DataType::UInt => write!(f, "UINT"),
+            DataType::UBigInt => write!(f, "UBIGINT"),
+            DataType::Float => write!(f, "FLOAT"),
+            DataType::Double => write!(f, "DOUBLE"),
+            DataType::Timestamp => write!(f, "TIMESTAMP"),
+            DataType::Char => write!(f, "CHAR"),
+            DataType::Binary => write!(f, "BINARY"),
+            DataType::VChar => write!(f, "VCHAR"),
+            DataType::VBinary => write!(f, "VBINARY"),
+            DataType::Max => write!(f, "MAX"),
         }
     }
 }
 
-impl Display for ColumnType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ColumnType::Null => write!(f, "NULL"),
-            ColumnType::TinyInt => write!(f, "TINYINT"),
-            ColumnType::SmallInt => write!(f, "SMALLINT"),
-            ColumnType::Int => write!(f, "INT"),
-            ColumnType::BigInt => write!(f, "BIGINT"),
-            ColumnType::UTinyInt => write!(f, "UTINYINT"),
-            ColumnType::USmallInt => write!(f, "USMALLINT"),
-            ColumnType::UInt => write!(f, "UINT"),
-            ColumnType::UBigInt => write!(f, "UBIGINT"),
-            ColumnType::Float => write!(f, "FLOAT"),
-            ColumnType::Double => write!(f, "DOUBLE"),
-            ColumnType::Timestamp => write!(f, "TIMESTAMP"),
-            ColumnType::Char => write!(f, "CHAR"),
-            ColumnType::Binary => write!(f, "BINARY"),
-            ColumnType::VChar => write!(f, "VCHAR"),
-            ColumnType::VBinary => write!(f, "VBINARY"),
-            ColumnType::Max => write!(f, "MAX"),
+impl DataType {
+    #[allow(non_upper_case_globals)]
+    unsafe fn from_meta(meta: u64, col: u16) -> Self {
+        let t = xdb_column_type(meta, col);
+        match t {
+            xdb_type_t_XDB_TYPE_NULL => Self::Null,
+            xdb_type_t_XDB_TYPE_TINYINT => Self::TinyInt,
+            xdb_type_t_XDB_TYPE_SMALLINT => Self::SmallInt,
+            xdb_type_t_XDB_TYPE_INT => Self::Int,
+            xdb_type_t_XDB_TYPE_BIGINT => Self::BigInt,
+            xdb_type_t_XDB_TYPE_UTINYINT => Self::UTinyInt,
+            xdb_type_t_XDB_TYPE_USMALLINT => Self::USmallInt,
+            xdb_type_t_XDB_TYPE_UINT => Self::UInt,
+            xdb_type_t_XDB_TYPE_UBIGINT => Self::UBigInt,
+            xdb_type_t_XDB_TYPE_FLOAT => Self::Float,
+            xdb_type_t_XDB_TYPE_DOUBLE => Self::Double,
+            xdb_type_t_XDB_TYPE_TIMESTAMP => Self::Timestamp,
+            xdb_type_t_XDB_TYPE_CHAR => Self::Char,
+            xdb_type_t_XDB_TYPE_BINARY => Self::Binary,
+            xdb_type_t_XDB_TYPE_VCHAR => Self::VChar,
+            xdb_type_t_XDB_TYPE_VBINARY => Self::VBinary,
+            xdb_type_t_XDB_TYPE_MAX => Self::Max,
+            _ => unreachable!(),
         }
     }
 }
 
-impl ColumnType {
-    pub(crate) fn all(res: &xdb_res_t) -> Vec<Self> {
-        let mut vec = Vec::with_capacity(res.col_count as usize);
-        for i in 0..vec.capacity() {
+#[derive(Debug, Clone)]
+pub struct Columns {
+    inner: Rc<Vec<(String, DataType)>>,
+}
+
+impl Columns {
+    pub(crate) unsafe fn from_res(ptr: *mut xdb_res_t) -> Self {
+        let res = *ptr;
+        let mut columns = Vec::with_capacity(res.col_count as usize);
+        for i in 0..res.col_count {
             unsafe {
-                let t = xdb_column_type(res.col_meta, i as u16);
-                vec.push(Self::from(t));
+                let name = CStr::from_ptr(xdb_column_name(res.col_meta, i))
+                    .to_str()
+                    .unwrap()
+                    .to_string();
+                let datatype = DataType::from_meta(res.col_meta, i);
+                columns.push((name, datatype));
             }
         }
-        vec
+        Self {
+            inner: Rc::new(columns),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    pub fn name(&self, i: usize) -> &str {
+        self.inner[i].0.as_str()
+    }
+
+    pub fn datatype(&self, i: usize) -> DataType {
+        self.inner[i].1
+    }
+
+    pub fn iter(&self) -> ColumnsIter {
+        ColumnsIter {
+            inner: self.inner.iter(),
+        }
+    }
+
+    pub fn into_inner(self) -> Option<Vec<(String, DataType)>> {
+        Rc::into_inner(self.inner)
+    }
+}
+
+pub struct ColumnsIter<'a> {
+    inner: Iter<'a, (String, DataType)>,
+}
+
+impl<'a> Iterator for ColumnsIter<'a> {
+    type Item = &'a (String, DataType);
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+}
+
+impl<'a> IntoIterator for &'a Columns {
+    type Item = &'a (String, DataType);
+    type IntoIter = ColumnsIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
     }
 }

src/de.rs

@@ -0,0 +1,36 @@
+use crate::Row;
+use serde::de::{value::Error as DeError, Error, Visitor};
+use serde::Deserializer;
+
+pub(crate) struct RowDeserializer<'de> {
+    pub(crate) row: &'de Row<'de>,
+}
+
+impl<'de> Deserializer<'de> for RowDeserializer<'de> {
+    type Error = DeError;
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(DeError::custom("Expects a struct"))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        _visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        todo!()
+    }
+
+    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
+        tuple_struct map enum identifier ignored_any
+    }
+}

src/lib.rs

@@ -10,11 +10,14 @@ mod crossdb_sys {
 }
 
 mod column;
+mod de;
 mod error;
+mod row;
 mod value;
 
-pub use column::ColumnType;
+pub use column::{Columns, DataType};
 pub use error::{Error, Result};
+pub use row::Row;
 pub use value::Value;
 
 use crossdb_sys::*;
@@ -56,8 +59,11 @@ impl Connection {
                 let msg = CStr::from_ptr(xdb_errmsg(ptr)).to_str()?.to_string();
                 return Err(Error::Query(res.errcode, msg));
             }
-            let types = ColumnType::all(&res);
-            Ok(ExecResult { res, ptr, types })
+            Ok(ExecResult {
+                res,
+                ptr,
+                columns: Columns::from_res(ptr),
+            })
         }
     }
 
@@ -109,8 +115,11 @@ impl Stmt {
                 let msg = CStr::from_ptr(xdb_errmsg(ptr)).to_str()?.to_string();
                 return Err(Error::Query(res.errcode, msg));
             }
-            let types = ColumnType::all(&res);
-            Ok(ExecResult { res, ptr, types })
+            Ok(ExecResult {
+                res,
+                ptr,
+                columns: Columns::from_res(ptr),
+            })
         }
     }
 }
@@ -119,7 +128,7 @@ impl Stmt {
 pub struct ExecResult {
     res: xdb_res_t,
     ptr: *mut xdb_res_t,
-    types: Vec<ColumnType>,
+    columns: Columns,
 }
 
 impl Drop for ExecResult {
@@ -143,27 +152,30 @@ impl ExecResult {
         self.res.affected_rows
     }
 
-    pub fn column_name(&self, i: usize) -> &str {
-        unsafe {
-            let name = xdb_column_name(self.res.col_meta, i as u16);
-            CStr::from_ptr(name).to_str().unwrap()
-        }
+    pub fn columns(&self) -> &Columns {
+        &self.columns
     }
 
-    pub fn column_type(&self, i: usize) -> ColumnType {
-        self.types[i]
+    pub fn fetch_row(&mut self) -> Option<Row<'_>> {
+        let columns = self.columns.clone();
+        let values = self.inner_fetch_row_values()?;
+        Some(Row { columns, values })
     }
 
-    pub fn fetch_row(&mut self) -> Option<Vec<Value<'_>>> {
+    fn inner_fetch_row_values(&mut self) -> Option<Vec<Value<'_>>> {
         unsafe {
             let row = xdb_fetch_row(self.ptr);
             if row.is_null() {
                 return None;
             }
             let mut values = Vec::with_capacity(self.column_count());
             for col in 0..self.column_count() {
-                let value =
-                    Value::from_result(self.res.col_meta, row, col as u16, self.column_type(col));
+                let value = Value::from_result(
+                    self.res.col_meta,
+                    row,
+                    col as u16,
+                    self.columns.datatype(col),
+                );
                 values.push(value);
             }
             Some(values)