Ensure that configuration changes propagate to all pooled connections (#36)

Author: eygraber

library/src/commonMain/kotlin/com/eygraber/sqldelight/androidx/driver/AndroidxSqliteConfiguration.kt

@@ -0,0 +1,70 @@
+package com.eygraber.sqldelight.androidx.driver
+
+/**
+ * [sqlite.org journal_mode](https://www.sqlite.org/pragma.html#pragma_journal_mode)
+ */
+public enum class SqliteJournalMode(internal val value: String) {
+  Delete("DELETE"),
+  Truncate("TRUNCATE"),
+  Persist("PERSIST"),
+  Memory("MEMORY"),
+  @Suppress("EnumNaming")
+  WAL("WAL"),
+  Off("OFF"),
+}
+
+/**
+ * [sqlite.org synchronous](https://www.sqlite.org/pragma.html#pragma_synchronous)
+ */
+public enum class SqliteSync(internal val value: String) {
+  Off("OFF"),
+  Normal("NORMAL"),
+  Full("FULL"),
+  Extra("EXTRA"),
+}
+
+public class AndroidxSqliteConfiguration(
+  /**
+   * The maximum size of the prepared statement cache for each database connection.
+   *
+   * Default is 25.
+   */
+  public val cacheSize: Int = 25,
+  /**
+   * True if foreign key constraints are enabled.
+   *
+   * Default is false.
+   */
+  public var isForeignKeyConstraintsEnabled: Boolean = false,
+  /**
+   * Journal mode to use.
+   *
+   * Default is [SqliteJournalMode.WAL].
+   */
+  public var journalMode: SqliteJournalMode = SqliteJournalMode.WAL,
+  /**
+   * Synchronous mode to use.
+   *
+   * Default is [SqliteSync.Full] unless [journalMode] is set to [SqliteJournalMode.WAL] in which case it is [SqliteSync.Normal].
+   */
+  public var sync: SqliteSync = when(journalMode) {
+    SqliteJournalMode.WAL -> SqliteSync.Normal
+    SqliteJournalMode.Delete,
+    SqliteJournalMode.Truncate,
+    SqliteJournalMode.Persist,
+    SqliteJournalMode.Memory,
+    SqliteJournalMode.Off,
+    -> SqliteSync.Full
+  },
+  /**
+   * The max amount of read connections that will be kept in the [ConnectionPool].
+   *
+   * Defaults to 4 when [journalMode] is [SqliteJournalMode.WAL], otherwise 0 (since reads are blocked by writes).
+   *
+   * The default for [SqliteJournalMode.WAL] may be changed in the future to be based on how many CPUs are available.
+   */
+  public val readerConnectionsCount: Int = when(journalMode) {
+    SqliteJournalMode.WAL -> 4
+    else -> 0
+  },
+)

library/src/commonMain/kotlin/com/eygraber/sqldelight/androidx/driver/AndroidxSqliteDriver.kt

@@ -23,8 +23,6 @@ internal expect class TransactionsThreadLocal() {
   internal fun set(transaction: Transacter.Transaction?)
 }
 
-internal const val DEFAULT_CACHE_SIZE = 20
-
 /**
  * @param databaseType Specifies the type of the database file
  * (see [Sqlite open documentation](https://www.sqlite.org/c3ref/open.html)).
@@ -37,21 +35,19 @@ public class AndroidxSqliteDriver(
   createConnection: (String) -> SQLiteConnection,
   databaseType: AndroidxSqliteDatabaseType,
   private val schema: SqlSchema<QueryResult.Value<Unit>>,
-  readerConnections: Int = 0,
-  private val cacheSize: Int = DEFAULT_CACHE_SIZE,
+  private val configuration: AndroidxSqliteConfiguration = AndroidxSqliteConfiguration(),
   private val migrateEmptySchema: Boolean = false,
   private val onConfigure: ConfigurableDatabase.() -> Unit = {},
-  private val onCreate: SqlDriver.() -> Unit = {},
-  private val onUpdate: SqlDriver.(Long, Long) -> Unit = { _, _ -> },
-  private val onOpen: SqlDriver.() -> Unit = {},
+  private val onCreate: AndroidxSqliteDriver.() -> Unit = {},
+  private val onUpdate: AndroidxSqliteDriver.(Long, Long) -> Unit = { _, _ -> },
+  private val onOpen: AndroidxSqliteDriver.() -> Unit = {},
   vararg migrationCallbacks: AfterVersion,
 ) : SqlDriver {
   public constructor(
     driver: SQLiteDriver,
     databaseType: AndroidxSqliteDatabaseType,
     schema: SqlSchema<QueryResult.Value<Unit>>,
-    readerConnections: Int = 0,
-    cacheSize: Int = DEFAULT_CACHE_SIZE,
+    configuration: AndroidxSqliteConfiguration = AndroidxSqliteConfiguration(),
     migrateEmptySchema: Boolean = false,
     onConfigure: ConfigurableDatabase.() -> Unit = {},
     onCreate: SqlDriver.() -> Unit = {},
@@ -62,8 +58,7 @@ public class AndroidxSqliteDriver(
     createConnection = driver::open,
     databaseType = databaseType,
     schema = schema,
-    readerConnections = readerConnections,
-    cacheSize = cacheSize,
+    configuration = configuration,
     migrateEmptySchema = migrateEmptySchema,
     onConfigure = onConfigure,
     onCreate = onCreate,
@@ -83,11 +78,12 @@ public class AndroidxSqliteDriver(
         AndroidxSqliteDatabaseType.Memory -> ":memory:"
         AndroidxSqliteDatabaseType.Temporary -> ""
       },
-      maxReaders = when(databaseType) {
-        is AndroidxSqliteDatabaseType.File -> readerConnections
-        AndroidxSqliteDatabaseType.Memory -> 0
-        AndroidxSqliteDatabaseType.Temporary -> 0
+      isFileBased = when(databaseType) {
+        is AndroidxSqliteDatabaseType.File -> true
+        AndroidxSqliteDatabaseType.Memory -> false
+        AndroidxSqliteDatabaseType.Temporary -> false
       },
+      configuration = configuration,
     )
   }
 
@@ -99,7 +95,7 @@ public class AndroidxSqliteDriver(
     statementsCaches.getOrPut(
       connection,
     ) {
-      object : LruCache<Int, AndroidxStatement>(cacheSize) {
+      object : LruCache<Int, AndroidxStatement>(configuration.cacheSize) {
         override fun entryRemoved(
           evicted: Boolean,
           key: Int,
@@ -118,6 +114,51 @@ public class AndroidxSqliteDriver(
 
   private val migrationCallbacks = migrationCallbacks
 
+  /**
+   * True if foreign key constraints are enabled.
+   *
+   * This function will block until all connections have been updated.
+   *
+   * An exception will be thrown if this is called from within a transaction.
+   */
+  public fun setForeignKeyConstraintsEnabled(isForeignKeyConstraintsEnabled: Boolean) {
+    check(currentTransaction() == null) {
+      "setForeignKeyConstraintsEnabled cannot be called from within a transaction"
+    }
+
+    connectionPool.setForeignKeyConstraintsEnabled(isForeignKeyConstraintsEnabled)
+  }
+
+  /**
+   * Journal mode to use.
+   *
+   * This function will block until all connections have been updated.
+   *
+   * An exception will be thrown if this is called from within a transaction.
+   */
+  public fun setJournalMode(journalMode: SqliteJournalMode) {
+    check(currentTransaction() == null) {
+      "setJournalMode cannot be called from within a transaction"
+    }
+
+    connectionPool.setJournalMode(journalMode)
+  }
+
+  /**
+   * Synchronous mode to use.
+   *
+   * This function will block until all connections have been updated.
+   *
+   * An exception will be thrown if this is called from within a transaction.
+   */
+  public fun setSync(sync: SqliteSync) {
+    check(currentTransaction() == null) {
+      "setSync cannot be called from within a transaction"
+    }
+
+    connectionPool.setSync(sync)
+  }
+
   override fun addListener(vararg queryKeys: String, listener: Query.Listener) {
     synchronized(listenersLock) {
       queryKeys.forEach {

library/src/commonMain/kotlin/com/eygraber/sqldelight/androidx/driver/AndroidxSqliteHelpers.kt

@@ -4,39 +4,19 @@ import app.cash.sqldelight.db.QueryResult
 import app.cash.sqldelight.db.SqlCursor
 import app.cash.sqldelight.db.SqlPreparedStatement
 
-public fun AndroidxSqliteDriver.enableForeignKeys() {
-  execute(null, "PRAGMA foreign_keys = ON;", 0, null)
-}
-
-public fun AndroidxSqliteDriver.disableForeignKeys() {
-  execute(null, "PRAGMA foreign_keys = OFF;", 0, null)
-}
-
-public fun AndroidxSqliteDriver.enableWAL() {
-  execute(null, "PRAGMA journal_mode = WAL;", 0, null)
-}
-
-public fun AndroidxSqliteDriver.disableWAL() {
-  execute(null, "PRAGMA journal_mode = DELETE;", 0, null)
-}
-
 public class ConfigurableDatabase(
   private val driver: AndroidxSqliteDriver,
 ) {
-  public fun enableForeignKeys() {
-    driver.enableForeignKeys()
-  }
-
-  public fun disableForeignKeys() {
-    driver.disableForeignKeys()
+  public fun setForeignKeyConstraintsEnabled(isForeignKeyConstraintsEnabled: Boolean) {
+    driver.setForeignKeyConstraintsEnabled(isForeignKeyConstraintsEnabled)
   }
 
-  public fun enableWAL() {
-    driver.enableWAL()
+  public fun setJournalMode(journalMode: SqliteJournalMode) {
+    driver.setJournalMode(journalMode)
   }
 
-  public fun disableWAL() {
-    driver.disableWAL()
+  public fun setSync(sync: SqliteSync) {
+    driver.setSync(sync)
   }
 
   public fun executePragma(

library/src/commonMain/kotlin/com/eygraber/sqldelight/androidx/driver/ConnectionPool.kt

@@ -1,6 +1,7 @@
 package com.eygraber.sqldelight.androidx.driver
 
 import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteStatement
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
@@ -9,13 +10,25 @@ import kotlinx.coroutines.sync.withLock
 internal class ConnectionPool(
   private val createConnection: (String) -> SQLiteConnection,
   private val name: String,
-  private val maxReaders: Int = 4,
+  private val isFileBased: Boolean,
+  private val configuration: AndroidxSqliteConfiguration,
 ) {
-  private val writerConnection: SQLiteConnection by lazy { createConnection(name) }
+  private val writerConnection: SQLiteConnection by lazy {
+    createConnection(name).withConfiguration()
+  }
   private val writerMutex = Mutex()
 
-  private val readerChannel = Channel<SQLiteConnection>(capacity = maxReaders)
-  private val readerConnections = List(maxReaders) { lazy { createConnection(name) } }
+  private val maxReaderConnectionsCount = when {
+    isFileBased -> configuration.readerConnectionsCount
+    else -> 0
+  }
+
+  private val readerChannel = Channel<SQLiteConnection>(capacity = maxReaderConnectionsCount)
+  private val readerConnections = List(maxReaderConnectionsCount) {
+    lazy {
+      createConnection(name).withConfiguration()
+    }
+  }
 
   /**
    * Acquires the writer connection, blocking if it's currently in use.
@@ -37,7 +50,7 @@ internal class ConnectionPool(
    * Acquires a reader connection, blocking if none are available.
    * @return A reader SQLiteConnection
    */
-  fun acquireReaderConnection() = when(maxReaders) {
+  fun acquireReaderConnection() = when(maxReaderConnectionsCount) {
     0 -> acquireWriterConnection()
     else -> runBlocking {
       val firstUninitialized = readerConnections.firstOrNull { !it.isInitialized() }
@@ -49,13 +62,61 @@ internal class ConnectionPool(
    * Releases a reader connection back to the pool.
    * @param connection The SQLiteConnection to release
    */
-  fun releaseReaderConnection(connection: SQLiteConnection) = when(maxReaders) {
+  fun releaseReaderConnection(connection: SQLiteConnection) = when(maxReaderConnectionsCount) {
     0 -> releaseWriterConnection()
     else -> runBlocking {
       readerChannel.send(connection)
     }
   }
 
+  fun setForeignKeyConstraintsEnabled(isForeignKeyConstraintsEnabled: Boolean) {
+    configuration.isForeignKeyConstraintsEnabled = isForeignKeyConstraintsEnabled
+    val foreignKeys = if(isForeignKeyConstraintsEnabled) "ON" else "OFF"
+    runPragmaOnAllConnections("PRAGMA foreign_keys = $foreignKeys;")
+  }
+
+  fun setJournalMode(journalMode: SqliteJournalMode) {
+    configuration.journalMode = journalMode
+    runPragmaOnAllConnections("PRAGMA journal_mode = ${configuration.journalMode.value};")
+  }
+
+  fun setSync(sync: SqliteSync) {
+    configuration.sync = sync
+    runPragmaOnAllConnections("PRAGMA synchronous = ${configuration.sync.value};")
+  }
+
+  private fun runPragmaOnAllConnections(sql: String) {
+    val writer = acquireWriterConnection()
+    try {
+      writer.writePragma(sql)
+    } finally {
+      releaseWriterConnection()
+    }
+
+    if(maxReaderConnectionsCount > 0) {
+      runBlocking {
+        val createdReadersCount = readerConnections.count { it.isInitialized() }
+        val readers = List(createdReadersCount) {
+          readerChannel.receive()
+        }
+        readers.forEach { reader ->
+          try {
+            reader.writePragma(sql)
+          } finally {
+            releaseReaderConnection(reader)
+          }
+        }
+      }
+    }
+  }
+
+  private fun SQLiteConnection.withConfiguration(): SQLiteConnection = this.apply {
+    val foreignKeys = if(configuration.isForeignKeyConstraintsEnabled) "ON" else "OFF"
+    writePragma("PRAGMA foreign_keys = $foreignKeys;")
+    writePragma("PRAGMA journal_mode = ${configuration.journalMode.value};")
+    writePragma("PRAGMA synchronous = ${configuration.sync.value};")
+  }
+
   /**
    * Closes all connections in the pool.
    */
@@ -71,3 +132,7 @@ internal class ConnectionPool(
     }
   }
 }
+
+private fun SQLiteConnection.writePragma(sql: String) {
+  prepare(sql).use(SQLiteStatement::step)
+}

library/src/commonTest/kotlin/com/eygraber/sqldelight/androidx/driver/AndroidxSqliteConcurrencyTest.kt

@@ -47,7 +47,7 @@ abstract class AndroidxSqliteConcurrencyTest {
     onCreate: SqlDriver.() -> Unit,
     onUpdate: SqlDriver.(Long, Long) -> Unit,
     onOpen: SqlDriver.() -> Unit,
-    onConfigure: ConfigurableDatabase.() -> Unit = { enableWAL() },
+    onConfigure: ConfigurableDatabase.() -> Unit = { setJournalMode(SqliteJournalMode.WAL) },
   ): SqlDriver = AndroidxSqliteDriver(
     createConnection = androidxSqliteTestCreateConnection(),
     databaseType = AndroidxSqliteDatabaseType.File(dbName),

library/src/commonTest/kotlin/com/eygraber/sqldelight/androidx/driver/AndroidxSqliteDriverTest.kt

@@ -70,7 +70,7 @@ abstract class AndroidxSqliteDriverTest {
       androidxSqliteTestDriver(),
       AndroidxSqliteDatabaseType.Memory,
       schema,
-      cacheSize = 1,
+      AndroidxSqliteConfiguration(cacheSize = 1),
     ).use(block)
   }