Added refreshSchema to bindings. Will cause all connections to be aware of a schema change.

Author: Chriztiaan

.changeset/angry-carrots-lay.md

@@ -0,0 +1,5 @@
+---
+"@journeyapps/react-native-quick-sqlite": minor
+---
+
+Added refreshSchema to bindings. Will cause all connections to be aware of a schema change.

cpp/ConnectionPool.cpp

@@ -168,6 +168,14 @@ void ConnectionPool::closeAll() {
   }
 }
 
+void ConnectionPool::refreshSchema() {
+  writeConnection.refreshSchema();
+
+  for (unsigned int i = 0; i < maxReads; i++) {
+    readConnections[i]->refreshSchema();
+  }
+}
+
 SQLiteOPResult ConnectionPool::attachDatabase(std::string const dbFileName,
                                               std::string const docPath,
                                               std::string const alias) {

cpp/ConnectionPool.h

@@ -126,6 +126,11 @@ class ConnectionPool {
    */
   void closeAll();
 
+  /**
+   * Refreshes the schema for all connections.
+   */
+  void refreshSchema();
+
   /**
    * Attaches another database to all connections
    */

cpp/ConnectionState.cpp

@@ -44,6 +44,12 @@ bool ConnectionState::matchesLock(const ConnectionLockId &lockId) {
 
 bool ConnectionState::isEmptyLock() { return _currentLockId == EMPTY_LOCK_ID; }
 
+void ConnectionState::refreshSchema() {
+  queueWork([this](sqlite3* db) {
+    sqlite3_exec(db, "PRAGMA table_info('sqlite_master')", nullptr, nullptr, nullptr);
+  });
+}
+
 void ConnectionState::close() {
   waitFinished();
   // So that the thread can stop (if not already)

cpp/ConnectionState.h

@@ -41,6 +41,7 @@ class ConnectionState {
   bool matchesLock(const ConnectionLockId &lockId);
   bool isEmptyLock();
 
+  void refreshSchema();
   void close();
   void queueWork(std::function<void(sqlite3 *)> task);
 

cpp/bindings.cpp

@@ -286,6 +286,20 @@ void osp::install(jsi::Runtime &rt,
     return {};
   });
 
+auto refreshSchema = HOSTFN("refreshSchema", 1) {
+    if (count == 0) {
+        throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name is required");
+    }
+
+    if (!args[0].isString()) {
+        throw jsi::JSError(rt, "[react-native-quick-sqlite][refreshSchema] database name must be a string");
+    }
+
+    string dbName = args[0].asString(rt).utf8(rt);
+
+    sqliteRefreshSchema(dbName);
+});
+
   auto executeInContext = HOSTFN("executeInContext", 3) {
     if (count < 4) {
       throw jsi::JSError(rt,
@@ -500,6 +514,7 @@ void osp::install(jsi::Runtime &rt,
   module.setProperty(rt, "releaseLock", move(releaseLock));
   module.setProperty(rt, "executeInContext", move(executeInContext));
   module.setProperty(rt, "close", move(close));
+  module.setProperty(rt, "refreshSchema", move(refreshSchema));
 
   module.setProperty(rt, "attach", move(attach));
   module.setProperty(rt, "detach", move(detach));

cpp/sqliteBridge.cpp

@@ -60,6 +60,17 @@ sqliteOpenDb(string const dbName, string const docPath,
   };
 }
 
+void sqliteRefreshSchema(string const dbName) {
+  if (dbMap.count(dbName) == 0) {
+   // Do nothing 
+    return;
+  }
+
+  ConnectionPool *connection = dbMap[dbName];
+  connection->refreshSchema();
+}
+
+
 SQLiteOPResult sqliteCloseDb(string const dbName) {
   if (dbMap.count(dbName) == 0) {
     return generateNotOpenResult(dbName);

cpp/sqliteBridge.h

@@ -33,6 +33,8 @@ sqliteOpenDb(std::string const dbName, std::string const docPath,
                  const TransactionCallbackPayload *event),
              uint32_t numReadConnections);
 
+void sqliteRefreshSchema(string const dbName);
+
 SQLiteOPResult sqliteCloseDb(string const dbName);
 
 void sqliteCloseAll();

src/setup-open.ts

@@ -225,6 +225,7 @@ export function setupOpen(QuickSQLite: ISQLite) {
       // Return the concurrent connection object
       return {
         close: () => QuickSQLite.close(dbName),
+        refreshSchema: () => QuickSQLite.refreshSchema(dbName),
         execute: (sql: string, args?: any[]) => writeLock((context) => context.execute(sql, args)),
         readLock,
         readTransaction: async <T>(callback: (context: TransactionContext) => Promise<T>, options?: LockOptions) =>

src/types.ts

@@ -124,6 +124,7 @@ export interface ISQLite {
   open: Open;
   close: (dbName: string) => void;
   delete: (dbName: string, location?: string) => void;
+  refreshSchema: (dbName: string) => void;
 
   requestLock: (dbName: string, id: ContextLockID, type: ConcurrentLockType) => QueryResult;
   releaseLock(dbName: string, id: ContextLockID): void;
@@ -151,6 +152,7 @@ export interface TransactionContext extends LockContext {
 
 export type QuickSQLiteConnection = {
   close: () => void;
+  refreshSchema: () => void;
   execute: (sql: string, args?: any[]) => Promise<QueryResult>;
   readLock: <T>(callback: (context: LockContext) => Promise<T>, options?: LockOptions) => Promise<T>;
   readTransaction: <T>(callback: (context: TransactionContext) => Promise<T>, options?: LockOptions) => Promise<T>;