Update, commit, and rollback hook support

Should make it easy, e.g., to create an interface for a table view to
register for updates.

Signed-off-by: Stephen Celis <stephen@stephencelis.com>

Author: stephencelis

SQLite Tests/DatabaseTests.swift

@@ -292,6 +292,64 @@ class DatabaseTests: SQLiteTestCase {
         XCTAssertEqual(true, db.foreignKeys)
     }
 
+    func test_updateHook_setsUpdateHook() {
+        let updateHook = expectationWithDescription("updateHook")
+        db.updateHook { operation, db, table, rowid in
+            XCTAssertEqual(.Insert, operation)
+            XCTAssertEqual("main", db)
+            XCTAssertEqual("users", table)
+            XCTAssertEqual(1, rowid)
+            updateHook.fulfill()
+        }
+        executeAndWait {
+            insertUser("alice")
+        }
+    }
+
+    func test_commitHook_setsCommitHook() {
+        let commitHook = expectationWithDescription("commitHook")
+        db.commitHook {
+            commitHook.fulfill()
+            return .Commit
+        }
+        executeAndWait {
+            self.db.transaction { _ in
+                self.insertUser("alice")
+                return .Commit
+            }
+            XCTAssertEqual(1, self.db.scalar("SELECT count(*) FROM users") as! Int64)
+        }
+    }
+
+    func test_rollbackHook_setsRollbackHook() {
+        let rollbackHook = expectationWithDescription("commitHook")
+        db.rollbackHook {
+            rollbackHook.fulfill()
+        }
+        executeAndWait {
+            self.db.transaction { _ in
+                self.insertUser("alice")
+                return .Rollback
+            }
+            XCTAssertEqual(0, self.db.scalar("SELECT count(*) FROM users") as! Int64)
+        }
+    }
+
+    func test_commitHook_withRollback_rollsBack() {
+        let rollbackHook = expectationWithDescription("commitHook")
+        db.commitHook { .Rollback }
+        db.rollbackHook {
+            rollbackHook.fulfill()
+        }
+        executeAndWait {
+            self.db.transaction { _ in
+                self.insertUser("alice")
+                return .Commit
+            }
+            XCTAssertEqual(0, self.db.scalar("SELECT count(*) FROM users") as! Int64)
+        }
+    }
+
     func test_createFunction_withArrayArguments() {
         db.create(function: "hello") { $0[0].map { "Hello, \($0)!" } }
 
@@ -320,4 +378,13 @@ class DatabaseTests: SQLiteTestCase {
         XCTAssertEqual(1, db.scalar("SELECT ? = ? COLLATE \"NO DIACRITIC\"", "cafe", "café") as! Int64)
     }
 
+    func executeAndWait(block: () -> ()) {
+        dispatch_async(dispatch_get_main_queue(), block)
+        waitForExpectationsWithTimeout(5) { error in
+            if let error = error {
+                fatalError(error.localizedDescription)
+            }
+        }
+    }
+
 }

SQLite/Database.swift

@@ -404,6 +404,80 @@ public final class Database {
     }
     private var trace: SQLiteTraceCallback?
 
