cleanup scalarfn definition. credit: github.com/asg017/pull/15

Author: PThorpe92

Cargo.lock

@@ -20,6 +20,7 @@ libsqlite3-sys = {version="0.26.0", optional=true, features=["bundled"]}
 [dev-dependencies]
 rusqlite = "0.29.0"
 libsqlite3-sys = {version="0.26.0", default-features = false, features=["bundled"]}
+rand = "0.8.4"
 
 [features]
 static = ["libsqlite3-sys"]

Cargo.toml

@@ -1,33 +1,44 @@
 //! cargo build --example scalar
 //! sqlite3 :memory: '.read examples/test.sql'
 
-use sqlite_loadable::prelude::*;
+use rand::Rng;
 use sqlite_loadable::{api, define_scalar_function, Result};
+use sqlite_loadable::{define_scalar_function_with_aux, prelude::*};
 
 // yo()
 fn yo(context: *mut sqlite3_context, _values: &[*mut sqlite3_value]) -> Result<()> {
     api::result_text(context, "yo")?;
     Ok(())
 }
 
+fn random_int64(
+    context: *mut sqlite3_context,
+    _values: &[*mut sqlite3_value],
+    rng: &mut rand::rngs::ThreadRng,
+) -> Result<()> {
+    let random_int64: i64 = rng.gen();
+    api::result_int64(context, random_int64);
+    Ok(())
+}
+
 // surround_rs(name)
 fn surround(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
-    let value = api::value_text(values.get(0).expect("1st argument as name"))?;
+    let value = api::value_text(values.first().expect("1st argument as name"))?;
     api::result_text(context, format!("x{}x", value))?;
     Ok(())
 }
 
 // add_rs(a, b)
 fn add(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
-    let a = api::value_int(values.get(0).expect("1st argument"));
+    let a = api::value_int(values.first().expect("1st argument"));
     let b = api::value_int(values.get(1).expect("2nd argument"));
     api::result_int(context, a + b);
     Ok(())
 }
 
 // connect(seperator, string1, ...)
 fn connect(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
-    let seperator = api::value_text(values.get(0).expect("1st argument"))?;
+    let seperator = api::value_text(values.first().expect("1st argument"))?;
     let strings: Vec<&str> = values
         .get(1..)
         .expect("more than 1 argument to be given")
@@ -45,5 +56,7 @@ pub fn sqlite3_scalarrs_init(db: *mut sqlite3) -> Result<()> {
     define_scalar_function(db, "connect", -1, connect, flags)?;
     define_scalar_function(db, "yo_rs", 0, yo, flags)?;
     define_scalar_function(db, "add_rs", 2, add, flags)?;
+    let rng = rand::thread_rng();
+    define_scalar_function_with_aux(db, "random_int64", 0, random_int64, flags, rng)?;
     Ok(())
 }

examples/scalar.rs

@@ -136,59 +136,57 @@ where
         None,
     )
 }
+type ValueScalarCallbackWithAux<T> =
+    fn(*mut sqlite3_context, &[*mut sqlite3_value], &mut T) -> Result<()>;
+struct ScalarCallbackWithAux<T> {
+    x_func: ValueScalarCallbackWithAux<T>,
+    aux: T,
+}
 
 /// Defines a new scalar function, but with the added ability to pass in an arbritary
 /// application "pointer" as any rust type. Can be accessed in the callback
 /// function as the 3rd argument, as a reference.
 /// <https://www.sqlite.org/c3ref/create_function.html#:~:text=The%20fifth%20parameter%20is%20an%20arbitrary%20pointer.>
-pub fn define_scalar_function_with_aux<F, T>(
+pub fn define_scalar_function_with_aux<T>(
     db: *mut sqlite3,
     name: &str,
     num_args: c_int,
-    x_func: F,
+    x_func: ValueScalarCallbackWithAux<T>,
     func_flags: FunctionFlags,
     aux: T,
-) -> Result<()>
-where
-    F: Fn(*mut sqlite3_context, &[*mut sqlite3_value], &T) -> Result<()>,
-{
-    let function_pointer: *mut F = Box::into_raw(Box::new(x_func));
-    let aux_pointer: *mut T = Box::into_raw(Box::new(aux));
-    let app_pointer = Box::into_raw(Box::new((function_pointer, aux_pointer)));
+) -> Result<()> {
+    let app_pointer = Box::into_raw(Box::new(ScalarCallbackWithAux { x_func, aux }));
 
-    unsafe extern "C" fn x_func_wrapper<F, T>(
+    unsafe extern "C" fn x_func_wrapper<T>(
         context: *mut sqlite3_context,
         argc: c_int,
         argv: *mut *mut sqlite3_value,
-    ) where
-        F: Fn(*mut sqlite3_context, &[*mut sqlite3_value], &T) -> Result<()>,
-    {
-        let x = sqlite3ext_user_data(context).cast::<(*mut F, *mut T)>();
-        let boxed_function = (*x).0;
-        let aux = (*x).1;
-        // .collect slows things waaaay down, so stick with slice for now
+    ) {
+        let x = sqlite3ext_user_data(context).cast::<ScalarCallbackWithAux<T>>();
         let args = slice::from_raw_parts(argv, argc as usize);
-        let b = Box::from_raw(aux);
-        match (*boxed_function)(context, args, &*b) {
+        match ((*x).x_func)(context, args, &mut (*x).aux) {
             Ok(()) => (),
             Err(e) => {
                 if api::result_error(context, &e.result_error_message()).is_err() {
                     api::result_error_code(context, SQLITE_INTERNAL);
                 }
             }
         }
-        Box::into_raw(b);
+    }
+    unsafe extern "C" fn destroy<T>(p_app: *mut c_void) {
+        let callbacks = p_app.cast::<ScalarCallbackWithAux<T>>();
+        let _ = Box::from_raw(callbacks);
     }
     create_function_v2(
         db,
         name,
         num_args,
         func_flags,
         app_pointer.cast::<c_void>(),
-        Some(x_func_wrapper::<F, T>),
-        None,
+        Some(x_func_wrapper::<T>),
         None,
         None,
+        Some(destroy::<T>),
     )
 }