feat(sqlite): add preupdate hook

.github/workflows/sqlx.yml

@@ -39,15 +39,15 @@ jobs:
       - run: >
           cargo clippy
           --no-default-features
-          --features all-databases,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }},macros
+          --features all-databases,_unstable-all-types,sqlite-preupdate-hook,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }},macros
           -- -D warnings
 
       # Run beta for new warnings but don't break the build.
       # Use a subdirectory of `target` to avoid clobbering the cache.
       - run: >
           cargo +beta clippy
           --no-default-features
-          --features all-databases,_unstable-all-types,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }},macros
+          --features all-databases,_unstable-all-types,sqlite-preupdate-hook,runtime-${{ matrix.runtime }},tls-${{ matrix.tls }},macros
           --target-dir target/beta/
 
   check-minimal-versions:
@@ -140,7 +140,7 @@ jobs:
       - run: >
           cargo test
           --no-default-features
-          --features any,macros,${{ matrix.linking }},_unstable-all-types,runtime-${{ matrix.runtime }}
+          --features any,macros,${{ matrix.linking }},${{ matrix.linking == 'sqlite' && 'sqlite-preupdate-hook,' || ''}}_unstable-all-types,runtime-${{ matrix.runtime }}
           --
           --test-threads=1
         env:

Cargo.toml

@@ -50,7 +50,7 @@ authors.workspace = true
 repository.workspace = true
 
 [package.metadata.docs.rs]
-features = ["all-databases", "_unstable-all-types"]
+features = ["all-databases", "_unstable-all-types", "sqlite-preupdate-hook"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
@@ -108,6 +108,7 @@ postgres = ["sqlx-postgres", "sqlx-macros?/postgres"]
 mysql = ["sqlx-mysql", "sqlx-macros?/mysql"]
 sqlite = ["_sqlite", "sqlx-sqlite/bundled", "sqlx-macros?/sqlite"]
 sqlite-unbundled = ["_sqlite", "sqlx-sqlite/unbundled", "sqlx-macros?/sqlite-unbundled"]
+sqlite-preupdate-hook = ["sqlx-sqlite/preupdate-hook"]
 
 # types
 json = ["sqlx-macros?/json", "sqlx-mysql?/json", "sqlx-postgres?/json", "sqlx-sqlite?/json"]

README.md

@@ -196,6 +196,10 @@ be removed in the future.
     * May result in link errors if the SQLite version is too old. Version `3.20.0` or newer is recommended.
     * Can increase build time due to the use of bindgen.
 
+-   `sqlite-preupdate-hook`: enables SQLite's [preupdate hook](https://sqlite.org/c3ref/preupdate_count.html) API.
+    * Exposed as a separate feature because it's generally not enabled by default.
+    * Using this feature with `sqlite-unbundled` may cause linker failures if the system SQLite version does not support it.
+
 -   `any`: Add support for the `Any` database driver, which can proxy to a database driver at runtime.
 
 -   `derive`: Add support for the derive family macros, those are `FromRow`, `Type`, `Encode`, `Decode`.

sqlx-sqlite/Cargo.toml

@@ -23,6 +23,8 @@ uuid = ["dep:uuid", "sqlx-core/uuid"]
 
 regexp = ["dep:regex"]
 
+preupdate-hook = ["libsqlite3-sys/preupdate_hook"]
+
 bundled = ["libsqlite3-sys/bundled"]
 unbundled = ["libsqlite3-sys/buildtime_bindgen"]
 
@@ -48,6 +50,7 @@ atoi = "2.0"
 
 log = "0.4.18"
 tracing = { version = "0.1.37", features = ["log"] }
+thiserror = "2.0.0"
 
 serde = { version = "1.0.145", features = ["derive"], optional = true }
 regex = { version = "1.5.5", optional = true }

sqlx-sqlite/src/connection/establish.rs

@@ -296,6 +296,8 @@ impl EstablishParams {
             log_settings: self.log_settings.clone(),
             progress_handler_callback: None,
             update_hook_callback: None,
+            #[cfg(feature = "preupdate-hook")]
+            preupdate_hook_callback: None,
             commit_hook_callback: None,
             rollback_hook_callback: None,
         })

sqlx-sqlite/src/connection/mod.rs

@@ -14,6 +14,8 @@ use libsqlite3_sys::{
     sqlite3, sqlite3_commit_hook, sqlite3_progress_handler, sqlite3_rollback_hook,
     sqlite3_update_hook, SQLITE_DELETE, SQLITE_INSERT, SQLITE_UPDATE,
 };
+#[cfg(feature = "preupdate-hook")]
+pub use preupdate_hook::*;
 
 pub(crate) use handle::ConnectionHandle;
 use sqlx_core::common::StatementCache;
@@ -36,6 +38,8 @@ mod executor;
 mod explain;
 mod handle;
 pub(crate) mod intmap;
+#[cfg(feature = "preupdate-hook")]
+mod preupdate_hook;
 
 mod worker;
 