+    /// A SQL operation passed to update callbacks.
+    public enum Operation {
+
+        /// An INSERT operation.
+        case Insert
+
+        /// An UPDATE operation.
+        case Update
+
+        /// A DELETE operation.
+        case Delete
+
+        private static func fromRawValue(rawValue: Int32) -> Operation {
+            switch rawValue {
+            case SQLITE_INSERT:
+                return .Insert
+            case SQLITE_UPDATE:
+                return .Update
+            case SQLITE_DELETE:
+                return .Delete
+            default:
+                fatalError("unhandled operation code: \(rawValue)")
+            }
+        }
+
+    }
+
+    /// Registers a callback to be invoked whenever a row is inserted, updated,
+    /// or deleted in a rowid table.
+    ///
+    /// :param: callback A callback invoked with the `Operation` (one
+    ///                  of `.Insert`, `.Update`, or `.Delete`), database name,
+    ///                  table name, and rowid.
+    public func updateHook(callback: ((operation: Operation, db: String, table: String, rowid: Int64) -> ())?) {
+        if let callback = callback {
+            updateHook = { operation, db, table, rowid in
+                callback(
+                    operation: .fromRawValue(operation),
+                    db: String.fromCString(db)!,
+                    table: String.fromCString(table)!,
+                    rowid: rowid
+                )
+            }
+        } else {
+            updateHook = nil
+        }
+        SQLiteUpdateHook(handle, updateHook)
+    }
+    private var updateHook: SQLiteUpdateHookCallback?
+
+    /// Registers a callback to be invoked whenever a transaction is committed.
+    ///
+    /// :param: callback A callback that must return `.Commit` or `.Rollback` to
+    ///                  determine whether a transaction should be committed or
+    ///                  not.
+    public func commitHook(callback: (() -> TransactionResult)?) {
+        if let callback = callback {
+            commitHook = { callback() == .Commit ? 0 : 1 }
+        } else {
+            commitHook = nil
+        }
+        SQLiteCommitHook(handle, commitHook)
+    }
+    private var commitHook: SQLiteCommitHookCallback?
+
+    /// Registers a callback to be invoked whenever a transaction rolls back.
+    ///
+    /// :param: callback A callback invoked when a transaction is rolled back.
+    public func rollbackHook(callback: (() -> ())?) {
+        rollbackHook = callback.map { $0 }
+        SQLiteRollbackHook(handle, rollbackHook)
+    }
+    private var rollbackHook: SQLiteRollbackHookCallback?
+
     /// Creates or redefines a custom SQL function.
     ///
     /// :param: function      The name of the function to create or redefine.

SQLite/SQLite-Bridging.h

@@ -31,6 +31,15 @@ int SQLiteBusyHandler(sqlite3 * handle, SQLiteBusyHandlerCallback callback);
 typedef void (^SQLiteTraceCallback)(const char * SQL);
 void SQLiteTrace(sqlite3 * handle, SQLiteTraceCallback callback);
 
+typedef void (^SQLiteUpdateHookCallback)(int operation, const char * db, const char * table, sqlite3_int64 rowid);
+void SQLiteUpdateHook(sqlite3 * handle, SQLiteUpdateHookCallback callback);
+
+typedef int (^SQLiteCommitHookCallback)();
+void SQLiteCommitHook(sqlite3 * handle, SQLiteCommitHookCallback callback);
+
+typedef void (^SQLiteRollbackHookCallback)();
+void SQLiteRollbackHook(sqlite3 * handle, SQLiteRollbackHookCallback callback);
+
 typedef void (^SQLiteCreateFunctionCallback)(sqlite3_context * context, int argc, sqlite3_value ** argv);
 int SQLiteCreateFunction(sqlite3 * handle, const char * name, int argc, int deterministic, SQLiteCreateFunctionCallback callback);
 

SQLite/SQLite-Bridging.m

@@ -50,6 +50,30 @@ void SQLiteTrace(sqlite3 * handle, SQLiteTraceCallback callback) {
     }
 }
 
+static void _SQLiteUpdateHook(void * context, int operation, const char * db, const char * table, sqlite3_int64 rowid) {
+    ((__bridge SQLiteUpdateHookCallback)context)(operation, db, table, rowid);
+}
+
+void SQLiteUpdateHook(sqlite3 * handle, SQLiteUpdateHookCallback callback) {
+    sqlite3_update_hook(handle, _SQLiteUpdateHook, (__bridge void *)callback);
+}
+
+static int _SQLiteCommitHook(void * context) {
+    return ((__bridge SQLiteCommitHookCallback)context)();
+}
+
+void SQLiteCommitHook(sqlite3 * handle, SQLiteCommitHookCallback callback) {
+    sqlite3_commit_hook(handle, _SQLiteCommitHook, (__bridge void *)callback);
+}
+
+static void _SQLiteRollbackHook(void * context) {
+    ((__bridge SQLiteRollbackHookCallback)context)();
+}
+
+void SQLiteRollbackHook(sqlite3 * handle, SQLiteRollbackHookCallback callback) {
+    sqlite3_rollback_hook(handle, _SQLiteRollbackHook, (__bridge void *)callback);
+}
+
 static void _SQLiteCreateFunction(sqlite3_context * context, int argc, sqlite3_value ** argv) {
     ((__bridge SQLiteCreateFunctionCallback)sqlite3_user_data(context))(context, argc, argv);
 }