From 86199e1b78f85bac1a2dd8643d08f7467badc97a Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Tue, 2 Feb 2021 22:00:19 +0100 Subject: [PATCH 01/17] Added an initial proposal for the preupdate hook. Created an initial proposal/direction for the preupdate hook. It is heavily based on the update hook, with only minor modifications to that code. This means that it entirely translate the original C API. --- Cargo.toml | 2 +- src/hooks.rs | 87 +++++++++++++++++++++++++++++++++++++++++ src/inner_connection.rs | 4 ++ 3 files changed, 92 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index fb951ef..0137e18 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,7 +37,7 @@ trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"] bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] limits = [] -hooks = [] +hooks = ["libsqlite3-sys/preupdate_hook"] i128_blob = ["byteorder"] sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] diff --git a/src/hooks.rs b/src/hooks.rs index b2ed430..1f5ae8a 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -78,6 +78,25 @@ impl Connection { { self.db.borrow_mut().update_hook(hook); } + /// + /// `feature = "hooks"` Register a callback function to be invoked before + /// a row is updated, inserted or deleted in a rowid table. + /// + /// The callback parameters are: + /// + /// - 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, + /// - for an update or delete, the initial ROWID of the row that is going to be updated/deleted. It is undefined for inserts. + /// - for an update or insert, the final ROWID of the row that is going to be updated/inserted. It is undefined for deletes. + #[inline] + pub fn preupdate_hook<'c, F>(&'c self, hook: Option) + where + F: FnMut(Action, &str, &str, i64, i64) + Send + 'c, + { + self.db.borrow_mut().preupdate_hook(hook); + } /// `feature = "hooks"` Register a query progress callback. /// @@ -99,6 +118,7 @@ impl InnerConnection { #[inline] pub fn remove_hooks(&mut self) { self.update_hook(None::); + self.preupdate_hook(None::); self.commit_hook(None:: bool>); self.rollback_hook(None::); self.progress_handler(0, None:: bool>); @@ -258,6 +278,73 @@ impl InnerConnection { self.free_update_hook = free_update_hook; } + fn preupdate_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut(Action, &str, &str, i64, i64) + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure( + p_arg: *mut c_void, + sqlite: *mut ffi::sqlite3, + action_code: c_int, + db_str: *const c_char, + tbl_str: *const c_char, + row_id: i64, + new_row_id: i64, + ) where + F: FnMut(Action, &str, &str, i64, 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(c_slice) + }; + let tbl_name = { + let c_slice = CStr::from_ptr(tbl_str).to_bytes(); + str::from_utf8(c_slice) + }; + + let _ = catch_unwind(|| { + let boxed_hook: *mut F = p_arg as *mut F; + (*boxed_hook)( + action, + db_name.expect("illegal db name"), + tbl_name.expect("illegal table name"), + row_id, + new_row_id, + ); + }); + } + + let free_preupdate_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + let previous_hook = match hook { + Some(hook) => { + let boxed_hook: *mut F = Box::into_raw(Box::new(hook)); + unsafe { + ffi::sqlite3_preupdate_hook( + self.db(), + Some(call_boxed_closure::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_preupdate_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_preupdate_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_preupdate_hook = free_preupdate_hook; + } + fn progress_handler(&mut self, num_ops: c_int, handler: Option) where F: FnMut() -> bool + Send + RefUnwindSafe + 'static, diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 133b7ef..7579ad5 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -33,6 +33,8 @@ pub struct InnerConnection { pub free_update_hook: Option, #[cfg(feature = "hooks")] pub progress_handler: Option bool + Send>>, + #[cfg(feature = "hooks")] + pub free_preupdate_hook: Option, owned: bool, } @@ -50,6 +52,8 @@ impl InnerConnection { #[cfg(feature = "hooks")] free_update_hook: None, #[cfg(feature = "hooks")] + free_preupdate_hook: None, + #[cfg(feature = "hooks")] progress_handler: None, owned, } From d88f49f83071ab72ca6b414253538503f94170f2 Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Wed, 3 Feb 2021 18:50:01 +0100 Subject: [PATCH 02/17] Prefix unused variable with _ --- src/hooks.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hooks.rs b/src/hooks.rs index 1f5ae8a..d2cc1cd 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -284,7 +284,7 @@ impl InnerConnection { { unsafe extern "C" fn call_boxed_closure( p_arg: *mut c_void, - sqlite: *mut ffi::sqlite3, + _sqlite: *mut ffi::sqlite3, action_code: c_int, db_str: *const c_char, tbl_str: *const c_char, From ceff6cb8b12d79ca0706f653e1e6ab3aceedef25 Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Sat, 6 Feb 2021 12:20:05 +0100 Subject: [PATCH 03/17] Extracted the preupdate_hook to a separate cargo feature. Moved hooks and preupdate_hook into their own modules inside hooks.rs Also created an initial way to access the functions that are available during the callback. --- Cargo.toml | 3 +- src/hooks.rs | 978 ++++++++++++++++++++++------------------ src/inner_connection.rs | 11 +- src/lib.rs | 4 +- src/types/value_ref.rs | 7 +- 5 files changed, 556 insertions(+), 447 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0137e18..9849310 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,7 +37,8 @@ trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"] bundled = ["libsqlite3-sys/bundled", "modern_sqlite"] buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] limits = [] -hooks = ["libsqlite3-sys/preupdate_hook"] +hooks = [] +preupdate_hook = ["libsqlite3-sys/preupdate_hook"] i128_blob = ["byteorder"] sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] diff --git a/src/hooks.rs b/src/hooks.rs index d2cc1cd..99dfe02 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -1,14 +1,9 @@ //! `feature = "hooks"` Commit, Data Change and Rollback Notification Callbacks #![allow(non_camel_case_types)] - -use std::os::raw::{c_char, c_int, c_void}; -use std::panic::{catch_unwind, RefUnwindSafe}; -use std::ptr; +use std::os::raw::c_void; use crate::ffi; -use crate::{Connection, InnerConnection}; - /// `feature = "hooks"` Action Codes #[derive(Clone, Copy, Debug, PartialEq)] #[repr(i32)] @@ -36,452 +31,555 @@ impl From for Action { } } -impl Connection { - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a transaction is committed. - /// - /// The callback returns `true` to rollback. - #[inline] - pub fn commit_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut() -> bool + Send + 'c, - { - self.db.borrow_mut().commit_hook(hook); - } - - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a transaction is committed. - /// - /// The callback returns `true` to rollback. - #[inline] - pub fn rollback_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut() + Send + 'c, - { - self.db.borrow_mut().rollback_hook(hook); - } - - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a row is updated, inserted or deleted in a rowid table. - /// - /// The callback parameters are: - /// - /// - 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. - #[inline] - pub fn update_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut(Action, &str, &str, i64) + Send + 'c, - { - self.db.borrow_mut().update_hook(hook); - } - /// - /// `feature = "hooks"` Register a callback function to be invoked before - /// a row is updated, inserted or deleted in a rowid table. - /// - /// The callback parameters are: - /// - /// - 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, - /// - for an update or delete, the initial ROWID of the row that is going to be updated/deleted. It is undefined for inserts. - /// - for an update or insert, the final ROWID of the row that is going to be updated/inserted. It is undefined for deletes. - #[inline] - pub fn preupdate_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut(Action, &str, &str, i64, i64) + Send + 'c, - { - self.db.borrow_mut().preupdate_hook(hook); - } - - /// `feature = "hooks"` Register a query progress callback. - /// - /// The parameter `num_ops` is the approximate number of virtual machine - /// instructions that are evaluated between successive invocations of the - /// `handler`. If `num_ops` is less than one then the progress handler - /// is disabled. - /// - /// If the progress callback returns `true`, the operation is interrupted. - pub fn progress_handler(&self, num_ops: c_int, handler: Option) - where - F: FnMut() -> bool + Send + RefUnwindSafe + 'static, - { - self.db.borrow_mut().progress_handler(num_ops, handler); - } -} - -impl InnerConnection { - #[inline] - pub fn remove_hooks(&mut self) { - self.update_hook(None::); - self.preupdate_hook(None::); - self.commit_hook(None:: bool>); - self.rollback_hook(None::); - self.progress_handler(0, None:: bool>); - } - - fn commit_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut() -> bool + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int - 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 { - 1 - } else { - 0 - } - } - - // 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`. - let free_commit_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_commit_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_commit_hook = free_commit_hook; - } - - fn rollback_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut() + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) - where - F: FnMut(), - { - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; - (*boxed_hook)(); - }); - } - - let free_rollback_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_rollback_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_rollback_hook = free_rollback_hook; - } - - fn update_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut(Action, &str, &str, i64) + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure( - 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(c_slice) - }; - let tbl_name = { - let c_slice = CStr::from_ptr(tbl_str).to_bytes(); - str::from_utf8(c_slice) - }; - - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; - (*boxed_hook)( - action, - db_name.expect("illegal db name"), - tbl_name.expect("illegal table name"), - row_id, - ); - }); - } - - let free_update_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_update_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_update_hook = free_update_hook; - } - - fn preupdate_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut(Action, &str, &str, i64, i64) + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure( - p_arg: *mut c_void, - _sqlite: *mut ffi::sqlite3, - action_code: c_int, - db_str: *const c_char, - tbl_str: *const c_char, - row_id: i64, - new_row_id: i64, - ) where - F: FnMut(Action, &str, &str, i64, 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(c_slice) - }; - let tbl_name = { - let c_slice = CStr::from_ptr(tbl_str).to_bytes(); - str::from_utf8(c_slice) - }; - - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; - (*boxed_hook)( - action, - db_name.expect("illegal db name"), - tbl_name.expect("illegal table name"), - row_id, - new_row_id, - ); - }); - } - - let free_preupdate_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - let previous_hook = match hook { - Some(hook) => { - let boxed_hook: *mut F = Box::into_raw(Box::new(hook)); - unsafe { - ffi::sqlite3_preupdate_hook( - self.db(), - Some(call_boxed_closure::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_preupdate_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_preupdate_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_preupdate_hook = free_preupdate_hook; - } - - fn progress_handler(&mut self, num_ops: c_int, handler: Option) - where - F: FnMut() -> bool + Send + RefUnwindSafe + 'static, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int - where - F: FnMut() -> bool, - { - let r = catch_unwind(|| { - let boxed_handler: *mut F = p_arg as *mut F; - (*boxed_handler)() - }); - if let Ok(true) = r { - 1 - } else { - 0 - } - } - - match handler { - Some(handler) => { - let boxed_handler = Box::new(handler); - unsafe { - ffi::sqlite3_progress_handler( - self.db(), - num_ops, - Some(call_boxed_closure::), - &*boxed_handler as *const F as *mut _, - ) - } - self.progress_handler = Some(boxed_handler); - } - _ => { - unsafe { ffi::sqlite3_progress_handler(self.db(), num_ops, None, ptr::null_mut()) } - self.progress_handler = None; - } - }; - } -} - unsafe fn free_boxed_hook(p: *mut c_void) { drop(Box::from_raw(p as *mut F)); } -#[cfg(test)] -mod test { +#[cfg(feature = "preupdate_hook")] +mod preupdate_hook { + use super::free_boxed_hook; use super::Action; - use crate::{Connection, Result}; - use std::sync::atomic::{AtomicBool, Ordering}; - #[test] - fn test_commit_hook() -> Result<()> { - let db = Connection::open_in_memory()?; + use std::os::raw::{c_char, c_int, c_void}; + use std::panic::catch_unwind; + use std::ptr; - let mut called = false; - db.commit_hook(Some(|| { - called = true; - false - })); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; - assert!(called); - Ok(()) + use crate::ffi; + use crate::types::ValueRef; + use crate::{Connection, InnerConnection}; + + // TODO: how to allow user access to these functions, since they should be only accessible in + // the scope of a preupdate_hook callback. + pub struct PreUpdateHookFunctions { + db: *mut ffi::sqlite3, } - #[test] - fn test_fn_commit_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - fn hook() -> bool { - true + impl PreUpdateHookFunctions { + pub unsafe fn get_count(&self) -> i32 { + ffi::sqlite3_preupdate_count(self.db) } - db.commit_hook(Some(hook)); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") - .unwrap_err(); - Ok(()) - } - - #[test] - fn test_rollback_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - let mut called = false; - db.rollback_hook(Some(|| { - called = true; - })); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")?; - assert!(called); - Ok(()) - } - - #[test] - fn test_update_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - let mut called = false; - 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); - called = true; - })); - db.execute_batch("CREATE TABLE foo (t TEXT)")?; - db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; - assert!(called); - Ok(()) - } - - #[test] - fn test_progress_handler() -> Result<()> { - let db = Connection::open_in_memory()?; - - static CALLED: AtomicBool = AtomicBool::new(false); - db.progress_handler( - 1, - Some(|| { - CALLED.store(true, Ordering::Relaxed); - false - }), - ); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; - assert!(CALLED.load(Ordering::Relaxed)); - Ok(()) - } - - #[test] - fn test_progress_handler_interrupt() -> Result<()> { - let db = Connection::open_in_memory()?; - - fn handler() -> bool { - true + pub unsafe fn get_old(&self, i: i32) -> ValueRef { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); + ValueRef::from_value(p_value) } - db.progress_handler(1, Some(handler)); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") - .unwrap_err(); - Ok(()) + pub unsafe fn get_new(&self, i: i32) -> ValueRef { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } + + impl Connection { + /// + /// `feature = "preupdate_hook"` Register a callback function to be invoked before + /// a row is updated, inserted or deleted in a rowid table. + /// + /// The callback parameters are: + /// + /// - 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, + /// - for an update or delete, the initial ROWID of the row that is going to be updated/deleted. It is undefined for inserts. + /// - for an update or insert, the final ROWID of the row that is going to be updated/inserted. It is undefined for deletes. + #[inline] + pub fn preupdate_hook<'c, F>(&'c self, hook: Option) + where + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions) + Send + 'c, + { + self.db.borrow_mut().preupdate_hook(hook); + } + } + + impl InnerConnection { + #[inline] + pub fn remove_preupdate_hook(&mut self) { + self.preupdate_hook(None::); + } + + fn preupdate_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions) + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure( + p_arg: *mut c_void, + sqlite: *mut ffi::sqlite3, + action_code: c_int, + db_str: *const c_char, + tbl_str: *const c_char, + row_id: i64, + new_row_id: i64, + ) where + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions), + { + 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(c_slice) + }; + let tbl_name = { + let c_slice = CStr::from_ptr(tbl_str).to_bytes(); + str::from_utf8(c_slice) + }; + + // TODO: how to properly allow a user to use the functions + // (sqlite3_preupdate_old,...) that are only in scope + // during the callback? + // Also how to pass in the rowids, because they can be undefined based on the + // action. + let preupdate_hook_functions = PreUpdateHookFunctions { db: sqlite }; + + let _ = catch_unwind(|| { + let boxed_hook: *mut F = p_arg as *mut F; + (*boxed_hook)( + action, + db_name.expect("illegal db name"), + tbl_name.expect("illegal table name"), + row_id, + new_row_id, + &preupdate_hook_functions, + ); + }); + } + + let free_preupdate_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + let previous_hook = match hook { + Some(hook) => { + let boxed_hook: *mut F = Box::into_raw(Box::new(hook)); + unsafe { + ffi::sqlite3_preupdate_hook( + self.db(), + Some(call_boxed_closure::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_preupdate_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_preupdate_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_preupdate_hook = free_preupdate_hook; + } + } + + #[cfg(test)] + mod test { + use super::super::Action; + use super::PreUpdateHookFunctions; + use crate::{Connection, Result}; + + #[test] + fn test_preupdate_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + db.preupdate_hook(Some( + |action, + db: &str, + tbl: &str, + row_id, + new_row_id, + _func: &PreUpdateHookFunctions| { + assert_eq!(Action::SQLITE_INSERT, action); + assert_eq!("main", db); + assert_eq!("foo", tbl); + assert_eq!(1, row_id); + assert_eq!(1, new_row_id); + called = true; + }, + )); + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + assert!(called); + Ok(()) + } + } +} + +#[cfg(feature = "hooks")] +mod datachanged_and_friends { + use super::free_boxed_hook; + use super::Action; + + use std::os::raw::{c_char, c_int, c_void}; + use std::panic::{catch_unwind, RefUnwindSafe}; + use std::ptr; + + use crate::ffi; + use crate::{Connection, InnerConnection}; + + impl Connection { + /// `feature = "hooks"` Register a callback function to be invoked whenever + /// a transaction is committed. + /// + /// The callback returns `true` to rollback. + #[inline] + pub fn commit_hook<'c, F>(&'c self, hook: Option) + where + F: FnMut() -> bool + Send + 'c, + { + self.db.borrow_mut().commit_hook(hook); + } + + /// `feature = "hooks"` Register a callback function to be invoked whenever + /// a transaction is committed. + /// + /// The callback returns `true` to rollback. + #[inline] + pub fn rollback_hook<'c, F>(&'c self, hook: Option) + where + F: FnMut() + Send + 'c, + { + self.db.borrow_mut().rollback_hook(hook); + } + + /// `feature = "hooks"` Register a callback function to be invoked whenever + /// a row is updated, inserted or deleted in a rowid table. + /// + /// The callback parameters are: + /// + /// - 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. + #[inline] + pub fn update_hook<'c, F>(&'c self, hook: Option) + where + F: FnMut(Action, &str, &str, i64) + Send + 'c, + { + self.db.borrow_mut().update_hook(hook); + } + + /// `feature = "hooks"` Register a query progress callback. + /// + /// The parameter `num_ops` is the approximate number of virtual machine + /// instructions that are evaluated between successive invocations of the + /// `handler`. If `num_ops` is less than one then the progress handler + /// is disabled. + /// + /// If the progress callback returns `true`, the operation is interrupted. + pub fn progress_handler(&self, num_ops: c_int, handler: Option) + where + F: FnMut() -> bool + Send + RefUnwindSafe + 'static, + { + self.db.borrow_mut().progress_handler(num_ops, handler); + } + } + + impl InnerConnection { + #[inline] + pub fn remove_hooks(&mut self) { + self.update_hook(None::); + self.commit_hook(None:: bool>); + self.rollback_hook(None::); + self.progress_handler(0, None:: bool>); + } + + fn commit_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut() -> bool + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int + 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 { + 1 + } else { + 0 + } + } + + // 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`. + let free_commit_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_commit_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_commit_hook = free_commit_hook; + } + + fn rollback_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut() + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) + where + F: FnMut(), + { + let _ = catch_unwind(|| { + let boxed_hook: *mut F = p_arg as *mut F; + (*boxed_hook)(); + }); + } + + let free_rollback_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_rollback_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_rollback_hook = free_rollback_hook; + } + + fn update_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut(Action, &str, &str, i64) + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure( + 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(c_slice) + }; + let tbl_name = { + let c_slice = CStr::from_ptr(tbl_str).to_bytes(); + str::from_utf8(c_slice) + }; + + let _ = catch_unwind(|| { + let boxed_hook: *mut F = p_arg as *mut F; + (*boxed_hook)( + action, + db_name.expect("illegal db name"), + tbl_name.expect("illegal table name"), + row_id, + ); + }); + } + + let free_update_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_update_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_update_hook = free_update_hook; + } + + fn progress_handler(&mut self, num_ops: c_int, handler: Option) + where + F: FnMut() -> bool + Send + RefUnwindSafe + 'static, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int + where + F: FnMut() -> bool, + { + let r = catch_unwind(|| { + let boxed_handler: *mut F = p_arg as *mut F; + (*boxed_handler)() + }); + if let Ok(true) = r { + 1 + } else { + 0 + } + } + + match handler { + Some(handler) => { + let boxed_handler = Box::new(handler); + unsafe { + ffi::sqlite3_progress_handler( + self.db(), + num_ops, + Some(call_boxed_closure::), + &*boxed_handler as *const F as *mut _, + ) + } + self.progress_handler = Some(boxed_handler); + } + _ => { + unsafe { + ffi::sqlite3_progress_handler(self.db(), num_ops, None, ptr::null_mut()) + } + self.progress_handler = None; + } + }; + } + } + + #[cfg(test)] + mod test { + use super::super::Action; + use crate::{Connection, Result}; + use std::sync::atomic::{AtomicBool, Ordering}; + + #[test] + fn test_commit_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + db.commit_hook(Some(|| { + called = true; + false + })); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; + assert!(called); + Ok(()) + } + + #[test] + fn test_fn_commit_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + fn hook() -> bool { + true + } + + db.commit_hook(Some(hook)); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") + .unwrap_err(); + Ok(()) + } + + #[test] + fn test_rollback_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + db.rollback_hook(Some(|| { + called = true; + })); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")?; + assert!(called); + Ok(()) + } + + #[test] + fn test_update_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + 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); + called = true; + })); + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + assert!(called); + Ok(()) + } + + #[test] + fn test_progress_handler() -> Result<()> { + let db = Connection::open_in_memory()?; + + static CALLED: AtomicBool = AtomicBool::new(false); + db.progress_handler( + 1, + Some(|| { + CALLED.store(true, Ordering::Relaxed); + false + }), + ); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; + assert!(CALLED.load(Ordering::Relaxed)); + Ok(()) + } + + #[test] + fn test_progress_handler_interrupt() -> Result<()> { + let db = Connection::open_in_memory()?; + + fn handler() -> bool { + true + } + + db.progress_handler(1, Some(handler)); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") + .unwrap_err(); + Ok(()) + } } } diff --git a/src/inner_connection.rs b/src/inner_connection.rs index 7579ad5..759d406 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -33,7 +33,7 @@ pub struct InnerConnection { pub free_update_hook: Option, #[cfg(feature = "hooks")] pub progress_handler: Option bool + Send>>, - #[cfg(feature = "hooks")] + #[cfg(feature = "preupdate_hook")] pub free_preupdate_hook: Option, owned: bool, } @@ -52,9 +52,9 @@ impl InnerConnection { #[cfg(feature = "hooks")] free_update_hook: None, #[cfg(feature = "hooks")] - free_preupdate_hook: None, - #[cfg(feature = "hooks")] progress_handler: None, + #[cfg(feature = "preupdate_hook")] + free_preupdate_hook: None, owned, } } @@ -155,6 +155,7 @@ impl InnerConnection { return Ok(()); } self.remove_hooks(); + self.remove_preupdate_hook(); let mut shared_handle = self.interrupt_lock.lock().unwrap(); assert!( !shared_handle.is_null(), @@ -305,6 +306,10 @@ impl InnerConnection { #[cfg(not(feature = "hooks"))] #[inline] fn remove_hooks(&mut self) {} + + #[cfg(not(feature = "preupdate_hook"))] + #[inline] + fn remove_preupdate_hook(&mut self) {} } impl Drop for InnerConnection { diff --git a/src/lib.rs b/src/lib.rs index 4635c19..7c916e4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -101,8 +101,8 @@ pub mod config; mod context; #[cfg(feature = "functions")] pub mod functions; -#[cfg(feature = "hooks")] -mod hooks; +#[cfg(any(feature = "hooks", feature = "preupdate_hook"))] +pub mod hooks; mod inner_connection; #[cfg(feature = "limits")] pub mod limits; diff --git a/src/types/value_ref.rs b/src/types/value_ref.rs index b95521b..0575b66 100644 --- a/src/types/value_ref.rs +++ b/src/types/value_ref.rs @@ -133,7 +133,12 @@ where } } -#[cfg(any(feature = "functions", feature = "session", feature = "vtab"))] +#[cfg(any( + feature = "functions", + feature = "session", + feature = "vtab", + feature = "preupdate_hook" +))] impl<'a> ValueRef<'a> { pub(crate) unsafe fn from_value(value: *mut crate::ffi::sqlite3_value) -> ValueRef<'a> { use crate::ffi; From 9187b3e960a1b8215a1bb783a3560b1fc1ecfc39 Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Fri, 26 Feb 2021 21:02:06 +0100 Subject: [PATCH 04/17] Wrap the unsafe functions to the special preupdate hook functions in a safe wrapper. --- src/hooks.rs | 97 ++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 68 insertions(+), 29 deletions(-) diff --git a/src/hooks.rs b/src/hooks.rs index 99dfe02..01bd412 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -48,27 +48,71 @@ mod preupdate_hook { use crate::types::ValueRef; use crate::{Connection, InnerConnection}; - // TODO: how to allow user access to these functions, since they should be only accessible in - // the scope of a preupdate_hook callback. - pub struct PreUpdateHookFunctions { + pub enum PreUpdateCase { + Insert(PreUpdateInsert), + Delete(PreUpdateDelete), + Update(PreUpdateUpdate), + } + + pub struct PreUpdateInsert { db: *mut ffi::sqlite3, } - impl PreUpdateHookFunctions { - pub unsafe fn get_count(&self) -> i32 { - ffi::sqlite3_preupdate_count(self.db) + impl PreUpdateInsert { + pub fn get_count(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub unsafe fn get_old(&self, i: i32) -> ValueRef { + pub fn get_new<'a>(&'a self, i: i32) -> ValueRef<'a> { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); - ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); - ValueRef::from_value(p_value) + unsafe { + ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } + } + + pub struct PreUpdateDelete { + db: *mut ffi::sqlite3, + } + + impl PreUpdateDelete { + pub fn get_count(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub unsafe fn get_new(&self, i: i32) -> ValueRef { + pub fn get_old<'a>(&'a self, i: i32) -> ValueRef<'a> { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); - ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); - ValueRef::from_value(p_value) + unsafe { + ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } + } + + pub struct PreUpdateUpdate { + db: *mut ffi::sqlite3, + } + + impl PreUpdateUpdate { + pub fn get_count(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_count(self.db) } + } + + pub fn get_old<'a>(&'a self, i: i32) -> ValueRef<'a> { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + unsafe { + ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } + + pub fn get_new<'a>(&'a self, i: i32) -> ValueRef<'a> { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + unsafe { + ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } } } @@ -88,7 +132,7 @@ mod preupdate_hook { #[inline] pub fn preupdate_hook<'c, F>(&'c self, hook: Option) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions) + Send + 'c, + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase) + Send + 'c, { self.db.borrow_mut().preupdate_hook(hook); } @@ -97,12 +141,12 @@ mod preupdate_hook { impl InnerConnection { #[inline] pub fn remove_preupdate_hook(&mut self) { - self.preupdate_hook(None::); + self.preupdate_hook(None::); } fn preupdate_hook<'c, F>(&'c mut self, hook: Option) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions) + Send + 'c, + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase) + Send + 'c, { unsafe extern "C" fn call_boxed_closure( p_arg: *mut c_void, @@ -113,7 +157,7 @@ mod preupdate_hook { row_id: i64, new_row_id: i64, ) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateHookFunctions), + F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase), { use std::ffi::CStr; use std::str; @@ -128,12 +172,12 @@ mod preupdate_hook { str::from_utf8(c_slice) }; - // TODO: how to properly allow a user to use the functions - // (sqlite3_preupdate_old,...) that are only in scope - // during the callback? - // Also how to pass in the rowids, because they can be undefined based on the - // action. - let preupdate_hook_functions = PreUpdateHookFunctions { db: sqlite }; + let preupdate_hook_functions = match action { + Action::SQLITE_INSERT => PreUpdateCase::Insert(PreUpdateInsert { db: sqlite }), + Action::SQLITE_DELETE => PreUpdateCase::Delete(PreUpdateDelete { db: sqlite }), + Action::SQLITE_UPDATE => PreUpdateCase::Update(PreUpdateUpdate { db: sqlite }), + _ => todo!(), + }; let _ = catch_unwind(|| { let boxed_hook: *mut F = p_arg as *mut F; @@ -179,7 +223,7 @@ mod preupdate_hook { #[cfg(test)] mod test { use super::super::Action; - use super::PreUpdateHookFunctions; + use super::PreUpdateCase; use crate::{Connection, Result}; #[test] @@ -188,12 +232,7 @@ mod preupdate_hook { let mut called = false; db.preupdate_hook(Some( - |action, - db: &str, - tbl: &str, - row_id, - new_row_id, - _func: &PreUpdateHookFunctions| { + |action, db: &str, tbl: &str, row_id, new_row_id, _func: &PreUpdateCase| { assert_eq!(Action::SQLITE_INSERT, action); assert_eq!("main", db); assert_eq!("foo", tbl); From e81c139fafb0d2165f2813c74fa212b6bc12f1da Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Thu, 8 Apr 2021 21:56:32 +0200 Subject: [PATCH 05/17] Removed explicit lifetimes to make clippy happy. --- src/hooks.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hooks.rs b/src/hooks.rs index 5b7888b..d7e0803 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -64,7 +64,7 @@ mod preupdate_hook { unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub fn get_new<'a>(&'a self, i: i32) -> ValueRef<'a> { + pub fn get_new(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); @@ -82,7 +82,7 @@ mod preupdate_hook { unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub fn get_old<'a>(&'a self, i: i32) -> ValueRef<'a> { + pub fn get_old(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); @@ -100,7 +100,7 @@ mod preupdate_hook { unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub fn get_old<'a>(&'a self, i: i32) -> ValueRef<'a> { + pub fn get_old(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); @@ -108,7 +108,7 @@ mod preupdate_hook { } } - pub fn get_new<'a>(&'a self, i: i32) -> ValueRef<'a> { + pub fn get_new(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); From 560ae50656f4d5227f4ff8eda5e6bd0dedeb37c9 Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Sun, 11 Apr 2021 12:33:08 +0200 Subject: [PATCH 06/17] Deduplicate accessing in different cases. Function duplication for delete-update and insert-update has been moved, as everything available in insert or delete is available for update. --- src/hooks.rs | 117 +++++++++++++++++++++++++++++++-------------------- 1 file changed, 72 insertions(+), 45 deletions(-) diff --git a/src/hooks.rs b/src/hooks.rs index d7e0803..97a3be1 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -49,40 +49,51 @@ mod preupdate_hook { use crate::types::ValueRef; use crate::{Connection, InnerConnection}; + /// `feature = "preupdate_hook"` + /// The possible cases for when a PreUpdateHook gets triggered. Allows access to the relevant + /// functions for each case through the contained values. pub enum PreUpdateCase { - Insert(PreUpdateInsert), - Delete(PreUpdateDelete), - Update(PreUpdateUpdate), + Insert(PreUpdateNewValueAccessor), + Delete(PreUpdateOldValueAccessor), + Update { + old_value_accessor: PreUpdateOldValueAccessor, + new_value_accessor: PreUpdateNewValueAccessor, + }, } - pub struct PreUpdateInsert { - db: *mut ffi::sqlite3, - } - - impl PreUpdateInsert { - pub fn get_count(&self) -> i32 { - unsafe { ffi::sqlite3_preupdate_count(self.db) } - } - - pub fn get_new(&self, i: i32) -> ValueRef { - let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); - unsafe { - ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); - ValueRef::from_value(p_value) + impl From for Action { + fn from(puc: PreUpdateCase) -> Action { + match puc { + PreUpdateCase::Insert(_) => Action::SQLITE_INSERT, + PreUpdateCase::Delete(_) => Action::SQLITE_DELETE, + PreUpdateCase::Update { .. } => Action::SQLITE_UPDATE, } } } - pub struct PreUpdateDelete { + /// `feature = "preupdate_hook"` + /// An accessor to access the old values of the row being deleted/updated during the preupdate callback. + pub struct PreUpdateOldValueAccessor { db: *mut ffi::sqlite3, + old_row_id: i64, } - impl PreUpdateDelete { - pub fn get_count(&self) -> i32 { + impl PreUpdateOldValueAccessor { + /// Get the amount of columns in the row being + /// deleted/updated. + pub fn get_column_count(&self) -> i32 { unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub fn get_old(&self, i: i32) -> ValueRef { + pub fn get_query_depth(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_depth(self.db) } + } + + pub fn get_old_row_id(&self) -> i64 { + self.old_row_id + } + + pub fn get_old_column_value(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); @@ -91,24 +102,29 @@ mod preupdate_hook { } } - pub struct PreUpdateUpdate { + /// `feature = "preupdate_hook"` + /// An accessor to access the new values of the row being inserted/updated during the preupdate callback. + pub struct PreUpdateNewValueAccessor { db: *mut ffi::sqlite3, + new_row_id: i64, } - impl PreUpdateUpdate { - pub fn get_count(&self) -> i32 { + impl PreUpdateNewValueAccessor { + /// Get the amount of columns in the row being + /// inserted/updated. + pub fn get_column_count(&self) -> i32 { unsafe { ffi::sqlite3_preupdate_count(self.db) } } - pub fn get_old(&self, i: i32) -> ValueRef { - let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); - unsafe { - ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); - ValueRef::from_value(p_value) - } + pub fn get_query_depth(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_depth(self.db) } } - pub fn get_new(&self, i: i32) -> ValueRef { + pub fn get_new_row_id(&self) -> i64 { + self.new_row_id + } + + pub fn get_new_column_value(&self, i: i32) -> ValueRef { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); @@ -124,16 +140,14 @@ mod preupdate_hook { /// /// The callback parameters are: /// - /// - 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, - /// - for an update or delete, the initial ROWID of the row that is going to be updated/deleted. It is undefined for inserts. - /// - for an update or insert, the final ROWID of the row that is going to be updated/inserted. It is undefined for deletes. + /// - a variant of the PreUpdateCase enum which allows access to extra functions depending + /// on whether it's an update, delete or insert. #[inline] pub fn preupdate_hook<'c, F>(&'c self, hook: Option) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase) + Send + 'c, + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'c, { self.db.borrow_mut().preupdate_hook(hook); } @@ -142,12 +156,12 @@ mod preupdate_hook { impl InnerConnection { #[inline] pub fn remove_preupdate_hook(&mut self) { - self.preupdate_hook(None::); + self.preupdate_hook(None::); } fn preupdate_hook<'c, F>(&'c mut self, hook: Option) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase) + Send + 'c, + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'c, { unsafe extern "C" fn call_boxed_closure( p_arg: *mut c_void, @@ -155,10 +169,10 @@ mod preupdate_hook { action_code: c_int, db_str: *const c_char, tbl_str: *const c_char, - row_id: i64, + old_row_id: i64, new_row_id: i64, ) where - F: FnMut(Action, &str, &str, i64, i64, &PreUpdateCase), + F: FnMut(Action, &str, &str, &PreUpdateCase), { use std::ffi::CStr; use std::str; @@ -174,9 +188,24 @@ mod preupdate_hook { }; let preupdate_hook_functions = match action { - Action::SQLITE_INSERT => PreUpdateCase::Insert(PreUpdateInsert { db: sqlite }), - Action::SQLITE_DELETE => PreUpdateCase::Delete(PreUpdateDelete { db: sqlite }), - Action::SQLITE_UPDATE => PreUpdateCase::Update(PreUpdateUpdate { db: sqlite }), + Action::SQLITE_INSERT => PreUpdateCase::Insert(PreUpdateNewValueAccessor { + db: sqlite, + new_row_id, + }), + Action::SQLITE_DELETE => PreUpdateCase::Delete(PreUpdateOldValueAccessor { + db: sqlite, + old_row_id, + }), + Action::SQLITE_UPDATE => PreUpdateCase::Update { + old_value_accessor: PreUpdateOldValueAccessor { + db: sqlite, + old_row_id, + }, + new_value_accessor: PreUpdateNewValueAccessor { + db: sqlite, + new_row_id, + }, + }, _ => todo!(), }; @@ -186,8 +215,6 @@ mod preupdate_hook { action, db_name.expect("illegal db name"), tbl_name.expect("illegal table name"), - row_id, - new_row_id, &preupdate_hook_functions, ); }); From b51b541d7f871e7fca0a17fe8dbdf1ec1f470244 Mon Sep 17 00:00:00 2001 From: Midas Lambrichts Date: Sun, 23 May 2021 12:14:02 +0200 Subject: [PATCH 07/17] Made preupdate_hook module public. --- src/hooks.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hooks.rs b/src/hooks.rs index 97a3be1..fa3c674 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -37,7 +37,7 @@ unsafe fn free_boxed_hook(p: *mut c_void) { } #[cfg(feature = "preupdate_hook")] -mod preupdate_hook { +pub mod preupdate_hook { use super::free_boxed_hook; use super::Action; From b910eafee5f82d6f82fcc4175c49d829c548977d Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sat, 30 Mar 2024 06:15:58 -0500 Subject: [PATCH 08/17] move preupdate hook to separate file --- Cargo.toml | 2 +- src/hooks.rs | 434 ------------------- src/hooks/mod.rs | 813 ++++++++++++++++++++++++++++++++++++ src/hooks/preupdate_hook.rs | 333 +++++++++++++++ src/inner_connection.rs | 66 +++ src/lib.rs | 2 +- 6 files changed, 1214 insertions(+), 436 deletions(-) delete mode 100644 src/hooks.rs create mode 100644 src/hooks/mod.rs create mode 100644 src/hooks/preupdate_hook.rs diff --git a/Cargo.toml b/Cargo.toml index 75d0d77..9519a6e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,7 +52,7 @@ buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"] limits = [] loadable_extension = ["libsqlite3-sys/loadable_extension"] hooks = [] -preupdate_hook = ["libsqlite3-sys/preupdate_hook"] +preupdate_hook = ["libsqlite3-sys/preupdate_hook", "hooks"] i128_blob = [] sqlcipher = ["libsqlite3-sys/sqlcipher"] unlock_notify = ["libsqlite3-sys/unlock_notify"] diff --git a/src/hooks.rs b/src/hooks.rs deleted file mode 100644 index b349078..0000000 --- a/src/hooks.rs +++ /dev/null @@ -1,434 +0,0 @@ -//! Commit, Data Change and Rollback Notification Callbacks -#![allow(non_camel_case_types)] -use std::os::raw::c_void; - -use crate::ffi; - -/// Action Codes -#[derive(Clone, Copy, Debug, Eq, PartialEq)] -#[repr(i32)] -#[non_exhaustive] -#[allow(clippy::upper_case_acronyms)] -pub enum Action { - /// Unsupported / unexpected action - UNKNOWN = -1, - /// DELETE command - SQLITE_DELETE = ffi::SQLITE_DELETE, - /// INSERT command - SQLITE_INSERT = ffi::SQLITE_INSERT, - /// UPDATE command - SQLITE_UPDATE = ffi::SQLITE_UPDATE, -} - -impl From for Action { - #[inline] - 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 { - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a transaction is committed. - /// - /// The callback returns `true` to rollback. - #[inline] - pub fn commit_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut() -> bool + Send + 'c, - { - self.db.borrow_mut().commit_hook(hook); - } - - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a transaction is committed. - /// - /// The callback returns `true` to rollback. - #[inline] - pub fn rollback_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut() + Send + 'c, - { - self.db.borrow_mut().rollback_hook(hook); - } - - /// `feature = "hooks"` Register a callback function to be invoked whenever - /// a row is updated, inserted or deleted in a rowid table. - /// - /// The callback parameters are: - /// - /// - 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. - #[inline] - pub fn update_hook<'c, F>(&'c self, hook: Option) - where - F: FnMut(Action, &str, &str, i64) + Send + 'c, - { - self.db.borrow_mut().update_hook(hook); - } - - /// `feature = "hooks"` Register a query progress callback. - /// - /// The parameter `num_ops` is the approximate number of virtual machine - /// instructions that are evaluated between successive invocations of the - /// `handler`. If `num_ops` is less than one then the progress handler - /// is disabled. - /// - /// If the progress callback returns `true`, the operation is interrupted. - pub fn progress_handler(&self, num_ops: c_int, handler: Option) - where - F: FnMut() -> bool + Send + RefUnwindSafe + 'static, - { - self.db.borrow_mut().progress_handler(num_ops, handler); - } -} - -impl InnerConnection { - #[inline] - pub fn remove_hooks(&mut self) { - self.update_hook(None::); - self.commit_hook(None:: bool>); - self.rollback_hook(None::); - self.progress_handler(0, None:: bool>); - } - - fn commit_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut() -> bool + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int - 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 { - 1 - } else { - 0 - } - } - - // 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`. - let free_commit_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_commit_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_commit_hook = free_commit_hook; - } - - fn rollback_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut() + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) - where - F: FnMut(), - { - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; - (*boxed_hook)(); - }); - } - - let free_rollback_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_rollback_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_rollback_hook = free_rollback_hook; - } - - fn update_hook<'c, F>(&'c mut self, hook: Option) - where - F: FnMut(Action, &str, &str, i64) + Send + 'c, - { - unsafe extern "C" fn call_boxed_closure( - 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(c_slice) - }; - let tbl_name = { - let c_slice = CStr::from_ptr(tbl_str).to_bytes(); - str::from_utf8(c_slice) - }; - - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; - (*boxed_hook)( - action, - db_name.expect("illegal db name"), - tbl_name.expect("illegal table name"), - row_id, - ); - }); - } - - let free_update_hook = if hook.is_some() { - Some(free_boxed_hook:: as unsafe fn(*mut c_void)) - } else { - None - }; - - 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::), - boxed_hook as *mut _, - ) - } - } - _ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) }, - }; - if !previous_hook.is_null() { - if let Some(free_boxed_hook) = self.free_update_hook { - unsafe { free_boxed_hook(previous_hook) }; - } - } - self.free_update_hook = free_update_hook; - } - - fn progress_handler(&mut self, num_ops: c_int, handler: Option) - where - F: FnMut() -> bool + Send + RefUnwindSafe + 'static, - { - unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int - where - F: FnMut() -> bool, - { - let r = catch_unwind(|| { - let boxed_handler: *mut F = p_arg as *mut F; - (*boxed_handler)() - }); - if let Ok(true) = r { - 1 - } else { - 0 - } - } - - match handler { - Some(handler) => { - let boxed_handler = Box::new(handler); - unsafe { - ffi::sqlite3_progress_handler( - self.db(), - num_ops, - Some(call_boxed_closure::), - &*boxed_handler as *const F as *mut _, - ) - } - self.progress_handler = Some(boxed_handler); - } - _ => { - unsafe { ffi::sqlite3_progress_handler(self.db(), num_ops, None, ptr::null_mut()) } - self.progress_handler = None; - } - }; - } -} - -unsafe fn free_boxed_hook(p: *mut c_void) { - drop(Box::from_raw(p as *mut F)); -} - - #[cfg(test)] - mod test { - use super::super::Action; - use crate::{Connection, Result}; - use std::sync::atomic::{AtomicBool, Ordering}; - - #[test] - fn test_commit_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - let mut called = false; - db.commit_hook(Some(|| { - called = true; - false - })); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; - assert!(called); - Ok(()) - } - - #[test] - fn test_fn_commit_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - fn hook() -> bool { - true - } - - db.commit_hook(Some(hook)); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") - .unwrap_err(); - Ok(()) - } - - #[test] - fn test_rollback_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - let mut called = false; - db.rollback_hook(Some(|| { - called = true; - })); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")?; - assert!(called); - Ok(()) - } - - #[test] - fn test_update_hook() -> Result<()> { - let db = Connection::open_in_memory()?; - - let mut called = false; - 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); - called = true; - })); - db.execute_batch("CREATE TABLE foo (t TEXT)")?; - db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; - assert!(called); - Ok(()) - } - - #[test] - fn test_progress_handler() -> Result<()> { - let db = Connection::open_in_memory()?; - - static CALLED: AtomicBool = AtomicBool::new(false); - db.progress_handler( - 1, - Some(|| { - CALLED.store(true, Ordering::Relaxed); - false - }), - ); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; - assert!(CALLED.load(Ordering::Relaxed)); - Ok(()) - } - - #[test] - fn test_progress_handler_interrupt() -> Result<()> { - let db = Connection::open_in_memory()?; - - fn handler() -> bool { - true - } - - db.progress_handler(1, Some(handler)); - db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") - .unwrap_err(); - Ok(()) - } - } - - #[test] - fn test_authorizer() -> Result<()> { - use super::{AuthAction, AuthContext, Authorization}; - - let db = Connection::open_in_memory()?; - db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)") - .unwrap(); - - let authorizer = move |ctx: AuthContext<'_>| match ctx.action { - AuthAction::Read { - column_name: "private", - .. - } => Authorization::Ignore, - AuthAction::DropTable { .. } => Authorization::Deny, - AuthAction::Pragma { .. } => panic!("shouldn't be called"), - _ => Authorization::Allow, - }; - - db.authorizer(Some(authorizer)); - db.execute_batch( - "BEGIN TRANSACTION; INSERT INTO foo VALUES ('pub txt', 'priv txt'); COMMIT;", - ) - .unwrap(); - db.query_row_and_then("SELECT * FROM foo", [], |row| -> Result<()> { - assert_eq!(row.get::<_, String>("public")?, "pub txt"); - assert!(row.get::<_, Option>("private")?.is_none()); - Ok(()) - }) - .unwrap(); - db.execute_batch("DROP TABLE foo").unwrap_err(); - - db.authorizer(None::) -> Authorization>); - db.execute_batch("PRAGMA user_version=1").unwrap(); // Disallowed by first authorizer, but it's now removed. - - Ok(()) - } -} diff --git a/src/hooks/mod.rs b/src/hooks/mod.rs new file mode 100644 index 0000000..eacf8d7 --- /dev/null +++ b/src/hooks/mod.rs @@ -0,0 +1,813 @@ +//! Commit, Data Change and Rollback Notification Callbacks +#![allow(non_camel_case_types)] + +use std::os::raw::{c_char, c_int, c_void}; +use std::panic::{catch_unwind, RefUnwindSafe}; +use std::ptr; + +use crate::ffi; + +use crate::{Connection, InnerConnection}; + +#[cfg(feature = "preupdate_hook")] +pub use preupdate_hook::*; + +#[cfg(feature = "preupdate_hook")] +mod preupdate_hook; + +/// Action Codes +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[repr(i32)] +#[non_exhaustive] +#[allow(clippy::upper_case_acronyms)] +pub enum Action { + /// Unsupported / unexpected action + UNKNOWN = -1, + /// DELETE command + SQLITE_DELETE = ffi::SQLITE_DELETE, + /// INSERT command + SQLITE_INSERT = ffi::SQLITE_INSERT, + /// UPDATE command + SQLITE_UPDATE = ffi::SQLITE_UPDATE, +} + +impl From for Action { + #[inline] + 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, + } + } +} + +/// The context received by an authorizer hook. +/// +/// See for more info. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct AuthContext<'c> { + /// The action to be authorized. + pub action: AuthAction<'c>, + + /// The database name, if applicable. + pub database_name: Option<&'c str>, + + /// The inner-most trigger or view responsible for the access attempt. + /// `None` if the access attempt was made by top-level SQL code. + pub accessor: Option<&'c str>, +} + +/// Actions and arguments found within a statement during +/// preparation. +/// +/// See for more info. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +#[allow(missing_docs)] +pub enum AuthAction<'c> { + /// This variant is not normally produced by SQLite. You may encounter it + // if you're using a different version than what's supported by this library. + Unknown { + /// The unknown authorization action code. + code: i32, + /// The third arg to the authorizer callback. + arg1: Option<&'c str>, + /// The fourth arg to the authorizer callback. + arg2: Option<&'c str>, + }, + CreateIndex { + index_name: &'c str, + table_name: &'c str, + }, + CreateTable { + table_name: &'c str, + }, + CreateTempIndex { + index_name: &'c str, + table_name: &'c str, + }, + CreateTempTable { + table_name: &'c str, + }, + CreateTempTrigger { + trigger_name: &'c str, + table_name: &'c str, + }, + CreateTempView { + view_name: &'c str, + }, + CreateTrigger { + trigger_name: &'c str, + table_name: &'c str, + }, + CreateView { + view_name: &'c str, + }, + Delete { + table_name: &'c str, + }, + DropIndex { + index_name: &'c str, + table_name: &'c str, + }, + DropTable { + table_name: &'c str, + }, + DropTempIndex { + index_name: &'c str, + table_name: &'c str, + }, + DropTempTable { + table_name: &'c str, + }, + DropTempTrigger { + trigger_name: &'c str, + table_name: &'c str, + }, + DropTempView { + view_name: &'c str, + }, + DropTrigger { + trigger_name: &'c str, + table_name: &'c str, + }, + DropView { + view_name: &'c str, + }, + Insert { + table_name: &'c str, + }, + Pragma { + pragma_name: &'c str, + /// The pragma value, if present (e.g., `PRAGMA name = value;`). + pragma_value: Option<&'c str>, + }, + Read { + table_name: &'c str, + column_name: &'c str, + }, + Select, + Transaction { + operation: TransactionOperation, + }, + Update { + table_name: &'c str, + column_name: &'c str, + }, + Attach { + filename: &'c str, + }, + Detach { + database_name: &'c str, + }, + AlterTable { + database_name: &'c str, + table_name: &'c str, + }, + Reindex { + index_name: &'c str, + }, + Analyze { + table_name: &'c str, + }, + CreateVtable { + table_name: &'c str, + module_name: &'c str, + }, + DropVtable { + table_name: &'c str, + module_name: &'c str, + }, + Function { + function_name: &'c str, + }, + Savepoint { + operation: TransactionOperation, + savepoint_name: &'c str, + }, + Recursive, +} + +impl<'c> AuthAction<'c> { + fn from_raw(code: i32, arg1: Option<&'c str>, arg2: Option<&'c str>) -> Self { + match (code, arg1, arg2) { + (ffi::SQLITE_CREATE_INDEX, Some(index_name), Some(table_name)) => Self::CreateIndex { + index_name, + table_name, + }, + (ffi::SQLITE_CREATE_TABLE, Some(table_name), _) => Self::CreateTable { table_name }, + (ffi::SQLITE_CREATE_TEMP_INDEX, Some(index_name), Some(table_name)) => { + Self::CreateTempIndex { + index_name, + table_name, + } + } + (ffi::SQLITE_CREATE_TEMP_TABLE, Some(table_name), _) => { + Self::CreateTempTable { table_name } + } + (ffi::SQLITE_CREATE_TEMP_TRIGGER, Some(trigger_name), Some(table_name)) => { + Self::CreateTempTrigger { + trigger_name, + table_name, + } + } + (ffi::SQLITE_CREATE_TEMP_VIEW, Some(view_name), _) => { + Self::CreateTempView { view_name } + } + (ffi::SQLITE_CREATE_TRIGGER, Some(trigger_name), Some(table_name)) => { + Self::CreateTrigger { + trigger_name, + table_name, + } + } + (ffi::SQLITE_CREATE_VIEW, Some(view_name), _) => Self::CreateView { view_name }, + (ffi::SQLITE_DELETE, Some(table_name), None) => Self::Delete { table_name }, + (ffi::SQLITE_DROP_INDEX, Some(index_name), Some(table_name)) => Self::DropIndex { + index_name, + table_name, + }, + (ffi::SQLITE_DROP_TABLE, Some(table_name), _) => Self::DropTable { table_name }, + (ffi::SQLITE_DROP_TEMP_INDEX, Some(index_name), Some(table_name)) => { + Self::DropTempIndex { + index_name, + table_name, + } + } + (ffi::SQLITE_DROP_TEMP_TABLE, Some(table_name), _) => { + Self::DropTempTable { table_name } + } + (ffi::SQLITE_DROP_TEMP_TRIGGER, Some(trigger_name), Some(table_name)) => { + Self::DropTempTrigger { + trigger_name, + table_name, + } + } + (ffi::SQLITE_DROP_TEMP_VIEW, Some(view_name), _) => Self::DropTempView { view_name }, + (ffi::SQLITE_DROP_TRIGGER, Some(trigger_name), Some(table_name)) => Self::DropTrigger { + trigger_name, + table_name, + }, + (ffi::SQLITE_DROP_VIEW, Some(view_name), _) => Self::DropView { view_name }, + (ffi::SQLITE_INSERT, Some(table_name), _) => Self::Insert { table_name }, + (ffi::SQLITE_PRAGMA, Some(pragma_name), pragma_value) => Self::Pragma { + pragma_name, + pragma_value, + }, + (ffi::SQLITE_READ, Some(table_name), Some(column_name)) => Self::Read { + table_name, + column_name, + }, + (ffi::SQLITE_SELECT, ..) => Self::Select, + (ffi::SQLITE_TRANSACTION, Some(operation_str), _) => Self::Transaction { + operation: TransactionOperation::from_str(operation_str), + }, + (ffi::SQLITE_UPDATE, Some(table_name), Some(column_name)) => Self::Update { + table_name, + column_name, + }, + (ffi::SQLITE_ATTACH, Some(filename), _) => Self::Attach { filename }, + (ffi::SQLITE_DETACH, Some(database_name), _) => Self::Detach { database_name }, + (ffi::SQLITE_ALTER_TABLE, Some(database_name), Some(table_name)) => Self::AlterTable { + database_name, + table_name, + }, + (ffi::SQLITE_REINDEX, Some(index_name), _) => Self::Reindex { index_name }, + (ffi::SQLITE_ANALYZE, Some(table_name), _) => Self::Analyze { table_name }, + (ffi::SQLITE_CREATE_VTABLE, Some(table_name), Some(module_name)) => { + Self::CreateVtable { + table_name, + module_name, + } + } + (ffi::SQLITE_DROP_VTABLE, Some(table_name), Some(module_name)) => Self::DropVtable { + table_name, + module_name, + }, + (ffi::SQLITE_FUNCTION, _, Some(function_name)) => Self::Function { function_name }, + (ffi::SQLITE_SAVEPOINT, Some(operation_str), Some(savepoint_name)) => Self::Savepoint { + operation: TransactionOperation::from_str(operation_str), + savepoint_name, + }, + (ffi::SQLITE_RECURSIVE, ..) => Self::Recursive, + (code, arg1, arg2) => Self::Unknown { code, arg1, arg2 }, + } + } +} + +pub(crate) type BoxedAuthorizer = + Box FnMut(AuthContext<'c>) -> Authorization + Send + 'static>; + +/// A transaction operation. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +#[allow(missing_docs)] +pub enum TransactionOperation { + Unknown, + Begin, + Release, + Rollback, +} + +impl TransactionOperation { + fn from_str(op_str: &str) -> Self { + match op_str { + "BEGIN" => Self::Begin, + "RELEASE" => Self::Release, + "ROLLBACK" => Self::Rollback, + _ => Self::Unknown, + } + } +} + +/// [`authorizer`](Connection::authorizer) return code +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +#[non_exhaustive] +pub enum Authorization { + /// Authorize the action. + Allow, + /// Don't allow access, but don't trigger an error either. + Ignore, + /// Trigger an error. + Deny, +} + +impl Authorization { + fn into_raw(self) -> c_int { + match self { + Self::Allow => ffi::SQLITE_OK, + Self::Ignore => ffi::SQLITE_IGNORE, + Self::Deny => ffi::SQLITE_DENY, + } + } +} + +impl Connection { + /// Register a callback function to be invoked whenever + /// a transaction is committed. + /// + /// The callback returns `true` to rollback. + #[inline] + pub fn commit_hook(&self, hook: Option) + where + F: FnMut() -> bool + Send + 'static, + { + self.db.borrow_mut().commit_hook(hook); + } + + /// Register a callback function to be invoked whenever + /// a transaction is committed. + #[inline] + pub fn rollback_hook(&self, hook: Option) + where + F: FnMut() + Send + 'static, + { + self.db.borrow_mut().rollback_hook(hook); + } + + /// Register a callback function to be invoked whenever + /// a row is updated, inserted or deleted in a rowid table. + /// + /// The callback parameters are: + /// + /// - 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. + #[inline] + pub fn update_hook(&self, hook: Option) + where + F: FnMut(Action, &str, &str, i64) + Send + 'static, + { + self.db.borrow_mut().update_hook(hook); + } + + /// Register a query progress callback. + /// + /// The parameter `num_ops` is the approximate number of virtual machine + /// instructions that are evaluated between successive invocations of the + /// `handler`. If `num_ops` is less than one then the progress handler + /// is disabled. + /// + /// If the progress callback returns `true`, the operation is interrupted. + pub fn progress_handler(&self, num_ops: c_int, handler: Option) + where + F: FnMut() -> bool + Send + RefUnwindSafe + 'static, + { + self.db.borrow_mut().progress_handler(num_ops, handler); + } + + /// Register an authorizer callback that's invoked + /// as a statement is being prepared. + #[inline] + pub fn authorizer<'c, F>(&self, hook: Option) + where + F: for<'r> FnMut(AuthContext<'r>) -> Authorization + Send + RefUnwindSafe + 'static, + { + self.db.borrow_mut().authorizer(hook); + } +} + +impl InnerConnection { + #[inline] + pub fn remove_hooks(&mut self) { + self.update_hook(None::); + self.commit_hook(None:: bool>); + self.rollback_hook(None::); + self.progress_handler(0, None:: bool>); + self.authorizer(None::) -> Authorization>); + } + + fn commit_hook(&mut self, hook: Option) + where + F: FnMut() -> bool + Send + 'static, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int + where + F: FnMut() -> bool, + { + let r = catch_unwind(|| { + let boxed_hook: *mut F = p_arg.cast::(); + (*boxed_hook)() + }); + c_int::from(r.unwrap_or_default()) + } + + // 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`. + let free_commit_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook.cast(), + ) + } + } + _ => unsafe { ffi::sqlite3_commit_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_commit_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_commit_hook = free_commit_hook; + } + + fn rollback_hook(&mut self, hook: Option) + where + F: FnMut() + Send + 'static, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) + where + F: FnMut(), + { + drop(catch_unwind(|| { + let boxed_hook: *mut F = p_arg.cast::(); + (*boxed_hook)(); + })); + } + + let free_rollback_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook.cast(), + ) + } + } + _ => unsafe { ffi::sqlite3_rollback_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_rollback_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_rollback_hook = free_rollback_hook; + } + + fn update_hook(&mut self, hook: Option) + where + F: FnMut(Action, &str, &str, i64) + Send + 'static, + { + unsafe extern "C" fn call_boxed_closure( + p_arg: *mut c_void, + action_code: c_int, + p_db_name: *const c_char, + p_table_name: *const c_char, + row_id: i64, + ) where + F: FnMut(Action, &str, &str, i64), + { + let action = Action::from(action_code); + drop(catch_unwind(|| { + let boxed_hook: *mut F = p_arg.cast::(); + (*boxed_hook)( + action, + expect_utf8(p_db_name, "database name"), + expect_utf8(p_table_name, "table name"), + row_id, + ); + })); + } + + let free_update_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + 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::), + boxed_hook.cast(), + ) + } + } + _ => unsafe { ffi::sqlite3_update_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_update_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_update_hook = free_update_hook; + } + + fn progress_handler(&mut self, num_ops: c_int, handler: Option) + where + F: FnMut() -> bool + Send + RefUnwindSafe + 'static, + { + unsafe extern "C" fn call_boxed_closure(p_arg: *mut c_void) -> c_int + where + F: FnMut() -> bool, + { + let r = catch_unwind(|| { + let boxed_handler: *mut F = p_arg.cast::(); + (*boxed_handler)() + }); + c_int::from(r.unwrap_or_default()) + } + + if let Some(handler) = handler { + let boxed_handler = Box::new(handler); + unsafe { + ffi::sqlite3_progress_handler( + self.db(), + num_ops, + Some(call_boxed_closure::), + &*boxed_handler as *const F as *mut _, + ); + } + self.progress_handler = Some(boxed_handler); + } else { + unsafe { ffi::sqlite3_progress_handler(self.db(), num_ops, None, ptr::null_mut()) } + self.progress_handler = None; + }; + } + + fn authorizer<'c, F>(&'c mut self, authorizer: Option) + where + F: for<'r> FnMut(AuthContext<'r>) -> Authorization + Send + RefUnwindSafe + 'static, + { + unsafe extern "C" fn call_boxed_closure<'c, F>( + p_arg: *mut c_void, + action_code: c_int, + param1: *const c_char, + param2: *const c_char, + db_name: *const c_char, + trigger_or_view_name: *const c_char, + ) -> c_int + where + F: FnMut(AuthContext<'c>) -> Authorization + Send + 'static, + { + catch_unwind(|| { + let action = AuthAction::from_raw( + action_code, + expect_optional_utf8(param1, "authorizer param 1"), + expect_optional_utf8(param2, "authorizer param 2"), + ); + let auth_ctx = AuthContext { + action, + database_name: expect_optional_utf8(db_name, "database name"), + accessor: expect_optional_utf8( + trigger_or_view_name, + "accessor (inner-most trigger or view)", + ), + }; + let boxed_hook: *mut F = p_arg.cast::(); + (*boxed_hook)(auth_ctx) + }) + .map_or_else(|_| ffi::SQLITE_ERROR, Authorization::into_raw) + } + + let callback_fn = authorizer + .as_ref() + .map(|_| call_boxed_closure::<'c, F> as unsafe extern "C" fn(_, _, _, _, _, _) -> _); + let boxed_authorizer = authorizer.map(Box::new); + + match unsafe { + ffi::sqlite3_set_authorizer( + self.db(), + callback_fn, + boxed_authorizer + .as_ref() + .map_or_else(ptr::null_mut, |f| &**f as *const F as *mut _), + ) + } { + ffi::SQLITE_OK => { + self.authorizer = boxed_authorizer.map(|ba| ba as _); + } + err_code => { + // The only error that `sqlite3_set_authorizer` returns is `SQLITE_MISUSE` + // when compiled with `ENABLE_API_ARMOR` and the db pointer is invalid. + // This library does not allow constructing a null db ptr, so if this branch + // is hit, something very bad has happened. Panicking instead of returning + // `Result` keeps this hook's API consistent with the others. + panic!("unexpectedly failed to set_authorizer: {}", unsafe { + crate::error::error_from_handle(self.db(), err_code) + }); + } + } + } +} + +unsafe fn free_boxed_hook(p: *mut c_void) { + drop(Box::from_raw(p.cast::())); +} + +unsafe fn expect_utf8<'a>(p_str: *const c_char, description: &'static str) -> &'a str { + expect_optional_utf8(p_str, description) + .unwrap_or_else(|| panic!("received empty {description}")) +} + +unsafe fn expect_optional_utf8<'a>( + p_str: *const c_char, + description: &'static str, +) -> Option<&'a str> { + if p_str.is_null() { + return None; + } + std::ffi::CStr::from_ptr(p_str) + .to_str() + .unwrap_or_else(|_| panic!("received non-utf8 string as {description}")) + .into() +} + +#[cfg(test)] +mod test { + use super::Action; + use crate::{Connection, Result}; + use std::sync::atomic::{AtomicBool, Ordering}; + + #[test] + fn test_commit_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + static CALLED: AtomicBool = AtomicBool::new(false); + db.commit_hook(Some(|| { + CALLED.store(true, Ordering::Relaxed); + false + })); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; + assert!(CALLED.load(Ordering::Relaxed)); + Ok(()) + } + + #[test] + fn test_fn_commit_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + fn hook() -> bool { + true + } + + db.commit_hook(Some(hook)); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") + .unwrap_err(); + Ok(()) + } + + #[test] + fn test_rollback_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + static CALLED: AtomicBool = AtomicBool::new(false); + db.rollback_hook(Some(|| { + CALLED.store(true, Ordering::Relaxed); + })); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); ROLLBACK;")?; + assert!(CALLED.load(Ordering::Relaxed)); + Ok(()) + } + + #[test] + fn test_update_hook() -> Result<()> { + let db = Connection::open_in_memory()?; + + static CALLED: AtomicBool = AtomicBool::new(false); + 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); + CALLED.store(true, Ordering::Relaxed); + })); + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + assert!(CALLED.load(Ordering::Relaxed)); + Ok(()) + } + + #[test] + fn test_progress_handler() -> Result<()> { + let db = Connection::open_in_memory()?; + + static CALLED: AtomicBool = AtomicBool::new(false); + db.progress_handler( + 1, + Some(|| { + CALLED.store(true, Ordering::Relaxed); + false + }), + ); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;")?; + assert!(CALLED.load(Ordering::Relaxed)); + Ok(()) + } + + #[test] + fn test_progress_handler_interrupt() -> Result<()> { + let db = Connection::open_in_memory()?; + + fn handler() -> bool { + true + } + + db.progress_handler(1, Some(handler)); + db.execute_batch("BEGIN; CREATE TABLE foo (t TEXT); COMMIT;") + .unwrap_err(); + Ok(()) + } + + #[test] + fn test_authorizer() -> Result<()> { + use super::{AuthAction, AuthContext, Authorization}; + + let db = Connection::open_in_memory()?; + db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)") + .unwrap(); + + let authorizer = move |ctx: AuthContext<'_>| match ctx.action { + AuthAction::Read { + column_name: "private", + .. + } => Authorization::Ignore, + AuthAction::DropTable { .. } => Authorization::Deny, + AuthAction::Pragma { .. } => panic!("shouldn't be called"), + _ => Authorization::Allow, + }; + + db.authorizer(Some(authorizer)); + db.execute_batch( + "BEGIN TRANSACTION; INSERT INTO foo VALUES ('pub txt', 'priv txt'); COMMIT;", + ) + .unwrap(); + db.query_row_and_then("SELECT * FROM foo", [], |row| -> Result<()> { + assert_eq!(row.get::<_, String>("public")?, "pub txt"); + assert!(row.get::<_, Option>("private")?.is_none()); + Ok(()) + }) + .unwrap(); + db.execute_batch("DROP TABLE foo").unwrap_err(); + + db.authorizer(None::) -> Authorization>); + db.execute_batch("PRAGMA user_version=1").unwrap(); // Disallowed by first authorizer, but it's now removed. + + Ok(()) + } +} diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs new file mode 100644 index 0000000..4f30416 --- /dev/null +++ b/src/hooks/preupdate_hook.rs @@ -0,0 +1,333 @@ +use std::fmt::Debug; +use std::os::raw::{c_char, c_int, c_void}; +use std::panic::catch_unwind; +use std::ptr; + +use super::expect_utf8; +use super::free_boxed_hook; +use super::Action; + +use crate::ffi; +use crate::inner_connection::InnerConnection; +use crate::types::ValueRef; +use crate::Connection; + +/// The possible cases for when a PreUpdateHook gets triggered. Allows access to the relevant +/// functions for each case through the contained values. +#[derive(Debug)] +pub enum PreUpdateCase { + /// Pre-update hook was triggered by an insert. + Insert(PreUpdateNewValueAccessor), + /// Pre-update hook was triggered by a delete. + Delete(PreUpdateOldValueAccessor), + /// Pre-update hook was triggered by an update. + Update { + #[allow(missing_docs)] + old_value_accessor: PreUpdateOldValueAccessor, + #[allow(missing_docs)] + new_value_accessor: PreUpdateNewValueAccessor, + }, + /// This variant is not normally produced by SQLite. You may encounter it + /// if you're using a different version than what's supported by this library. + Unknown, +} + +impl From for Action { + fn from(puc: PreUpdateCase) -> Action { + match puc { + PreUpdateCase::Insert(_) => Action::SQLITE_INSERT, + PreUpdateCase::Delete(_) => Action::SQLITE_DELETE, + PreUpdateCase::Update { .. } => Action::SQLITE_UPDATE, + PreUpdateCase::Unknown => Action::UNKNOWN, + } + } +} + +/// An accessor to access the old values of the row being deleted/updated during the preupdate callback. +#[derive(Debug)] +pub struct PreUpdateOldValueAccessor { + db: *mut ffi::sqlite3, + old_row_id: i64, +} + +impl PreUpdateOldValueAccessor { + /// Get the amount of columns in the row being deleted/updated. + pub fn get_column_count(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_count(self.db) } + } + + /// Get the depth of the query that triggered the preupdate hook. + /// Returns 0 if the preupdate callback was invoked as a result of + /// a direct insert, update, or delete operation; + /// 1 for inserts, updates, or deletes invoked by top-level triggers; + /// 2 for changes resulting from triggers called by top-level triggers; and so forth. + pub fn get_query_depth(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_depth(self.db) } + } + + /// Get the row id of the row being updated/deleted. + pub fn get_old_row_id(&self) -> i64 { + self.old_row_id + } + + /// Get the value of the row being updated/deleted at the specified index. + pub fn get_old_column_value(&self, i: i32) -> ValueRef { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + unsafe { + ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } +} + +/// An accessor to access the new values of the row being inserted/updated +/// during the preupdate callback. +#[derive(Debug)] +pub struct PreUpdateNewValueAccessor { + db: *mut ffi::sqlite3, + new_row_id: i64, +} + +impl PreUpdateNewValueAccessor { + /// Get the amount of columns in the row being inserted/updated. + pub fn get_column_count(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_count(self.db) } + } + + /// Get the depth of the query that triggered the preupdate hook. + /// Returns 0 if the preupdate callback was invoked as a result of + /// a direct insert, update, or delete operation; + /// 1 for inserts, updates, or deletes invoked by top-level triggers; + /// 2 for changes resulting from triggers called by top-level triggers; and so forth. + pub fn get_query_depth(&self) -> i32 { + unsafe { ffi::sqlite3_preupdate_depth(self.db) } + } + + /// Get the row id of the row being inserted/updated. + pub fn get_new_row_id(&self) -> i64 { + self.new_row_id + } + + /// Get the value of the row being updated/deleted at the specified index. + pub fn get_new_column_value(&self, i: i32) -> ValueRef { + let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); + unsafe { + ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); + ValueRef::from_value(p_value) + } + } +} + +impl Connection { + /// Register a callback function to be invoked before + /// a row is updated, inserted or deleted. + /// + /// The callback parameters are: + /// + /// - the name of the database ("main", "temp", ...), + /// - the name of the table that is updated, + /// - a variant of the PreUpdateCase enum which allows access to extra functions depending + /// on whether it's an update, delete or insert. + #[inline] + pub fn preupdate_hook(&self, hook: Option) + where + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send, + { + self.db.borrow_mut().preupdate_hook(hook); + } +} + +impl InnerConnection { + #[inline] + pub fn remove_preupdate_hook(&mut self) { + self.preupdate_hook(None::); + } + + fn preupdate_hook<'c, F>(&'c mut self, hook: Option) + where + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'c, + { + unsafe extern "C" fn call_boxed_closure( + p_arg: *mut c_void, + sqlite: *mut ffi::sqlite3, + action_code: c_int, + db_name: *const c_char, + tbl_name: *const c_char, + old_row_id: i64, + new_row_id: i64, + ) where + F: FnMut(Action, &str, &str, &PreUpdateCase), + { + let action = Action::from(action_code); + + let preupdate_case = match action { + Action::SQLITE_INSERT => PreUpdateCase::Insert(PreUpdateNewValueAccessor { + db: sqlite, + new_row_id, + }), + Action::SQLITE_DELETE => PreUpdateCase::Delete(PreUpdateOldValueAccessor { + db: sqlite, + old_row_id, + }), + Action::SQLITE_UPDATE => PreUpdateCase::Update { + old_value_accessor: PreUpdateOldValueAccessor { + db: sqlite, + old_row_id, + }, + new_value_accessor: PreUpdateNewValueAccessor { + db: sqlite, + new_row_id, + }, + }, + Action::UNKNOWN => PreUpdateCase::Unknown, + }; + + let _ = catch_unwind(|| { + let boxed_hook: *mut F = p_arg as *mut F; + (*boxed_hook)( + action, + expect_utf8(db_name, "database name"), + expect_utf8(tbl_name, "table name"), + &preupdate_case, + ); + }); + } + + let free_preupdate_hook = if hook.is_some() { + Some(free_boxed_hook:: as unsafe fn(*mut c_void)) + } else { + None + }; + + let previous_hook = match hook { + Some(hook) => { + let boxed_hook: *mut F = Box::into_raw(Box::new(hook)); + unsafe { + ffi::sqlite3_preupdate_hook( + self.db(), + Some(call_boxed_closure::), + boxed_hook as *mut _, + ) + } + } + _ => unsafe { ffi::sqlite3_preupdate_hook(self.db(), None, ptr::null_mut()) }, + }; + if !previous_hook.is_null() { + if let Some(free_boxed_hook) = self.free_preupdate_hook { + unsafe { free_boxed_hook(previous_hook) }; + } + } + self.free_preupdate_hook = free_preupdate_hook; + } +} + +#[cfg(test)] +mod test { + use super::super::Action; + use super::PreUpdateCase; + use crate::{Connection, Result}; + + #[test] + fn test_preupdate_hook_insert() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { + assert_eq!(Action::SQLITE_INSERT, action); + assert_eq!("main", db); + assert_eq!("foo", tbl); + match case { + PreUpdateCase::Insert(accessor) => { + assert_eq!(1, accessor.get_column_count()); + assert_eq!(1, accessor.get_new_row_id()); + assert_eq!(0, accessor.get_query_depth()); + assert_eq!("lisa", accessor.get_new_column_value(0).as_str().unwrap()); + assert_eq!(0, accessor.get_query_depth()); + } + _ => panic!("wrong preupdate case"), + } + called = true; + })); + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + assert!(called); + Ok(()) + } + + #[test] + fn test_preupdate_hook_delete() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + + db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { + assert_eq!(Action::SQLITE_DELETE, action); + assert_eq!("main", db); + assert_eq!("foo", tbl); + match case { + PreUpdateCase::Delete(accessor) => { + assert_eq!(1, accessor.get_column_count()); + assert_eq!(1, accessor.get_old_row_id()); + assert_eq!(0, accessor.get_query_depth()); + assert_eq!("lisa", accessor.get_old_column_value(0).as_str().unwrap()); + assert_eq!(0, accessor.get_query_depth()); + } + _ => panic!("wrong preupdate case"), + } + called = true; + })); + + db.execute_batch("DELETE from foo")?; + assert!(called); + Ok(()) + } + + #[test] + fn test_preupdate_hook_update() -> Result<()> { + let db = Connection::open_in_memory()?; + + let mut called = false; + + db.execute_batch("CREATE TABLE foo (t TEXT)")?; + db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; + + db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { + assert_eq!(Action::SQLITE_UPDATE, action); + assert_eq!("main", db); + assert_eq!("foo", tbl); + match case { + PreUpdateCase::Update { + old_value_accessor, + new_value_accessor, + } => { + assert_eq!(1, old_value_accessor.get_column_count()); + assert_eq!(1, old_value_accessor.get_old_row_id()); + assert_eq!(0, old_value_accessor.get_query_depth()); + assert_eq!( + "lisa", + old_value_accessor.get_old_column_value(0).as_str().unwrap() + ); + assert_eq!(0, old_value_accessor.get_query_depth()); + + assert_eq!(1, new_value_accessor.get_column_count()); + assert_eq!(1, new_value_accessor.get_new_row_id()); + assert_eq!(0, new_value_accessor.get_query_depth()); + assert_eq!( + "janice", + new_value_accessor.get_new_column_value(0).as_str().unwrap() + ); + assert_eq!(0, new_value_accessor.get_query_depth()); + } + _ => panic!("wrong preupdate case"), + } + called = true; + })); + + db.execute_batch("UPDATE foo SET t = 'janice'")?; + assert!(called); + Ok(()) + } +} diff --git a/src/inner_connection.rs b/src/inner_connection.rs index edd4682..282eb5e 100644 --- a/src/inner_connection.rs +++ b/src/inner_connection.rs @@ -31,6 +31,10 @@ pub struct InnerConnection { pub free_update_hook: Option, #[cfg(feature = "hooks")] pub progress_handler: Option bool + Send>>, + #[cfg(feature = "hooks")] + pub authorizer: Option, + #[cfg(feature = "preupdate_hook")] + pub free_preupdate_hook: Option, owned: bool, } @@ -51,6 +55,10 @@ impl InnerConnection { free_update_hook: None, #[cfg(feature = "hooks")] progress_handler: None, + #[cfg(feature = "hooks")] + authorizer: None, + #[cfg(feature = "preupdate_hook")] + free_preupdate_hook: None, owned, } } @@ -333,6 +341,64 @@ impl InnerConnection { #[cfg(not(feature = "hooks"))] #[inline] fn remove_hooks(&mut self) {} + + #[cfg(not(feature = "preupdate_hook"))] + #[inline] + fn remove_preupdate_hook(&mut self) {} + + pub fn db_readonly(&self, db_name: super::DatabaseName<'_>) -> Result { + let name = db_name.as_cstring()?; + let r = unsafe { ffi::sqlite3_db_readonly(self.db, name.as_ptr()) }; + match r { + 0 => Ok(false), + 1 => Ok(true), + -1 => Err(Error::SqliteFailure( + ffi::Error::new(ffi::SQLITE_MISUSE), + Some(format!("{db_name:?} is not the name of a database")), + )), + _ => Err(error_from_sqlite_code( + r, + Some("Unexpected result".to_owned()), + )), + } + } + + #[cfg(feature = "modern_sqlite")] // 3.37.0 + pub fn txn_state( + &self, + db_name: Option>, + ) -> Result { + let r = if let Some(ref name) = db_name { + let name = name.as_cstring()?; + unsafe { ffi::sqlite3_txn_state(self.db, name.as_ptr()) } + } else { + unsafe { ffi::sqlite3_txn_state(self.db, ptr::null()) } + }; + match r { + 0 => Ok(super::transaction::TransactionState::None), + 1 => Ok(super::transaction::TransactionState::Read), + 2 => Ok(super::transaction::TransactionState::Write), + -1 => Err(Error::SqliteFailure( + ffi::Error::new(ffi::SQLITE_MISUSE), + Some(format!("{db_name:?} is not the name of a valid schema")), + )), + _ => Err(error_from_sqlite_code( + r, + Some("Unexpected result".to_owned()), + )), + } + } + + #[inline] + #[cfg(feature = "release_memory")] + pub fn release_memory(&self) -> Result<()> { + self.decode_result(unsafe { ffi::sqlite3_db_release_memory(self.db) }) + } + + #[cfg(feature = "modern_sqlite")] // 3.41.0 + pub fn is_interrupted(&self) -> bool { + unsafe { ffi::sqlite3_is_interrupted(self.db) == 1 } + } } impl Drop for InnerConnection { diff --git a/src/lib.rs b/src/lib.rs index a35eaab..7572908 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -111,7 +111,7 @@ mod context; #[cfg(feature = "functions")] #[cfg_attr(docsrs, doc(cfg(feature = "functions")))] pub mod functions; -#[cfg(any(feature = "hooks", feature = "preupdate_hook"))] +#[cfg(feature = "hooks")] #[cfg_attr(docsrs, doc(cfg(feature = "hooks")))] pub mod hooks; mod inner_connection; From fb50d45bdfb44ac48728b3b5017d60a1c63f2275 Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sat, 30 Mar 2024 10:49:12 -0500 Subject: [PATCH 09/17] remove extra lifetime --- src/hooks/preupdate_hook.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index 4f30416..2b7debf 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -143,9 +143,9 @@ impl InnerConnection { self.preupdate_hook(None::); } - fn preupdate_hook<'c, F>(&'c mut self, hook: Option) + fn preupdate_hook(&mut self, hook: Option) where - F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'c, + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send, { unsafe extern "C" fn call_boxed_closure( p_arg: *mut c_void, From 64bb1e861f95e75ab8d65f97e020190a50d17b28 Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sat, 30 Mar 2024 11:03:09 -0500 Subject: [PATCH 10/17] add preupdate_hook feature to README --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index be71d28..cb2cd99 100644 --- a/README.md +++ b/README.md @@ -123,6 +123,7 @@ features](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-s - As the name implies this depends on the `bundled-sqlcipher` feature, and automatically turns it on. - If turned on, this uses the [`openssl-sys`](https://crates.io/crates/openssl-sys) crate, with the `vendored` feature enabled in order to build and bundle the OpenSSL crypto library. * `hooks` for [Commit, Rollback](http://sqlite.org/c3ref/commit_hook.html) and [Data Change](http://sqlite.org/c3ref/update_hook.html) notification callbacks. +* `preupdate_hook` for [preupdate](https://sqlite.org/c3ref/preupdate_count.html) notification callbacks. (Implies `hooks`.) * `unlock_notify` for [Unlock](https://sqlite.org/unlock_notify.html) notification. * `vtab` for [virtual table](https://sqlite.org/vtab.html) support (allows you to write virtual table implementations in Rust). Currently, only read-only virtual tables are supported. * `series` exposes [`generate_series(...)`](https://www.sqlite.org/series.html) Table-Valued Function. (Implies `vtab`.) From dd92f1d6dfb6ef499603b4c695eeb01756a23031 Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sat, 30 Mar 2024 12:45:52 -0500 Subject: [PATCH 11/17] add static lifetime bound and compile test --- src/hooks/preupdate_hook.rs | 38 ++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index 2b7debf..a272d54 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -131,7 +131,7 @@ impl Connection { #[inline] pub fn preupdate_hook(&self, hook: Option) where - F: FnMut(Action, &str, &str, &PreUpdateCase) + Send, + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'static, { self.db.borrow_mut().preupdate_hook(hook); } @@ -143,9 +143,22 @@ impl InnerConnection { self.preupdate_hook(None::); } + /// ```compile_fail + /// use rusqlite::{Connection, Result, hooks::PreUpdateCase}; + /// fn main() -> Result<()> { + /// let db = Connection::open_in_memory()?; + /// { + /// let mut called = std::sync::atomic::AtomicBool::new(false); + /// db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { + /// called.store(true, std::sync::atomic::Ordering::Relaxed); + /// })); + /// } + /// db.execute_batch("CREATE TABLE foo AS SELECT 1 AS bar;") + /// } + /// ``` fn preupdate_hook(&mut self, hook: Option) where - F: FnMut(Action, &str, &str, &PreUpdateCase) + Send, + F: FnMut(Action, &str, &str, &PreUpdateCase) + Send + 'static, { unsafe extern "C" fn call_boxed_closure( p_arg: *mut c_void, @@ -223,6 +236,8 @@ impl InnerConnection { #[cfg(test)] mod test { + use std::sync::atomic::{AtomicBool, Ordering}; + use super::super::Action; use super::PreUpdateCase; use crate::{Connection, Result}; @@ -231,7 +246,8 @@ mod test { fn test_preupdate_hook_insert() -> Result<()> { let db = Connection::open_in_memory()?; - let mut called = false; + static CALLED: AtomicBool = AtomicBool::new(false); + db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { assert_eq!(Action::SQLITE_INSERT, action); assert_eq!("main", db); @@ -246,11 +262,11 @@ mod test { } _ => panic!("wrong preupdate case"), } - called = true; + CALLED.store(true, Ordering::Relaxed); })); db.execute_batch("CREATE TABLE foo (t TEXT)")?; db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; - assert!(called); + assert!(CALLED.load(Ordering::Relaxed)); Ok(()) } @@ -258,7 +274,7 @@ mod test { fn test_preupdate_hook_delete() -> Result<()> { let db = Connection::open_in_memory()?; - let mut called = false; + static CALLED: AtomicBool = AtomicBool::new(false); db.execute_batch("CREATE TABLE foo (t TEXT)")?; db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; @@ -277,11 +293,11 @@ mod test { } _ => panic!("wrong preupdate case"), } - called = true; + CALLED.store(true, Ordering::Relaxed); })); db.execute_batch("DELETE from foo")?; - assert!(called); + assert!(CALLED.load(Ordering::Relaxed)); Ok(()) } @@ -289,7 +305,7 @@ mod test { fn test_preupdate_hook_update() -> Result<()> { let db = Connection::open_in_memory()?; - let mut called = false; + static CALLED: AtomicBool = AtomicBool::new(false); db.execute_batch("CREATE TABLE foo (t TEXT)")?; db.execute_batch("INSERT INTO foo VALUES ('lisa')")?; @@ -323,11 +339,11 @@ mod test { } _ => panic!("wrong preupdate case"), } - called = true; + CALLED.store(true, Ordering::Relaxed); })); db.execute_batch("UPDATE foo SET t = 'janice'")?; - assert!(called); + assert!(CALLED.load(Ordering::Relaxed)); Ok(()) } } From 475c2fc6917cba436f26ef5d1479bd5a0f06151d Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sat, 30 Mar 2024 12:53:52 -0500 Subject: [PATCH 12/17] fix indentation --- src/hooks/preupdate_hook.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index a272d54..f4d3845 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -150,7 +150,7 @@ impl InnerConnection { /// { /// let mut called = std::sync::atomic::AtomicBool::new(false); /// db.preupdate_hook(Some(|action, db: &str, tbl: &str, case: &PreUpdateCase| { - /// called.store(true, std::sync::atomic::Ordering::Relaxed); + /// called.store(true, std::sync::atomic::Ordering::Relaxed); /// })); /// } /// db.execute_batch("CREATE TABLE foo AS SELECT 1 AS bar;") From 41cf19030aadb8c9364dc01bb55e9a8e2e4e59de Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sun, 31 Mar 2024 08:04:09 -0500 Subject: [PATCH 13/17] minor changes to match other hooks --- src/hooks/preupdate_hook.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index f4d3845..e8301c0 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -195,15 +195,15 @@ impl InnerConnection { Action::UNKNOWN => PreUpdateCase::Unknown, }; - let _ = catch_unwind(|| { - let boxed_hook: *mut F = p_arg as *mut F; + drop(catch_unwind(|| { + let boxed_hook: *mut F = p_arg.cast(); (*boxed_hook)( action, expect_utf8(db_name, "database name"), expect_utf8(tbl_name, "table name"), &preupdate_case, ); - }); + })); } let free_preupdate_hook = if hook.is_some() { @@ -219,7 +219,7 @@ impl InnerConnection { ffi::sqlite3_preupdate_hook( self.db(), Some(call_boxed_closure::), - boxed_hook as *mut _, + boxed_hook.cast(), ) } } From ba392cf1044f646bb872006113c8a75be79a3d47 Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sun, 31 Mar 2024 08:06:33 -0500 Subject: [PATCH 14/17] fix syntax --- src/hooks/preupdate_hook.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index e8301c0..7e1033d 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -196,7 +196,7 @@ impl InnerConnection { }; drop(catch_unwind(|| { - let boxed_hook: *mut F = p_arg.cast(); + let boxed_hook: *mut F = p_arg.cast::(); (*boxed_hook)( action, expect_utf8(db_name, "database name"), From 63a1f1d3b02f5581b0ebe28fb4f50e7cc08d09aa Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sun, 31 Mar 2024 08:17:52 -0500 Subject: [PATCH 15/17] add preupdate_hook to ci tests --- .github/workflows/main.yml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b251ebf..07d93f2 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -62,8 +62,8 @@ jobs: if: matrix.os == 'windows-latest' run: echo "C:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append - - run: cargo test --features 'bundled-full session buildtime_bindgen' --all-targets --workspace --verbose - - run: cargo test --features 'bundled-full session buildtime_bindgen' --doc --workspace --verbose + - run: cargo test --features 'bundled-full session buildtime_bindgen preupdate_hook' --all-targets --workspace --verbose + - run: cargo test --features 'bundled-full session buildtime_bindgen preupdate_hook' --doc --workspace --verbose - name: loadable extension run: | @@ -119,8 +119,8 @@ jobs: if: matrix.os == 'windows-latest' run: echo "C:\msys64\mingw64\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append - - run: cargo test --features 'bundled-full session buildtime_bindgen' --all-targets --workspace --verbose - - run: cargo test --features 'bundled-full session buildtime_bindgen' --doc --workspace --verbose + - run: cargo test --features 'bundled-full session buildtime_bindgen preupdate_hook' --all-targets --workspace --verbose + - run: cargo test --features 'bundled-full session buildtime_bindgen preupdate_hook' --doc --workspace --verbose sqlcipher: name: Test with sqlcipher @@ -156,7 +156,7 @@ jobs: # leak sanitization, but we don't care about backtraces here, so long # as the other tests have them. RUST_BACKTRACE: "0" - run: cargo -Z build-std test --features 'bundled-full session buildtime_bindgen with-asan' --target x86_64-unknown-linux-gnu + run: cargo -Z build-std test --features 'bundled-full session buildtime_bindgen preupdate_hook with-asan' --target x86_64-unknown-linux-gnu # Ensure clippy doesn't complain. clippy: @@ -170,7 +170,7 @@ jobs: - uses: Swatinem/rust-cache@v2 - run: cargo clippy --all-targets --workspace --features bundled -- -D warnings # Clippy with all non-conflicting features - - run: cargo clippy --all-targets --workspace --features 'bundled-full session buildtime_bindgen' -- -D warnings + - run: cargo clippy --all-targets --workspace --features 'bundled-full session buildtime_bindgen preupdate_hook' -- -D warnings # Ensure patch is formatted. fmt: @@ -192,7 +192,7 @@ jobs: - uses: hecrj/setup-rust-action@v1 - uses: Swatinem/rust-cache@v2 with: { sharedKey: fullBuild } - - run: cargo doc --features 'bundled-full session buildtime_bindgen' --no-deps + - run: cargo doc --features 'bundled-full session buildtime_bindgen preupdate_hook' --no-deps env: { RUSTDOCFLAGS: -Dwarnings } codecov: @@ -210,7 +210,7 @@ jobs: run: | cargo test --verbose cargo test --features="bundled-full" --verbose - cargo test --features="bundled-full session buildtime_bindgen" --verbose + cargo test --features="bundled-full session buildtime_bindgen preupdate_hook" --verbose cargo test --features="bundled-sqlcipher-vendored-openssl" --verbose env: RUSTFLAGS: -Cinstrument-coverage From 6cd70cc6bfa816b41f3fea8aeac4d5a4162dcc8e Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sun, 31 Mar 2024 08:28:16 -0500 Subject: [PATCH 16/17] update comment --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 07d93f2..7041575 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -49,7 +49,7 @@ jobs: # The `{ sharedKey: ... }` allows different actions to share the cache. # We're using a `fullBuild` key mostly as a "this needs to do the # complete" that needs to do the complete build (that is, including - # `--features 'bundled-full session buildtime_bindgen'`), which is very + # `--features 'bundled-full session buildtime_bindgen preupdate_hook'`), which is very # slow, and has several deps. - uses: Swatinem/rust-cache@v2 with: { sharedKey: fullBuild } From 269dd72a76b43c0f71424c259752e11f53ca50b6 Mon Sep 17 00:00:00 2001 From: Austin Schey Date: Sun, 31 Mar 2024 08:47:03 -0500 Subject: [PATCH 17/17] check errors from sqlite3_preupdate_old and sqlite3_preupdate_new --- src/hooks/preupdate_hook.rs | 45 ++++++++++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 11 deletions(-) diff --git a/src/hooks/preupdate_hook.rs b/src/hooks/preupdate_hook.rs index 7e1033d..57ea174 100644 --- a/src/hooks/preupdate_hook.rs +++ b/src/hooks/preupdate_hook.rs @@ -6,11 +6,12 @@ use std::ptr; use super::expect_utf8; use super::free_boxed_hook; use super::Action; - +use crate::error::check; use crate::ffi; use crate::inner_connection::InnerConnection; use crate::types::ValueRef; use crate::Connection; +use crate::Result; /// The possible cases for when a PreUpdateHook gets triggered. Allows access to the relevant /// functions for each case through the contained values. @@ -71,11 +72,11 @@ impl PreUpdateOldValueAccessor { } /// Get the value of the row being updated/deleted at the specified index. - pub fn get_old_column_value(&self, i: i32) -> ValueRef { + pub fn get_old_column_value(&self, i: i32) -> Result { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { - ffi::sqlite3_preupdate_old(self.db, i, &mut p_value); - ValueRef::from_value(p_value) + check(ffi::sqlite3_preupdate_old(self.db, i, &mut p_value))?; + Ok(ValueRef::from_value(p_value)) } } } @@ -109,11 +110,11 @@ impl PreUpdateNewValueAccessor { } /// Get the value of the row being updated/deleted at the specified index. - pub fn get_new_column_value(&self, i: i32) -> ValueRef { + pub fn get_new_column_value(&self, i: i32) -> Result { let mut p_value: *mut ffi::sqlite3_value = ptr::null_mut(); unsafe { - ffi::sqlite3_preupdate_new(self.db, i, &mut p_value); - ValueRef::from_value(p_value) + check(ffi::sqlite3_preupdate_new(self.db, i, &mut p_value))?; + Ok(ValueRef::from_value(p_value)) } } } @@ -257,7 +258,12 @@ mod test { assert_eq!(1, accessor.get_column_count()); assert_eq!(1, accessor.get_new_row_id()); assert_eq!(0, accessor.get_query_depth()); - assert_eq!("lisa", accessor.get_new_column_value(0).as_str().unwrap()); + // out of bounds access should return an error + assert!(accessor.get_new_column_value(1).is_err()); + assert_eq!( + "lisa", + accessor.get_new_column_value(0).unwrap().as_str().unwrap() + ); assert_eq!(0, accessor.get_query_depth()); } _ => panic!("wrong preupdate case"), @@ -288,7 +294,12 @@ mod test { assert_eq!(1, accessor.get_column_count()); assert_eq!(1, accessor.get_old_row_id()); assert_eq!(0, accessor.get_query_depth()); - assert_eq!("lisa", accessor.get_old_column_value(0).as_str().unwrap()); + // out of bounds access should return an error + assert!(accessor.get_old_column_value(1).is_err()); + assert_eq!( + "lisa", + accessor.get_old_column_value(0).unwrap().as_str().unwrap() + ); assert_eq!(0, accessor.get_query_depth()); } _ => panic!("wrong preupdate case"), @@ -322,18 +333,30 @@ mod test { assert_eq!(1, old_value_accessor.get_column_count()); assert_eq!(1, old_value_accessor.get_old_row_id()); assert_eq!(0, old_value_accessor.get_query_depth()); + // out of bounds access should return an error + assert!(old_value_accessor.get_old_column_value(1).is_err()); assert_eq!( "lisa", - old_value_accessor.get_old_column_value(0).as_str().unwrap() + old_value_accessor + .get_old_column_value(0) + .unwrap() + .as_str() + .unwrap() ); assert_eq!(0, old_value_accessor.get_query_depth()); assert_eq!(1, new_value_accessor.get_column_count()); assert_eq!(1, new_value_accessor.get_new_row_id()); assert_eq!(0, new_value_accessor.get_query_depth()); + // out of bounds access should return an error + assert!(new_value_accessor.get_new_column_value(1).is_err()); assert_eq!( "janice", - new_value_accessor.get_new_column_value(0).as_str().unwrap() + new_value_accessor + .get_new_column_value(0) + .unwrap() + .as_str() + .unwrap() ); assert_eq!(0, new_value_accessor.get_query_depth()); }