Merge pull request #284 from libsql/lucio/params-try-into

libsql/core: Switch to TryInto for params

crates/core/src/connection.rs

@@ -73,10 +73,13 @@ impl Connection {
     pub fn query<S, P>(&self, sql: S, params: P) -> Result<Option<Rows>>
     where
         S: Into<String>,
-        P: Into<Params>,
+        P: TryInto<Params>,
+        P::Error: Into<crate::BoxError>,
     {
         let stmt = Statement::prepare(self.clone(), self.raw, sql.into().as_str())?;
-        let params = params.into();
+        let params = params
+            .try_into()
+            .map_err(|e| Error::ToSqlConversionFailure(e.into()))?;
         let ret = stmt.query(&params)?;
         Ok(Some(ret))
     }
@@ -134,10 +137,13 @@ impl Connection {
     pub fn execute<S, P>(&self, sql: S, params: P) -> Result<u64>
     where
         S: Into<String>,
-        P: Into<Params>,
+        P: TryInto<Params>,
+        P::Error: Into<crate::BoxError>,
     {
         let stmt = Statement::prepare(self.clone(), self.raw, sql.into().as_str())?;
-        let params = params.into();
+        let params = params
+            .try_into()
+            .map_err(|e| Error::ToSqlConversionFailure(e.into()))?;
         stmt.execute(&params)
     }
 

crates/core/src/errors.rs

@@ -20,6 +20,8 @@ pub enum Error {
     QueryReturnedNoRows,
     #[error("Execute returned rows")]
     ExecuteReturnedRows,
+    #[error("unable to convert to sql: `{0}`")]
+    ToSqlConversionFailure(crate::BoxError),
 }
 
 pub(crate) fn error_from_handle(raw: *mut libsql_sys::ffi::sqlite3) -> String {

crates/core/src/lib.rs

@@ -51,6 +51,7 @@ pub mod statement;
 pub mod transaction;
 
 pub type Result<T> = std::result::Result<T, errors::Error>;
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
 
 pub use libsql_sys::ffi;
 pub use libsql_sys::ValueType;
@@ -75,5 +76,10 @@ pub fn version_number() -> i32 {
 
 /// Return the version of the underlying SQLite library as a string.
 pub fn version() -> &'static str {
-    unsafe { std::ffi::CStr::from_ptr(ffi::sqlite3_libversion()).to_str().unwrap() }
-}
+    unsafe {
+        std::ffi::CStr::from_ptr(ffi::sqlite3_libversion())
+            .to_str()
+            .unwrap()
+    }
+}
+

crates/core/src/params.rs

@@ -2,6 +2,8 @@ use std::ffi::c_char;
 
 use libsql_sys::ValueType;
 
+use crate::{Error, Result};
+
 pub enum Params {
     None,
     Positional(Vec<Value>),
@@ -40,18 +42,23 @@ macro_rules! named_params {
 ///
 /// conn.query(
 ///     "SELECT * FROM users WHERE id IN (?1, ?2, ?3)",
-///     params_from_iter(iter)
+///     params_from_iter(iter)?
 /// )
 /// # }
 /// ```
-pub fn params_from_iter<I>(iter: I) -> Params
+pub fn params_from_iter<I>(iter: I) -> Result<Params>
 where
     I: IntoIterator,
-    I::Item: Into<Value>,
+    I::Item: TryInto<Value>,
+    <I::Item as TryInto<Value>>::Error: Into<crate::BoxError>,
 {
-    let vec = iter.into_iter().map(Into::into).collect();
+    let vec = iter
+        .into_iter()
+        .map(|i| i.try_into())
+        .collect::<std::result::Result<Vec<_>, _>>()
+        .map_err(|e| Error::ToSqlConversionFailure(e.into()))?;
 
-    Params::Positional(vec)
+    Ok(Params::Positional(vec))
 }
 
 impl From<()> for Params {

crates/core/src/statement.rs

@@ -101,7 +101,10 @@ impl Statement {
         match err as u32 {
             crate::ffi::SQLITE_DONE => Ok(self.conn.changes()),
             crate::ffi::SQLITE_ROW => Err(Error::ExecuteReturnedRows),
-            _ => Err(Error::LibError(err, errors::error_from_handle(self.conn.raw))),
+            _ => Err(Error::LibError(
+                err,
+                errors::error_from_handle(self.conn.raw),
+            )),
         }
     }
 

crates/core/tests/integration_tests.rs

@@ -213,3 +213,32 @@ fn transaction() {
     assert_eq!(row.get::<&str>(1).unwrap(), "Alice");
     assert!(rows.next().unwrap().is_none());
 }
+
+#[test]
+fn custom_params() {
+    let conn = setup();
+
+    enum MyValue {
+        Text(String),
+        Int(i64),
+    }
+
+    impl TryInto<libsql::Value> for MyValue {
+        type Error = std::io::Error;
+
+        fn try_into(self) -> Result<libsql::Value, Self::Error> {
+            match self {
+                MyValue::Text(s) => Ok(Value::Text(s)),
+                MyValue::Int(i) => Ok(Value::Integer(i)),
+            }
+        }
+    }
+
+    let params = vec![MyValue::Int(2), MyValue::Text("Alice".into())];
+
+    conn.execute(
+        "INSERT INTO users (id, name) VALUES (?1, ?2)",
+        libsql::params_from_iter(params).unwrap(),
+    )
+    .unwrap();
+}