Use LRU cache for SQL statement

Author: wyhaya

.gitignore

@@ -3,4 +3,4 @@ Cargo.lock
 **/*.rs.bk
 *.pdb
 .DS_Store
-test.db/
+test/

Cargo.toml

@@ -9,6 +9,7 @@ homepage = "hhttps://github.com/crossdb-org/crossdb-rust"
 repository = "https://github.com/crossdb-org/crossdb-rust.git"
 
 [dependencies]
+lru = "0.12"
 serde = "1.0"
 thiserror = "1.0"
 

README.md

@@ -6,25 +6,35 @@ crossdb = { git = "https://github.com/crossdb-org/crossdb-rust" }
 ```
 
 ```rs
-use crossdb::Connection;
+use crossdb::{Connection, Result};
 
-fn main() {
-    let conn = Connection::open_with_memory().unwrap();
-    let mut rst = conn.exec("select * from system.databases;").unwrap();
+fn main() -> Result<()> {
+    let mut conn = Connection::open_with_memory()?;
 
-    for (name, datatype) in rst.columns() {
+    conn.execute("create table if not exists users(id int, name CHAR(255));")?;
+    let stmt = conn.prepare("insert into users (id, name) values (?, ?);")?;
+
+    stmt.execute((1, "Alex"))?;
+    stmt.execute((2, "Thorne"))?;
+    stmt.execute((3, "Ryder"))?;
+
+    let mut query = conn.query("select * from users;")?;
+
+    for (name, datatype) in query.columns() {
         println!("Column : {} {}", name, datatype);
     }
 
-    while let Some(row) = rst.fetch_row() {
-        dbg!(row.values());
+    while let Some(row) = query.fetch_row() {
+        println!("User: {}, Name: {}", row.get("id"), row.get("name"));
     }
+
+    Ok(())
 }
 ```
 
 ## TODO
-* NULL value
-* Add more apis
-* Windows support
-* Dynamic link crossdb
-* use serde to serialize/deserialize
+
+- NULL value
+- Windows support
+- Dynamic link crossdb
+- use serde to serialize/deserialize

examples/basic.rs

@@ -1,14 +1,14 @@
 use crossdb::Connection;
 
 fn main() {
-    let conn = Connection::open("test.db").unwrap();
-    let mut rst = conn.exec("select * FROM system.databases;").unwrap();
+    let conn = Connection::open("test").unwrap();
+    let mut query = conn.query("select * from system.databases;").unwrap();
 
-    for (name, datatype) in rst.columns() {
+    for (name, datatype) in query.columns() {
         println!("Column : {} {}", name, datatype);
     }
 
-    while let Some(row) = rst.fetch_row() {
+    while let Some(row) = query.fetch_row() {
         dbg!(row.values());
     }
 }

src/lib.rs

@@ -13,24 +13,32 @@ mod column;
 mod de;
 mod error;
 mod row;
+mod statement;
 mod value;
 
 pub use column::{Columns, DataType};
 pub use error::{Error, Result};
-pub use row::Row;
+pub use params::{IntoParams, Params, Value as ParamValue};
+pub use row::{IntoValueIndex, Row, ValueIndex};
+pub use statement::Statement;
 pub use value::Value;
 
 use crossdb_sys::*;
-use params::{IntoParams, Value as ParamValue};
+use lru::LruCache;
 use std::ffi::{CStr, CString};
 use std::fmt::Display;
+use std::num::NonZeroUsize;
 mod params;
 
 #[derive(Debug)]
 pub struct Connection {
     ptr: *mut xdb_conn_t,
+    cache: LruCache<CString, Statement>,
 }
 
+unsafe impl Send for Connection {}
+unsafe impl Sync for Connection {}
+
 impl Drop for Connection {
     fn drop(&mut self) {
         unsafe {
@@ -43,30 +51,29 @@ impl Connection {
     pub fn open<P: AsRef<str>>(path: P) -> Result<Self> {
         let path = CString::new(path.as_ref())?;
         let ptr = unsafe { xdb_open(path.as_ptr()) };
-        Ok(Self { ptr })
+        let cap = NonZeroUsize::new(256).unwrap();
+        Ok(Self {
+            ptr,
+            cache: LruCache::new(cap),
+        })
     }
 
     pub fn open_with_memory() -> Result<Self> {
         Self::open(":memory:")
     }
 
-    pub fn exec<S: AsRef<str>>(&self, sql: S) -> Result<ExecResult> {
+    pub fn query<S: AsRef<str>>(&self, sql: S) -> Result<Query> {
         let sql = CString::new(sql.as_ref())?;
         unsafe {
             let ptr = xdb_exec(self.ptr, sql.as_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));
-            }
-            Ok(ExecResult {
-                res,
-                ptr,
-                columns: Columns::from_res(ptr),
-            })
+            Query::from_res(ptr)
         }
     }
 
+    pub fn execute<S: AsRef<str>>(&self, sql: S) -> Result<u64> {
+        self.query(sql).map(|q| q.affected_rows())
+    }
+
     pub fn begin(&self) -> bool {
         unsafe { xdb_begin(self.ptr) == 0 }
     }
@@ -79,67 +86,53 @@ impl Connection {
         unsafe { xdb_rollback(self.ptr) == 0 }
     }
 
-    // TODO: LRU cache
-    pub fn prepare<S: AsRef<str>>(&mut self, sql: S) -> Result<Stmt> {
-        unsafe {
-            let sql = CString::new(sql.as_ref())?;
-            let ptr = xdb_stmt_prepare(self.ptr, sql.as_ptr());
-            Ok(Stmt { ptr })
-        }
-    }
-}
-
-pub struct Stmt {
-    ptr: *mut xdb_stmt_t,
-}
-
-impl Drop for Stmt {
-    fn drop(&mut self) {
-        unsafe {
-            xdb_stmt_close(self.ptr);
-        }
+    pub fn prepare<S: AsRef<str>>(&mut self, sql: S) -> Result<&Statement> {
+        let sql = CString::new(sql.as_ref())?;
+        let sql_ptr = sql.as_ptr();
+        let stmt = self.cache.get_or_insert(sql, || {
+            let ptr = unsafe { xdb_stmt_prepare(self.ptr, sql_ptr) };
+            Statement { ptr }
+        });
+        Ok(stmt)
     }
-}
 
-impl Stmt {
-    pub fn exec(&self, params: impl IntoParams) -> Result<ExecResult> {
-        unsafe {
-            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));
-            }
-            Ok(ExecResult {
-                res,
-                ptr,
-                columns: Columns::from_res(ptr),
-            })
-        }
+    pub fn clear_statement_cache(&mut self) {
+        self.cache.clear();
     }
 }
 
 #[derive(Debug)]
-pub struct ExecResult {
+pub struct Query {
     res: xdb_res_t,
     ptr: *mut xdb_res_t,
     columns: Columns,
 }
 
-impl Drop for ExecResult {
+impl Drop for Query {
     fn drop(&mut self) {
         unsafe {
             xdb_free_result(self.ptr);
         }
     }
 }
 
-impl ExecResult {
+unsafe impl Send for Query {}
+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 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));
+        }
+        Ok(Self {
+            res,
+            ptr,
+            columns: Columns::from_res(ptr),
+        })
+    }
+
     pub fn column_count(&self) -> usize {
         self.res.col_count as usize
     }

src/params.rs

@@ -46,25 +46,23 @@ impl IntoValue for Value {
 }
 
 pub enum Params {
-    None,
+    Empty,
     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);
-                }
+    pub(crate) unsafe fn bind(ptr: *mut xdb_stmt_t, params: Vec<Value>) -> Result<()> {
+        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(())
@@ -77,7 +75,7 @@ pub trait IntoParams {
 
 impl IntoParams for () {
     fn into_params(self) -> Result<Params> {
-        Ok(Params::None)
+        Ok(Params::Empty)
     }
 }
 

src/row.rs

@@ -16,7 +16,11 @@ impl Row<'_> {
         &self.values
     }
 
-    pub fn get<'i>(&self, index: impl IntoValueIndex<'i>) -> Option<&Value<'_>> {
+    pub fn get<'i>(&self, index: impl IntoValueIndex<'i>) -> &Value<'_> {
+        unsafe { self.try_get(index).unwrap_unchecked() }
+    }
+
+    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)?;
@@ -27,7 +31,7 @@ impl Row<'_> {
     }
 
     pub fn deserialize<T: DeserializeOwned>(&self) -> Result<T, DeError> {
-        let deserializer = RowDeserializer { row: &self };
+        let deserializer = RowDeserializer { row: self };
         T::deserialize(deserializer)
     }
 }

src/statement.rs

@@ -0,0 +1,43 @@
+use params::Params;
+
+use crate::*;
+
+pub struct Statement {
+    pub(crate) ptr: *mut xdb_stmt_t,
+}
+
+impl Drop for Statement {
+    fn drop(&mut self) {
+        unsafe {
+            xdb_stmt_close(self.ptr);
+        }
+    }
+}
+
+impl Statement {
+    pub fn query(&self, params: impl IntoParams) -> Result<Query> {
+        unsafe {
+            let params = params.into_params()?;
+            if let Params::Positional(params) = params {
+                if !params.is_empty() {
+                    self.clear_bindings()?;
+                    Params::bind(self.ptr, params)?;
+                }
+            }
+            let ptr = xdb_stmt_exec(self.ptr);
+            Query::from_res(ptr)
+        }
+    }
+
+    pub fn execute(&self, params: impl IntoParams) -> Result<u64> {
+        self.query(params).map(|q| q.affected_rows())
+    }
+
+    pub fn clear_bindings(&self) -> Result<()> {
+        let ret = unsafe { xdb_clear_bindings(self.ptr) };
+        match ret {
+            0 => Ok(()),
+            _ => Err(Error::ClearBindings),
+        }
+    }
+}

src/value.rs

@@ -12,6 +12,21 @@ pub enum Value<'a> {
     Char(&'a str),
 }
 
+impl Display for Value<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Null => write!(f, "NULL"),
+            Value::I8(v) => write!(f, "{}", v),
+            Value::I16(v) => write!(f, "{}", v),
+            Value::I32(v) => write!(f, "{}", v),
+            Value::I64(v) => write!(f, "{}", v),
+            Value::F32(v) => write!(f, "{}", v),
+            Value::F64(v) => write!(f, "{}", v),
+            Value::Char(v) => write!(f, "{}", v),
+        }
+    }
+}
+
 impl<'a> Value<'a> {
     // TODO: If you know the detailed format, you can access the pointer directly
     // https://crossdb.org/client/api-c/#xdb_column_int