Support prepare statement

Author: wyhaya

README.md

@@ -23,6 +23,7 @@ fn main() {
 ```
 
 ## TODO
+* NULL value
 * Add more apis
 * Windows support
 * Dynamic link crossdb

src/error.rs

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

src/lib.rs

@@ -18,8 +18,10 @@ pub use error::{Error, Result};
 pub use value::Value;
 
 use crossdb_sys::*;
+use params::{IntoParams, Value as ParamValue};
 use std::ffi::{CStr, CString};
 use std::fmt::Display;
+mod params;
 
 #[derive(Debug)]
 pub struct Connection {
@@ -60,23 +62,55 @@ impl Connection {
     }
 
     pub fn begin(&self) -> bool {
+        unsafe { xdb_begin(self.ptr) == 0 }
+    }
+
+    pub fn commit(&self) -> bool {
+        unsafe { xdb_commit(self.ptr) == 0 }
+    }
+
+    pub fn rollback(&self) -> bool {
+        unsafe { xdb_rollback(self.ptr) == 0 }
+    }
+
+    // TODO: LRU cache
+    pub fn prepare<S: AsRef<str>>(&mut self, sql: S) -> Result<Stmt> {
         unsafe {
-            let status = xdb_begin(self.ptr);
-            status as u32 == xdb_errno_e_XDB_OK
+            let sql = CString::new(sql.as_ref())?;
+            let ptr = xdb_stmt_prepare(self.ptr, sql.as_ptr());
+            Ok(Stmt { ptr })
         }
     }
+}
 
-    pub fn commit(&self) -> bool {
+pub struct Stmt {
+    ptr: *mut xdb_stmt_t,
+}
+
+impl Drop for Stmt {
+    fn drop(&mut self) {
         unsafe {
-            let status = xdb_commit(self.ptr);
-            status as u32 == xdb_errno_e_XDB_OK
+            xdb_stmt_close(self.ptr);
         }
     }
+}
 
-    pub fn rollback(&self) -> bool {
+impl Stmt {
+    pub fn exec(&self, params: impl IntoParams) -> Result<ExecResult> {
         unsafe {
-            let status = xdb_rollback(self.ptr);
-            status as u32 == xdb_errno_e_XDB_OK
+            let ret = xdb_clear_bindings(self.ptr);
+            if ret != 0 {
+                return Err(Error::ClearBindings);
+            }
+            params.into_params()?.bind(self.ptr)?;
+            let ptr = xdb_stmt_exec(self.ptr);
+            let res = *ptr;
+            if res.errcode as u32 != xdb_errno_e_XDB_OK {
+                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 })
         }
     }
 }
@@ -109,7 +143,7 @@ impl ExecResult {
         self.res.affected_rows
     }
 
-    pub fn column_name<'a>(&'a self, i: usize) -> &'a str {
+    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()

src/params.rs

@@ -0,0 +1,138 @@
+use crate::*;
+
+pub enum Value {
+    Int(i32),
+    Int64(i64),
+    Float(f32),
+    Double(f64),
+    String(String),
+}
+
+trait IntoValue {
+    fn into_value(self) -> Result<Value>;
+}
+
+macro_rules! impl_value {
+    ($t: ty, $v: ident) => {
+        impl IntoValue for $t {
+            fn into_value(self) -> Result<Value> {
+                Ok(Value::$v(self as _))
+            }
+        }
+    };
+}
+impl_value!(i8, Int);
+impl_value!(u8, Int);
+impl_value!(i16, Int);
+impl_value!(u16, Int);
+impl_value!(i32, Int);
+impl_value!(u32, Int);
+impl_value!(u64, Int64);
+impl_value!(i64, Int64);
+impl_value!(f32, Float);
+impl_value!(f64, Double);
+impl_value!(String, String);
+
+impl IntoValue for &str {
+    fn into_value(self) -> Result<Value> {
+        Ok(Value::String(self.into()))
+    }
+}
+
+impl IntoValue for Value {
+    fn into_value(self) -> Result<Value> {
+        Ok(self)
+    }
+}
+
+pub enum Params {
+    None,
+    Positional(Vec<Value>),
+}
+
+impl Params {
+    pub(crate) unsafe fn bind(self, ptr: *mut xdb_stmt_t) -> Result<()> {
+        if let Params::Positional(params) = self {
+            for (i, p) in params.into_iter().enumerate() {
+                let i = i as u16 + 1;
+                let ret = match p {
+                    ParamValue::Int(v) => xdb_bind_int(ptr, i, v),
+                    ParamValue::Int64(v) => xdb_bind_int64(ptr, i, v),
+                    ParamValue::Float(v) => xdb_bind_float(ptr, i, v),
+                    ParamValue::Double(v) => xdb_bind_double(ptr, i, v),
+                    ParamValue::String(v) => xdb_bind_str(ptr, i, CString::new(v)?.as_ptr()),
+                };
+                if ret != 0 {
+                    return Err(Error::BindParams);
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+pub trait IntoParams {
+    fn into_params(self) -> Result<Params>;
+}
+
+impl IntoParams for () {
+    fn into_params(self) -> Result<Params> {
+        Ok(Params::None)
+    }
+}
+
+impl IntoParams for Params {
+    fn into_params(self) -> Result<Params> {
+        Ok(self)
+    }
+}
+
+impl<T: IntoValue> IntoParams for Vec<T> {
+    fn into_params(self) -> Result<Params> {
+        let mut params = Vec::with_capacity(self.len());
+        for param in self {
+            params.push(param.into_value()?);
+        }
+        Ok(Params::Positional(params))
+    }
+}
+
+impl<T: IntoValue + Clone> IntoParams for &[T] {
+    fn into_params(self) -> Result<Params> {
+        self.to_vec().into_params()
+    }
+}
+
+impl<T: IntoValue + Clone, const N: usize> IntoParams for &[T; N] {
+    fn into_params(self) -> Result<Params> {
+        self.to_vec().into_params()
+    }
+}
+
+// Copy from:https://github.com/tursodatabase/libsql/blob/main/libsql/src/params.rs#L206-L207
+macro_rules! tuple_into_params {
+    ($count:literal : $(($field:tt $ftype:ident)),* $(,)?) => {
+        impl<$($ftype,)*> IntoParams for ($($ftype,)*) where $($ftype: IntoValue,)* {
+            fn into_params(self) -> Result<Params> {
+                let params = Params::Positional(vec![$(self.$field.into_value()?),*]);
+                Ok(params)
+            }
+        }
+    }
+}
+tuple_into_params!(1: (0 A));
+tuple_into_params!(2: (0 A), (1 B));
+tuple_into_params!(3: (0 A), (1 B), (2 C));
+tuple_into_params!(4: (0 A), (1 B), (2 C), (3 D));
+tuple_into_params!(5: (0 A), (1 B), (2 C), (3 D), (4 E));
+tuple_into_params!(6: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F));
+tuple_into_params!(7: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G));
+tuple_into_params!(8: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H));
+tuple_into_params!(9: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I));
+tuple_into_params!(10: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J));
+tuple_into_params!(11: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K));
+tuple_into_params!(12: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L));
+tuple_into_params!(13: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M));
+tuple_into_params!(14: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N));
+tuple_into_params!(15: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N), (14 O));
+tuple_into_params!(16: (0 A), (1 B), (2 C), (3 D), (4 E), (5 F), (6 G), (7 H), (8 I), (9 J), (10 K), (11 L), (12 M), (13 N), (14 O), (15 P));