rusqlite/src/hooks.rs

305 lines
9.0 KiB
Rust
Raw Normal View History

//! Commit, Data Change and Rollback Notification Callbacks
#![allow(non_camel_case_types)]
2018-08-11 18:48:21 +08:00
use std::os::raw::{c_char, c_int, c_void};
use std::panic::catch_unwind;
use std::ptr;
2018-10-31 03:11:35 +08:00
use crate::ffi;
2018-10-31 03:11:35 +08:00
use crate::{Connection, InnerConnection};
/// Action Codes
#[derive(Clone, Copy, Debug, PartialEq)]
2019-02-02 18:04:46 +08:00
#[repr(i32)]
pub enum Action {
UNKNOWN = -1,
2019-02-02 18:04:46 +08:00
SQLITE_DELETE = ffi::SQLITE_DELETE,
SQLITE_INSERT = ffi::SQLITE_INSERT,
SQLITE_UPDATE = ffi::SQLITE_UPDATE,
}
impl From<i32> for Action {
fn from(code: i32) -> Action {
match code {
ffi::SQLITE_DELETE => Action::SQLITE_DELETE,
ffi::SQLITE_INSERT => Action::SQLITE_INSERT,
ffi::SQLITE_UPDATE => Action::SQLITE_UPDATE,
_ => Action::UNKNOWN,
}
}
}
impl Connection {
2018-08-17 00:29:46 +08:00
/// Register a callback function to be invoked whenever a transaction is
/// committed.
///
/// The callback returns `true` to rollback.
2018-08-05 16:58:00 +08:00
pub fn commit_hook<F>(&self, hook: Option<F>)
where
F: FnMut() -> bool + Send + 'static,
{
self.db.borrow_mut().commit_hook(hook);
}
2018-08-17 00:29:46 +08:00
/// Register a callback function to be invoked whenever a transaction is
/// committed.
///
/// The callback returns `true` to rollback.
2018-08-05 16:58:00 +08:00
pub fn rollback_hook<F>(&self, hook: Option<F>)
where
F: FnMut() + Send + 'static,
{
self.db.borrow_mut().rollback_hook(hook);
}
2017-05-13 01:18:42 +08:00
/// Register a callback function to be invoked whenever a row is updated,
/// inserted or deleted in a rowid table.
///
/// The callback parameters are:
///
2018-08-17 00:29:46 +08:00
/// - the type of database update (SQLITE_INSERT, SQLITE_UPDATE or
/// SQLITE_DELETE),
/// - the name of the database ("main", "temp", ...),
/// - the name of the table that is updated,
/// - the ROWID of the row that is updated.
2018-08-05 16:58:00 +08:00
pub fn update_hook<F>(&self, hook: Option<F>)
where
F: FnMut(Action, &str, &str, i64) + Send + 'static,
{
self.db.borrow_mut().update_hook(hook);
}
}
impl InnerConnection {
2017-04-27 02:12:48 +08:00
pub fn remove_hooks(&mut self) {
2018-08-05 16:58:00 +08:00
self.update_hook(None::<fn(Action, &str, &str, i64)>);
self.commit_hook(None::<fn() -> bool>);
self.rollback_hook(None::<fn()>);
}
2018-08-11 17:14:17 +08:00
fn commit_hook<F>(&mut self, hook: Option<F>)
2018-08-05 16:58:00 +08:00
where
F: FnMut() -> bool + Send + 'static,
{
unsafe extern "C" fn call_boxed_closure<F>(p_arg: *mut c_void) -> c_int
2018-08-05 16:58:00 +08:00
where
F: FnMut() -> bool,
{
let r = catch_unwind(|| {
let boxed_hook: *mut F = p_arg as *mut F;
(*boxed_hook)()
});
if let Ok(true) = r {
2018-08-05 16:58:00 +08:00
1
} else {
0
}
}
2018-08-17 00:29:46 +08:00
// unlike `sqlite3_create_function_v2`, we cannot specify a `xDestroy` with
// `sqlite3_commit_hook`. so we keep the `xDestroy` function in
// `InnerConnection.free_boxed_hook`.
2018-08-11 17:14:17 +08:00
let free_commit_hook = if hook.is_some() {
Some(free_boxed_hook::<F> as fn(*mut c_void))
} else {
None
};
2018-08-05 16:58:00 +08:00
let previous_hook = match hook {
Some(hook) => {
let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
unsafe {
ffi::sqlite3_commit_hook(
self.db(),
Some(call_boxed_closure::<F>),
boxed_hook as *mut _,
)
}
}
2018-08-05 16:58:00 +08:00
_ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) },
};
2018-08-11 17:14:17 +08:00
if !previous_hook.is_null() {
if let Some(free_boxed_hook) = self.free_commit_hook {
free_boxed_hook(previous_hook);
}
}
self.free_commit_hook = free_commit_hook;
}
2018-08-11 17:14:17 +08:00
fn rollback_hook<F>(&mut self, hook: Option<F>)
2018-08-05 16:58:00 +08:00
where
F: FnMut() + Send + 'static,
{
unsafe extern "C" fn call_boxed_closure<F>(p_arg: *mut c_void)
2018-08-05 16:58:00 +08:00
where
F: FnMut(),
{
let _ = catch_unwind(|| {
let boxed_hook: *mut F = p_arg as *mut F;
(*boxed_hook)();
});
}
2018-08-11 17:14:17 +08:00
let free_rollback_hook = if hook.is_some() {
Some(free_boxed_hook::<F> as fn(*mut c_void))
} else {
None
};
2018-08-05 16:58:00 +08:00
let previous_hook = match hook {
Some(hook) => {
let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
unsafe {
ffi::sqlite3_rollback_hook(
self.db(),
Some(call_boxed_closure::<F>),
boxed_hook as *mut _,
)
}
}
2018-08-05 16:58:00 +08:00
_ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) },
};
2018-08-11 17:14:17 +08:00
if !previous_hook.is_null() {
if let Some(free_boxed_hook) = self.free_rollback_hook {
free_boxed_hook(previous_hook);
}
}
self.free_rollback_hook = free_rollback_hook;
2017-04-27 02:12:48 +08:00
}
2018-08-05 16:58:00 +08:00
fn update_hook<F>(&mut self, hook: Option<F>)
where
F: FnMut(Action, &str, &str, i64) + Send + 'static,
{
2018-08-05 16:58:00 +08:00
unsafe extern "C" fn call_boxed_closure<F>(
p_arg: *mut c_void,
action_code: c_int,
db_str: *const c_char,
tbl_str: *const c_char,
row_id: i64,
) where
F: FnMut(Action, &str, &str, i64),
{
use std::ffi::CStr;
use std::str;
let action = Action::from(action_code);
let db_name = {
let c_slice = CStr::from_ptr(db_str).to_bytes();
str::from_utf8_unchecked(c_slice)
};
let tbl_name = {
let c_slice = CStr::from_ptr(tbl_str).to_bytes();
str::from_utf8_unchecked(c_slice)
};
let _ = catch_unwind(|| {
let boxed_hook: *mut F = p_arg as *mut F;
(*boxed_hook)(action, db_name, tbl_name, row_id);
});
}
2018-08-11 17:14:17 +08:00
let free_update_hook = if hook.is_some() {
Some(free_boxed_hook::<F> as fn(*mut c_void))
} else {
None
};
2018-08-05 16:58:00 +08:00
let previous_hook = match hook {
Some(hook) => {
let boxed_hook: *mut F = Box::into_raw(Box::new(hook));
unsafe {
ffi::sqlite3_update_hook(
self.db(),
Some(call_boxed_closure::<F>),
boxed_hook as *mut _,
)
}
}
2018-08-05 16:58:00 +08:00
_ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) },
};
2018-08-11 17:14:17 +08:00
if !previous_hook.is_null() {
if let Some(free_boxed_hook) = self.free_update_hook {
free_boxed_hook(previous_hook);
}
}
self.free_update_hook = free_update_hook;
2017-04-27 02:12:48 +08:00
}
}
2018-08-11 17:14:17 +08:00
fn free_boxed_hook<F>(p: *mut c_void) {
drop(unsafe { Box::from_raw(p as *mut F) });
2017-04-27 02:12:48 +08:00
}
#[cfg(test)]
mod test {
use super::Action;
2018-10-31 03:11:35 +08:00
use crate::Connection;
use lazy_static::lazy_static;
2019-08-10 02:03:46 +08:00
use std::sync::atomic::{AtomicBool, Ordering};
2017-04-27 02:12:48 +08:00
#[test]
fn test_commit_hook() {
let db = Connection::open_in_memory().unwrap();
lazy_static! {
2019-02-02 18:10:08 +08:00
static ref CALLED: AtomicBool = AtomicBool::new(false);
}
2018-08-05 16:58:00 +08:00
db.commit_hook(Some(|| {
2019-02-02 18:10:08 +08:00
CALLED.store(true, Ordering::Relaxed);
2018-08-05 16:58:00 +08:00
false
}));
2017-05-13 01:18:42 +08:00
db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")
.unwrap();
2019-02-02 18:10:08 +08:00
assert!(CALLED.load(Ordering::Relaxed));
}
2018-08-11 17:14:17 +08:00
#[test]
fn test_fn_commit_hook() {
let db = Connection::open_in_memory().unwrap();
fn hook() -> bool {
true
}
db.commit_hook(Some(hook));
db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")
.unwrap_err();
}
#[test]
fn test_rollback_hook() {
let db = Connection::open_in_memory().unwrap();
lazy_static! {
2019-02-02 18:10:08 +08:00
static ref CALLED: AtomicBool = AtomicBool::new(false);
}
2018-08-05 16:58:00 +08:00
db.rollback_hook(Some(|| {
2019-02-02 18:10:08 +08:00
CALLED.store(true, Ordering::Relaxed);
2018-08-05 16:58:00 +08:00
}));
2017-05-13 01:18:42 +08:00
db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")
.unwrap();
2019-02-02 18:10:08 +08:00
assert!(CALLED.load(Ordering::Relaxed));
}
2017-04-27 02:12:48 +08:00
#[test]
fn test_update_hook() {
let db = Connection::open_in_memory().unwrap();
lazy_static! {
2019-02-02 18:10:08 +08:00
static ref CALLED: AtomicBool = AtomicBool::new(false);
}
2018-08-05 16:58:00 +08:00
db.update_hook(Some(|action, db: &str, tbl: &str, row_id| {
assert_eq!(Action::SQLITE_INSERT, action);
assert_eq!("main", db);
assert_eq!("foo", tbl);
assert_eq!(1, row_id);
2019-02-02 18:10:08 +08:00
CALLED.store(true, Ordering::Relaxed);
2018-08-05 16:58:00 +08:00
}));
2017-04-27 02:12:48 +08:00
db.execute_batch("CREATE TABLE foo (t TEXT)").unwrap();
2017-05-13 01:18:42 +08:00
db.execute_batch("INSERT INTO foo VALUES ('lisa')").unwrap();
2019-02-02 18:10:08 +08:00
assert!(CALLED.load(Ordering::Relaxed));
}
}