Add support for update/commit/rollback event notifications (#350)

Using sqlite3_commit_hook, sqlite3_rollback_hook, and
sqlite3_update_hook

Co-authored-by: Moxie Marlinspike <[email protected]>

Author: moxie0

src/main/java/org/sqlite/SQLiteCommitListener.java

@@ -0,0 +1,12 @@
+package org.sqlite;
+
+/**
+ * https://www.sqlite.org/c3ref/commit_hook.html
+ */
+
+public interface SQLiteCommitListener {
+
+  void onCommit();
+  void onRollback();
+
+}

src/main/java/org/sqlite/SQLiteConnection.java

@@ -417,6 +417,42 @@ public void rollback() throws SQLException {
         db.exec(connectionConfig.transactionPrefix(), getAutoCommit());
     }
 
+    /**
+     * Add a listener for DB update events, see https://www.sqlite.org/c3ref/update_hook.html
+     *
+     * @param listener The listener to receive update events
+     */
+    public void addUpdateListener(SQLiteUpdateListener listener) {
+        db.addUpdateListener(listener);
+    }
+
+    /**
+     * Remove a listener registered for DB update events.
+     *
+     * @param listener The listener to no longer receive update events
+     */
+    public void removeUpdateListener(SQLiteUpdateListener listener) {
+        db.removeUpdateListener(listener);
+    }
+
+
+    /**
+     * Add a listener for DB commit/rollback events, see https://www.sqlite.org/c3ref/commit_hook.html
+     *
+     * @param listener The listener to receive commit events
+     */
+    public void addCommitListener(SQLiteCommitListener listener) {
+        db.addCommitListener(listener);
+    }
+
+    /**
+     * Remove a listener registered for DB commit/rollback events.
+     *
+     * @param listener The listener to no longer receive commit/rollback events.
+     */
+    public void removeCommitListener(SQLiteCommitListener listener) {
+        db.removeCommitListener(listener);
+    }
 
     /**
      * Extracts PRAGMA values from the filename and sets them into the Properties

src/main/java/org/sqlite/SQLiteUpdateListener.java

@@ -0,0 +1,14 @@
+package org.sqlite;
+
+/**
+ * https://www.sqlite.org/c3ref/update_hook.html
+ */
+public interface SQLiteUpdateListener {
+
+  public enum Type {
+    INSERT, DELETE, UPDATE
+  }
+
+  void onUpdate(Type type, String database, String table, long rowId);
+
+}

src/main/java/org/sqlite/core/DB.java

@@ -18,15 +18,19 @@
 import org.sqlite.BusyHandler;
 import org.sqlite.Function;
 import org.sqlite.ProgressHandler;
+import org.sqlite.SQLiteCommitListener;
 import org.sqlite.SQLiteConfig;
 import org.sqlite.SQLiteErrorCode;
 import org.sqlite.SQLiteException;
+import org.sqlite.SQLiteUpdateListener;
 
 import java.sql.BatchUpdateException;
 import java.sql.SQLException;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /*
@@ -55,6 +59,9 @@ public abstract class DB implements Codes
     /** Tracer for statements to avoid unfinalized statements on db close. */
     private final Map<Long, CoreStatement> stmts  = new HashMap<Long, CoreStatement>();
 
+    private final Set<SQLiteUpdateListener> updateListeners = new HashSet<SQLiteUpdateListener>();
+    private final Set<SQLiteCommitListener> commitListeners = new HashSet<SQLiteCommitListener>();
+
     public DB(String url, String fileName, SQLiteConfig config)
             throws SQLException
     {
@@ -901,6 +908,68 @@ public final synchronized int executeUpdate(CoreStatement stmt, Object[] vals) t
         return changes();
     }
 
+    abstract void set_commit_listener(boolean enabled);
+    abstract void set_update_listener(boolean enabled);
+
+    public synchronized void addUpdateListener(SQLiteUpdateListener listener) {
+        if (updateListeners.add(listener) && updateListeners.size() == 1) {
+            set_update_listener(true);
+        }
+    }
+
+    public synchronized void addCommitListener(SQLiteCommitListener listener) {
+        if (commitListeners.add(listener) && commitListeners.size() == 1) {
+            set_commit_listener(true);
+        }
+    }
+
+    public synchronized void removeUpdateListener(SQLiteUpdateListener listener) {
+        if (updateListeners.remove(listener) && updateListeners.isEmpty()) {
+            set_update_listener(false);
+        }
+    }
+
+    public synchronized void removeCommitListener(SQLiteCommitListener listener) {
+        if (commitListeners.remove(listener) && commitListeners.isEmpty()) {
+            set_commit_listener(false);
+        }
+    }
+
+    void onUpdate(int type, String database, String table, long rowId) {
+        Set<SQLiteUpdateListener> listeners;
+
+        synchronized (this) {
+            listeners = new HashSet<SQLiteUpdateListener>(updateListeners);
+        }
+
+        for (SQLiteUpdateListener listener : listeners) {
+            SQLiteUpdateListener.Type operationType;
+
+            switch (type) {
+                case 18: operationType = SQLiteUpdateListener.Type.INSERT; break;
+                case 9:  operationType = SQLiteUpdateListener.Type.DELETE; break;
+                case 23: operationType = SQLiteUpdateListener.Type.UPDATE; break;
+                default: throw new AssertionError("Unknown type: " + type);
+            }
+
+
+            listener.onUpdate(operationType, database, table, rowId);
+        }
+    }
+
+    void onCommit(boolean commit) {
+        Set<SQLiteCommitListener> listeners;
+
+        synchronized (this) {
+            listeners = new HashSet<SQLiteCommitListener>(commitListeners);
+        }
+
+        for (SQLiteCommitListener listener : listeners) {
+            if (commit) listener.onCommit();
+            else        listener.onRollback();
+        }
+    }
+
     /**
      * Throws SQLException with error message.
      * @throws SQLException

src/main/java/org/sqlite/core/NativeDB.c

@@ -1328,7 +1328,6 @@ JNIEXPORT void JNICALL Java_org_sqlite_core_NativeDB_free_1functions(
     }
 }
 
-
 // COMPOUND FUNCTIONS ///////////////////////////////////////////////
 
 JNIEXPORT jobjectArray JNICALL Java_org_sqlite_core_NativeDB_column_1metadata(
@@ -1607,3 +1606,76 @@ JNIEXPORT void JNICALL Java_org_sqlite_core_NativeDB_clear_1progress_1handler(
     sqlite3_progress_handler(gethandle(env, this), 0, NULL, NULL);
     (*env)->DeleteGlobalRef(env, progress_handler_context.phandler);
 }
+
+// Update hook
+
+struct UpdateHandlerContext {
+    JavaVM *vm;
+    jmethodID method;
+    jobject handler;
+};
+
+static struct UpdateHandlerContext update_handler_context;
+
+
+void update_hook(void *context, int type, char const *database, char const *table, sqlite3_int64 row) {
+    JNIEnv *env = 0;
+    (*update_handler_context.vm)->AttachCurrentThread(update_handler_context.vm, (void **)&env, 0);
+
+    jstring databaseString = (*env)->NewStringUTF(env, database);
+    jstring tableString    = (*env)->NewStringUTF(env, table);
+
+    (*env)->CallVoidMethod(env, update_handler_context.handler, update_handler_context.method, type, databaseString, tableString, row);
+
+    (*env)->DeleteLocalRef(env, databaseString);
+    (*env)->DeleteLocalRef(env, tableString);
+}
+
+JNIEXPORT void JNICALL Java_org_sqlite_core_NativeDB_set_1update_1listener(JNIEnv *env, jobject this, jboolean enabled) {
+    if (enabled) {
+        update_handler_context.method = (*env)->GetMethodID(env, dbclass, "onUpdate", "(ILjava/lang/String;Ljava/lang/String;J)V");
+        update_handler_context.handler = (*env)->NewGlobalRef(env, this);
+        (*env)->GetJavaVM(env, &update_handler_context.vm);
+        sqlite3_update_hook(gethandle(env, this), &update_hook, NULL);
+    } else {
+        sqlite3_update_hook(gethandle(env, this), NULL, NULL);
+        (*env)->DeleteGlobalRef(env, update_handler_context.handler);
+    }
+}
+
+// Commit hook
+
+struct CommitHandlerContext {
+    JavaVM *vm;
+    jmethodID method;
+    jobject handler;
+};
+
+static struct CommitHandlerContext commit_handler_context;
+
+int commit_hook(void *context) {
+    JNIEnv *env = 0;
+    (*commit_handler_context.vm)->AttachCurrentThread(commit_handler_context.vm, (void **)&env, 0);
+    (*env)->CallVoidMethod(env, commit_handler_context.handler, commit_handler_context.method, 1);
+    return 0;
+}
+
+void rollback_hook(void *context) {
+    JNIEnv *env = 0;
+    (*commit_handler_context.vm)->AttachCurrentThread(commit_handler_context.vm, (void **)&env, 0);
+    (*env)->CallVoidMethod(env, commit_handler_context.handler, commit_handler_context.method, 0);
+}
+
+JNIEXPORT void JNICALL Java_org_sqlite_core_NativeDB_set_1commit_1listener(JNIEnv *env, jobject this, jboolean enabled) {
+    if (enabled) {
+        commit_handler_context.method  = (*env)->GetMethodID(env, dbclass, "onCommit", "(Z)V");
+        commit_handler_context.handler = (*env)->NewGlobalRef(env, this);
+        (*env)->GetJavaVM(env, &commit_handler_context.vm);
+        sqlite3_commit_hook(gethandle(env, this), &commit_hook, NULL);
+        sqlite3_rollback_hook(gethandle(env, this), &rollback_hook, NULL);
+    }  else {
+        sqlite3_commit_hook(gethandle(env, this), NULL, NULL);
+        sqlite3_update_hook(gethandle(env, this), NULL, NULL);
+        (*env)->DeleteGlobalRef(env, commit_handler_context.handler);
+    }
+}

src/main/java/org/sqlite/core/NativeDB.java

@@ -469,6 +469,12 @@ native synchronized int restore(byte[] dbNameUtf8, byte[] sourceFileName,
     @Override
     native synchronized boolean[][] column_metadata(long stmt);
 
+    @Override
+    native synchronized void set_commit_listener(boolean enabled);
+
+    @Override
+    native synchronized void set_update_listener(boolean enabled);
+
     /**
      * Throws an SQLException
      * @param msg Message for the SQLException.