@@ -88,6 +92,7 @@ pub struct UpdateHookResult<'a> {
     pub table: &'a str,
     pub rowid: i64,
 }
+
 pub(crate) struct UpdateHookHandler(NonNull<dyn FnMut(UpdateHookResult) + Send + 'static>);
 unsafe impl Send for UpdateHookHandler {}
 
@@ -112,6 +117,8 @@ pub(crate) struct ConnectionState {
     progress_handler_callback: Option<Handler>,
 
     update_hook_callback: Option<UpdateHookHandler>,
+    #[cfg(feature = "preupdate-hook")]
+    preupdate_hook_callback: Option<preupdate_hook::PreupdateHookHandler>,
 
     commit_hook_callback: Option<CommitHookHandler>,
 
@@ -138,6 +145,16 @@ impl ConnectionState {
         }
     }
 
+    #[cfg(feature = "preupdate-hook")]
+    pub(crate) fn remove_preupdate_hook(&mut self) {
+        if let Some(mut handler) = self.preupdate_hook_callback.take() {
+            unsafe {
+                libsqlite3_sys::sqlite3_preupdate_hook(self.handle.as_ptr(), None, ptr::null_mut());
+                let _ = { Box::from_raw(handler.0.as_mut()) };
+            }
+        }
+    }
+
     pub(crate) fn remove_commit_hook(&mut self) {
         if let Some(mut handler) = self.commit_hook_callback.take() {
             unsafe {
@@ -421,6 +438,34 @@ impl LockedSqliteHandle<'_> {
         }
     }
 
+    /// Registers a hook that is invoked prior to each `INSERT`, `UPDATE`, and `DELETE` operation on a database table.
+    /// At most one preupdate hook may be registered at a time on a single database connection.
+    ///
+    /// The preupdate hook only fires for changes to real database tables;
+    /// it is not invoked for changes to virtual tables or to system tables like sqlite_sequence or sqlite_stat1.
+    ///
+    /// See https://sqlite.org/c3ref/preupdate_count.html
+    #[cfg(feature = "preupdate-hook")]
+    pub fn set_preupdate_hook<F>(&mut self, callback: F)
+    where
+        F: FnMut(PreupdateHookResult) + Send + 'static,
+    {
+        unsafe {
+            let callback_boxed = Box::new(callback);
+            // SAFETY: `Box::into_raw()` always returns a non-null pointer.
+            let callback = NonNull::new_unchecked(Box::into_raw(callback_boxed));
+            let handler = callback.as_ptr() as *mut _;
+            self.guard.remove_preupdate_hook();
+            self.guard.preupdate_hook_callback = Some(PreupdateHookHandler(callback));
+
+            libsqlite3_sys::sqlite3_preupdate_hook(
+                self.as_raw_handle().as_mut(),
+                Some(preupdate_hook::<F>),
+                handler,
+            );
+        }
+    }
+
     /// Sets a commit hook that is invoked whenever a transaction is committed. If the commit hook callback
     /// returns `false`, then the operation is turned into a ROLLBACK.
     ///
@@ -485,6 +530,11 @@ impl LockedSqliteHandle<'_> {
         self.guard.remove_update_hook();
     }
 
+    #[cfg(feature = "preupdate-hook")]
+    pub fn remove_preupdate_hook(&mut self) {
+        self.guard.remove_preupdate_hook();
+    }
+
     pub fn remove_commit_hook(&mut self) {
         self.guard.remove_commit_hook();
     }

sqlx-sqlite/src/connection/preupdate_hook.rs

@@ -0,0 +1,160 @@
+use super::SqliteOperation;
+use crate::type_info::DataType;
+use crate::{SqliteError, SqliteTypeInfo, SqliteValueRef};
+
+use libsqlite3_sys::{
+    sqlite3, sqlite3_preupdate_count, sqlite3_preupdate_depth, sqlite3_preupdate_new,
+    sqlite3_preupdate_old, sqlite3_value, sqlite3_value_type, SQLITE_OK,
+};
+use std::ffi::CStr;
+use std::marker::PhantomData;
+use std::os::raw::{c_char, c_int, c_void};
+use std::panic::catch_unwind;
+use std::ptr;
+use std::ptr::NonNull;
+
+#[derive(Debug, thiserror::Error)]
+pub enum PreupdateError {
+    /// Error returned from the database.
+    #[error("error returned from database: {0}")]
+    Database(#[source] SqliteError),
+    /// Index is not within the valid column range
+    #[error("{0} is not within the valid column range")]
+    ColumnIndexOutOfBounds(i32),
+    /// Column value accessor was invoked from an invalid operation
+    #[error("column value accessor was invoked from an invalid operation")]
+    InvalidOperation,
+}
+
+pub(crate) struct PreupdateHookHandler(
+    pub(super) NonNull<dyn FnMut(PreupdateHookResult) + Send + 'static>,
+);
+unsafe impl Send for PreupdateHookHandler {}
+
+#[derive(Debug)]
+pub struct PreupdateHookResult<'a> {
+    pub operation: SqliteOperation,
+    pub database: &'a str,
+    pub table: &'a str,
+    db: *mut sqlite3,
+    // The database pointer should not be usable after the preupdate hook.
+    // The lifetime on this struct needs to ensure it cannot outlive the callback.
+    _db_lifetime: PhantomData<&'a ()>,
+    old_row_id: i64,
+    new_row_id: i64,
+}
+
+impl<'a> PreupdateHookResult<'a> {
+    /// Gets the amount of columns in the row being inserted, deleted, or updated.
+    pub fn get_column_count(&self) -> i32 {
+        unsafe { sqlite3_preupdate_count(self.db) }
+    }
+
+    /// Gets 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 { sqlite3_preupdate_depth(self.db) }
+    }
+
+    /// Gets the row id of the row being updated/deleted.
+    /// Returns an error if called from an insert operation.
+    pub fn get_old_row_id(&self) -> Result<i64, PreupdateError> {
+        if self.operation == SqliteOperation::Insert {
+            return Err(PreupdateError::InvalidOperation);
+        }
+        Ok(self.old_row_id)
+    }
+
+    /// Gets the row id of the row being inserted/updated.
+    /// Returns an error if called from a delete operation.
+    pub fn get_new_row_id(&self) -> Result<i64, PreupdateError> {
+        if self.operation == SqliteOperation::Delete {
+            return Err(PreupdateError::InvalidOperation);
+        }
+        Ok(self.new_row_id)
+    }
+
+    /// Gets the value of the row being updated/deleted at the specified index.
+    /// Returns an error if called from an insert operation or the index is out of bounds.
+    pub fn get_old_column_value(&self, i: i32) -> Result<SqliteValueRef<'a>, PreupdateError> {
+        if self.operation == SqliteOperation::Insert {
+            return Err(PreupdateError::InvalidOperation);
+        }
+        self.validate_column_index(i)?;
+
+        let mut p_value: *mut sqlite3_value = ptr::null_mut();
+        unsafe {
+            let ret = sqlite3_preupdate_old(self.db, i, &mut p_value);
+            self.get_value(ret, p_value)
+        }
+    }
+
+    /// Gets the value of the row being inserted/updated at the specified index.
+    /// Returns an error if called from a delete operation or the index is out of bounds.
+    pub fn get_new_column_value(&self, i: i32) -> Result<SqliteValueRef<'a>, PreupdateError> {
+        if self.operation == SqliteOperation::Delete {
+            return Err(PreupdateError::InvalidOperation);
+        }
+        self.validate_column_index(i)?;
+
+        let mut p_value: *mut sqlite3_value = ptr::null_mut();
+        unsafe {
+            let ret = sqlite3_preupdate_new(self.db, i, &mut p_value);
+            self.get_value(ret, p_value)
+        }
+    }
+
+    fn validate_column_index(&self, i: i32) -> Result<(), PreupdateError> {
+        if i < 0 || i >= self.get_column_count() {
+            return Err(PreupdateError::ColumnIndexOutOfBounds(i));
+        }
+        Ok(())
+    }
+
+    unsafe fn get_value(
+        &self,
+        ret: i32,
+        p_value: *mut sqlite3_value,
+    ) -> Result<SqliteValueRef<'a>, PreupdateError> {
+        if ret != SQLITE_OK {
+            return Err(PreupdateError::Database(SqliteError::new(self.db)));
+        }
+        let data_type = DataType::from_code(sqlite3_value_type(p_value));
+        // SAFETY: SQLite will free the sqlite3_value when the callback returns
+        Ok(SqliteValueRef::borrowed(p_value, SqliteTypeInfo(data_type)))
+    }
+}
+
+pub(super) extern "C" fn preupdate_hook<F>(
+    callback: *mut c_void,
+    db: *mut sqlite3,
+    op_code: c_int,
+    database: *const c_char,
+    table: *const c_char,
+    old_row_id: i64,
+    new_row_id: i64,
+) where
+    F: FnMut(PreupdateHookResult) + Send + 'static,
+{
+    unsafe {
+        let _ = catch_unwind(|| {
+            let callback: *mut F = callback.cast::<F>();
+            let operation: SqliteOperation = op_code.into();
+            let database = CStr::from_ptr(database).to_str().unwrap_or_default();
+            let table = CStr::from_ptr(table).to_str().unwrap_or_default();
+
+            (*callback)(PreupdateHookResult {
+                operation,
+                database,
+                table,
+                old_row_id,
+                new_row_id,
+                db,
+                _db_lifetime: PhantomData,
+            })
+        });
+    }
+}

sqlx-sqlite/src/lib.rs

@@ -46,6 +46,8 @@ use std::sync::atomic::AtomicBool;
 
 pub use arguments::{SqliteArgumentValue, SqliteArguments};
 pub use column::SqliteColumn;
+#[cfg(feature = "preupdate-hook")]
+pub use connection::PreupdateHookResult;
 pub use connection::{LockedSqliteHandle, SqliteConnection, SqliteOperation, UpdateHookResult};
 pub use database::Sqlite;
 pub use error::SqliteError;