Upgrade crossdb to v0.12.0

Author: wyhaya

Cargo.toml

@@ -9,13 +9,13 @@ homepage = "hhttps://github.com/crossdb-org/crossdb-rust"
 repository = "https://github.com/crossdb-org/crossdb-rust.git"
 
 [dependencies]
-lru = "0.12"
+lru = "0.14"
 serde = "1.0"
-thiserror = "1.0"
-strum = { version = "0.26", features = ["derive"] }
-cidr = "0.3.0"
-mac_address = "1.1.7"
+thiserror = "2.0"
+strum = { version = "0.27", features = ["derive"] }
+cidr = "0.3"
+mac_address = "1.1"
 
 [build-dependencies]
-bindgen = "0.70"
-cc = "1.1"
+bindgen = "0.71"
+cc = "1.2"

crossdb

@@ -45,13 +45,15 @@ pub enum DataType {
     Inet = xdb_type_t_XDB_TYPE_INET,
     #[strum(serialize = "MAC")]
     Mac = xdb_type_t_XDB_TYPE_MAC,
+    #[strum(serialize = "ARRAY")]
+    Array = xdb_type_t_XDB_TYPE_ARRAY,
     #[strum(serialize = "MAX")]
     Max = xdb_type_t_XDB_TYPE_MAX,
 }
 
 impl DataType {
-    unsafe fn from_meta(meta: u64, col: u16) -> Self {
-        let t = xdb_column_type(meta, col);
+    unsafe fn from_meta(ptr: *mut xdb_res_t, col: u16) -> Self {
+        let t = xdb_column_type(ptr, col);
         match Self::from_repr(t) {
             Some(t) => t,
             None => unreachable!(),
@@ -66,15 +68,15 @@ pub struct Columns {
 
 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 {
+        let count = xdb_column_count(ptr);
+        let mut columns = Vec::with_capacity(count as usize);
+        for i in 0..(count as u16) {
             unsafe {
-                let name = CStr::from_ptr(xdb_column_name(res.col_meta, i))
+                let name = CStr::from_ptr(xdb_column_name(ptr, i))
                     .to_str()
                     .unwrap()
                     .to_string();
-                let datatype = DataType::from_meta(res.col_meta, i);
+                let datatype = DataType::from_meta(ptr, i);
                 columns.push(Column::new(name, datatype));
             }
         }
@@ -83,6 +85,7 @@ impl Columns {
         }
     }
 
+    #[allow(clippy::len_without_is_empty)]
     pub fn len(&self) -> usize {
         self.inner.len()
     }

src/column.rs

@@ -9,7 +9,7 @@ pub enum Error {
     #[error("UTF8 error: {0}")]
     Utf8(#[from] std::str::Utf8Error),
     #[error("Query error: {0}, {1}")]
-    Query(u16, String),
+    Query(u32, String),
     #[error("Clear bindings error")]
     ClearBindings,
     #[error("Bind params error")]

src/error.rs

@@ -123,7 +123,6 @@ impl Connection {
 
 #[derive(Debug)]
 pub struct Query {
-    res: xdb_res_t,
     ptr: *mut xdb_res_t,
     columns: Columns,
 }
@@ -141,28 +140,27 @@ unsafe impl Sync for Query {}
 
 impl Query {
     pub(crate) unsafe fn from_res(ptr: *mut xdb_res_t) -> Result<Self> {
-        let res = *ptr;
-        if res.errcode != xdb_errno_e_XDB_OK as u16 {
+        let code = xdb_errcode(ptr);
+        if code != xdb_errno_e_XDB_OK {
             let msg = CStr::from_ptr(xdb_errmsg(ptr)).to_str()?.to_string();
-            return Err(Error::Query(res.errcode, msg));
+            return Err(Error::Query(code, msg));
         }
         Ok(Self {
-            res,
             ptr,
             columns: Columns::from_res(ptr),
         })
     }
 
     pub fn column_count(&self) -> usize {
-        self.res.col_count as usize
+        unsafe { xdb_column_count(self.ptr) as usize }
     }
 
     pub fn row_count(&self) -> usize {
-        self.res.row_count as usize
+        unsafe { xdb_row_count(self.ptr) as usize }
     }
 
     pub fn affected_rows(&self) -> u64 {
-        self.res.affected_rows
+        unsafe { xdb_affected_rows(self.ptr) as u64 }
     }
 
     pub fn columns(&self) -> &Columns {
@@ -179,7 +177,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<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()?);
@@ -189,14 +187,14 @@ impl Query {
 
     fn inner_fetch_row_values(&mut self) -> Option<Vec<Value<'_>>> {
         unsafe {
-            let row = xdb_fetch_row(self.ptr);
+            let row: *mut c_void = xdb_fetch_row(self.ptr);
             if row.is_null() {
                 return None;
             }
-            let mut values = Vec::with_capacity(self.column_count());
-            let iter = from_raw_parts(row, self.column_count()).iter().enumerate();
+            let count = self.columns.len();
+            let mut values = Vec::with_capacity(count);
+            let iter = from_raw_parts(row, count).iter().enumerate();
             for (i, ptr) in iter {
-                let ptr = *ptr as *const c_void;
                 values.push(Value::from_ptr(ptr, self.columns.datatype(i)));
             }
             Some(values)

src/lib.rs

@@ -20,6 +20,7 @@ pub enum Value<'a> {
     Bool(bool),
     Inet(IpInet),
     Mac(MacAddress),
+    // TODO: Array
 }
 
 impl Display for Value<'_> {
@@ -42,7 +43,7 @@ impl Display for Value<'_> {
     }
 }
 
-impl<'a> Value<'a> {
+impl Value<'_> {
     pub(crate) unsafe fn from_ptr(ptr: *const c_void, t: DataType) -> Self {
         if ptr.is_null() {
             return Self::Null;
@@ -96,6 +97,7 @@ impl<'a> Value<'a> {
                     MacAddress::new([bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]]);
                 Self::Mac(address)
             }
+            DataType::Array => todo!(),
             DataType::Max => todo!(),
         }
     }