ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-04-01 19:52:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Let create_scalar_function take an FnMut instead of a extern "C" fn.

Browse Source
This commit is contained in:
John Gallagher 2015-12-11 12:01:05 -05:00
parent aae431760e
commit 29494f46f6
1 changed files with 47 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
src/functions.rs
View File

@ -1,9 +1,8 @@
//! Create or redefine SQL functions //! Create or redefine SQL functions
use std::ffi::CStr; use std::ffi::CStr;
use std::mem; use std::mem;
use std::ptr;
use std::str; use std::str;
use libc::{c_int, c_double, c_char}; use libc::{c_int, c_double, c_char, c_void};
use ffi; use ffi;
pub use ffi::sqlite3_context; pub use ffi::sqlite3_context;
@ -225,30 +224,50 @@ impl<T: FromValue> FromValue for Option<T> {
// sqlite3_get_auxdata // sqlite3_get_auxdata
// sqlite3_set_auxdata // sqlite3_set_auxdata
pub type ScalarFunc = Option<extern "C" fn(ctx: *mut sqlite3_context, pub trait ScalarFunction: FnMut(*mut sqlite3_context, c_int, *mut *mut sqlite3_value) {}
argc: c_int, impl<F: FnMut(*mut sqlite3_context, c_int, *mut *mut sqlite3_value)> ScalarFunction for F {}
argv: *mut *mut sqlite3_value)
>;
impl SqliteConnection { impl SqliteConnection {
// TODO pApp pub fn create_scalar_function<F>(&self,
pub fn create_scalar_function(&self, fn_name: &str,
fn_name: &str, n_arg: c_int,
n_arg: c_int, deterministic: bool,
deterministic: bool, x_func: F)
x_func: ScalarFunc) -> SqliteResult<()>
-> SqliteResult<()> { where F: ScalarFunction
{
self.db.borrow_mut().create_scalar_function(fn_name, n_arg, deterministic, x_func) self.db.borrow_mut().create_scalar_function(fn_name, n_arg, deterministic, x_func)
} }
} }
impl InnerSqliteConnection { impl InnerSqliteConnection {
pub fn create_scalar_function(&mut self, pub fn create_scalar_function<F>(&mut self,
fn_name: &str, fn_name: &str,
n_arg: c_int, n_arg: c_int,
deterministic: bool, deterministic: bool,
x_func: ScalarFunc) x_func: F)
-> SqliteResult<()> { -> SqliteResult<()>
where F: ScalarFunction
{
extern "C" fn free_boxed_closure<F>(p: *mut c_void)
where F: ScalarFunction
{
let _: Box<F> = unsafe { Box::from_raw(mem::transmute(p)) };
}
extern "C" fn call_boxed_closure<F>(ctx: *mut sqlite3_context,
argc: c_int,
argv: *mut *mut sqlite3_value)
where F: ScalarFunction
{
unsafe {
let boxed_f: *mut F = mem::transmute(ffi::sqlite3_user_data(ctx));
assert!(!boxed_f.is_null(), "Internal error - null function pointer");
(*boxed_f)(ctx, argc, argv);
}
}
let boxed_f: *mut F = Box::into_raw(Box::new(x_func));
let c_name = try!(str_to_cstring(fn_name)); let c_name = try!(str_to_cstring(fn_name));
let mut flags = ffi::SQLITE_UTF8; let mut flags = ffi::SQLITE_UTF8;
if deterministic { if deterministic {
@ -259,11 +278,11 @@ impl InnerSqliteConnection {
c_name.as_ptr(), c_name.as_ptr(),
n_arg, n_arg,
flags, flags,
ptr::null_mut(), mem::transmute(boxed_f),
x_func, Some(call_boxed_closure::<F>),
None, None,
None, None,
None) Some(free_boxed_closure::<F>))
}; };
self.decode_result(r) self.decode_result(r)
} }
@ -285,7 +304,7 @@ mod test {
use ffi::sqlite3_value; use ffi::sqlite3_value;
use functions::{FromValue, ToResult}; use functions::{FromValue, ToResult};
extern "C" fn half(ctx: *mut sqlite3_context, _: c_int, argv: *mut *mut sqlite3_value) { fn half(ctx: *mut sqlite3_context, _: c_int, argv: *mut *mut sqlite3_value) {
unsafe { unsafe {
let arg = *argv.offset(0); let arg = *argv.offset(0);
if c_double::parameter_has_valid_sqlite_type(arg) { if c_double::parameter_has_valid_sqlite_type(arg) {
@ -298,9 +317,9 @@ mod test {
} }
#[test] #[test]
fn test_half() { fn test_function_half() {
let db = SqliteConnection::open_in_memory().unwrap(); let db = SqliteConnection::open_in_memory().unwrap();
db.create_scalar_function("half", 1, true, Some(half)).unwrap(); db.create_scalar_function("half", 1, true, half).unwrap();
let result = db.query_row("SELECT half(6)", &[], |r| r.get::<f64>(0)); let result = db.query_row("SELECT half(6)", &[], |r| r.get::<f64>(0));
assert_eq!(3f64, result.unwrap()); assert_eq!(3f64, result.unwrap());
@ -310,7 +329,7 @@ mod test {
let _: Box<Regex> = unsafe { Box::from_raw(mem::transmute(raw)) }; let _: Box<Regex> = unsafe { Box::from_raw(mem::transmute(raw)) };
} }
extern "C" fn regexp(ctx: *mut sqlite3_context, _: c_int, argv: *mut *mut sqlite3_value) { fn regexp(ctx: *mut sqlite3_context, _: c_int, argv: *mut *mut sqlite3_value) {
unsafe { unsafe {
let mut re_ptr = ffi::sqlite3_get_auxdata(ctx, 0) as *const Regex; let mut re_ptr = ffi::sqlite3_get_auxdata(ctx, 0) as *const Regex;
let need_re = re_ptr.is_null(); let need_re = re_ptr.is_null();
@ -344,9 +363,9 @@ mod test {
} }
#[test] #[test]
fn test_regexp() { fn test_function_regexp() {
let db = SqliteConnection::open_in_memory().unwrap(); let db = SqliteConnection::open_in_memory().unwrap();
db.create_scalar_function("regexp", 2, true, Some(regexp)).unwrap(); db.create_scalar_function("regexp", 2, true, regexp).unwrap();
let result = db.query_row("SELECT regexp('l.s[aeiouy]', 'lisa')", let result = db.query_row("SELECT regexp('l.s[aeiouy]', 'lisa')",
&[], &[],
|r| r.get::<bool>(0)); |r| r.get::<bool>(0));