Add raw connection API

Author: simolus3

core/build.gradle.kts

@@ -181,6 +181,7 @@ kotlin {
         all {
             languageSettings {
                 optIn("kotlinx.cinterop.ExperimentalForeignApi")
+                optIn("kotlin.experimental.ExperimentalObjCRefinement")
             }
         }
 
@@ -202,6 +203,7 @@ kotlin {
 
             dependencies {
                 api(libs.kermit)
+                api(libs.androidx.sqlite)
 
                 implementation(libs.uuid)
                 implementation(libs.kotlin.stdlib)

core/src/androidMain/kotlin/com/powersync/DatabaseDriverFactory.android.kt

@@ -15,7 +15,7 @@ public actual class DatabaseDriverFactory(
         dbFilename: String,
         dbDirectory: String?,
         readOnly: Boolean,
-        listener: ConnectionListener?
+        listener: ConnectionListener?,
     ): SQLiteConnection {
         val dbPath =
             if (dbDirectory != null) {

core/src/appleMain/kotlin/com/powersync/DatabaseDriverFactory.apple.kt

@@ -33,7 +33,7 @@ public actual class DatabaseDriverFactory {
         dbFilename: String,
         dbDirectory: String?,
         readOnly: Boolean,
-        listener: ConnectionListener?
+        listener: ConnectionListener?,
     ): SQLiteConnection {
         val directory = dbDirectory ?: defaultDatabaseDirectory()
         val path = Path(directory, dbFilename).toString()
@@ -61,15 +61,16 @@ public actual class DatabaseDriverFactory {
         @OptIn(UnsafeNumber::class)
         private fun defaultDatabaseDirectory(search: String = "databases"): String {
             // This needs to be compatible with https://github.com/touchlab/SQLiter/blob/a37bbe7e9c65e6a5a94c5bfcaccdaae55ad2bac9/sqliter-driver/src/appleMain/kotlin/co/touchlab/sqliter/DatabaseFileContext.kt#L36-L51
-            val paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, true);
-            val documentsDirectory = paths[0] as String;
+            val paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, true)
+            val documentsDirectory = paths[0] as String
 
             val databaseDirectory = "$documentsDirectory/$search"
 
             val fileManager = NSFileManager.defaultManager()
 
-            if (!fileManager.fileExistsAtPath(databaseDirectory))
-                fileManager.createDirectoryAtPath(databaseDirectory, true, null, null); //Create folder
+            if (!fileManager.fileExistsAtPath(databaseDirectory)) {
+                fileManager.createDirectoryAtPath(databaseDirectory, true, null, null)
+            }; // Create folder
 
             return databaseDirectory
         }

core/src/commonIntegrationTest/kotlin/com/powersync/DatabaseTest.kt

@@ -1,5 +1,7 @@
 package com.powersync
 
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.execSQL
 import app.cash.turbine.turbineScope
 import co.touchlab.kermit.ExperimentalKermitApi
 import com.powersync.db.ActiveDatabaseGroup
@@ -13,6 +15,7 @@ import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldContain
+import io.kotest.matchers.throwable.shouldHaveMessage
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
@@ -459,4 +462,38 @@ class DatabaseTest {
 
             database.getCrudBatch() shouldBe null
         }
+
+    @Test
+    fun testRawConnection() =
+        databaseTest {
+            database.execute(
+                "INSERT INTO users (id, name, email) VALUES (uuid(), ?, ?)",
+                listOf("a", "[email protected]"),
+            )
+            var capturedConnection: SQLiteConnection? = null
+
+            database.readLock {
+                it.rawConnection.prepare("SELECT * FROM users").use { stmt ->
+                    stmt.step() shouldBe true
+                    stmt.getText(1) shouldBe "a"
+                    stmt.getText(2) shouldBe "[email protected]"
+                }
+
+                capturedConnection = it.rawConnection
+            }
+
+            // When we exit readLock, the connection should no longer be usable
+            shouldThrow<IllegalStateException> { capturedConnection!!.execSQL("DELETE FROM users") } shouldHaveMessage
+                "Connection lease already closed"
+
+            capturedConnection = null
+            database.writeLock {
+                it.rawConnection.execSQL("DELETE FROM users")
+                capturedConnection = it.rawConnection
+            }
+
+            // Same thing for writes
+            shouldThrow<IllegalStateException> { capturedConnection!!.prepare("SELECT * FROM users") } shouldHaveMessage
+                "Connection lease already closed"
+        }
 }

core/src/commonIntegrationTest/kotlin/com/powersync/sync/SyncIntegrationTest.kt

@@ -597,10 +597,12 @@ abstract class BaseSyncIntegrationTest(
                 val turbine = database.currentStatus.asFlow().testIn(scope)
                 turbine.waitFor { it.connected }
 
-                val query = database.watch("SELECT name FROM users") {
-                    println("interpreting results: ${it.getString(0)}")
-                    it.getString(0)!!
-                }.testIn(scope)
+                val query =
+                    database
+                        .watch("SELECT name FROM users") {
+                            println("interpreting results: ${it.getString(0)}")
+                            it.getString(0)!!
+                        }.testIn(scope)
                 query.awaitItem() shouldBe listOf("local write")
 
                 syncLines.send(SyncLine.KeepAlive(tokenExpiresIn = 1234))

core/src/commonMain/kotlin/com/powersync/db/PowerSyncDatabaseImpl.kt

@@ -1,5 +1,6 @@
 package com.powersync.db
 
+import androidx.sqlite.SQLiteConnection
 import co.touchlab.kermit.Logger
 import com.powersync.DatabaseDriverFactory
 import com.powersync.PowerSyncDatabase
@@ -46,7 +47,6 @@ import kotlinx.datetime.Instant
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toInstant
-import kotlin.math.log
 import kotlin.time.Duration.Companion.milliseconds
 
 /**

core/src/commonMain/kotlin/com/powersync/db/SqlCursor.kt

@@ -31,62 +31,54 @@ private inline fun <T> SqlCursor.getColumnValue(
     return getValue(index) ?: throw IllegalArgumentException("Null value found for column '$name'")
 }
 
-internal class StatementBasedCursor(private val stmt: SQLiteStatement): SqlCursor {
-    override fun getBoolean(index: Int): Boolean? {
-        return getNullable(index) { index -> stmt.getLong(index) != 0L }
-    }
+internal class StatementBasedCursor(
+    private val stmt: SQLiteStatement,
+) : SqlCursor {
+    override fun getBoolean(index: Int): Boolean? = getNullable(index) { index -> stmt.getLong(index) != 0L }
 
-    override fun getBytes(index: Int): ByteArray? {
-        return getNullable(index, SQLiteStatement::getBlob)
-    }
+    override fun getBytes(index: Int): ByteArray? = getNullable(index, SQLiteStatement::getBlob)
 
-    override fun getDouble(index: Int): Double? {
-        return getNullable(index, SQLiteStatement::getDouble)
-    }
+    override fun getDouble(index: Int): Double? = getNullable(index, SQLiteStatement::getDouble)
 
-    override fun getLong(index: Int): Long? {
-        return getNullable(index, SQLiteStatement::getLong)
-    }
+    override fun getLong(index: Int): Long? = getNullable(index, SQLiteStatement::getLong)
 
-    override fun getString(index: Int): String? {
-        return getNullable(index, SQLiteStatement::getText)
-    }
+    override fun getString(index: Int): String? = getNullable(index, SQLiteStatement::getText)
 
-    private inline fun <T> getNullable(index: Int, read: SQLiteStatement.(Int) -> T): T? {
-        return if (stmt.isNull(index)) {
+    private inline fun <T> getNullable(
+        index: Int,
+        read: SQLiteStatement.(Int) -> T,
+    ): T? =
+        if (stmt.isNull(index)) {
             null
         } else {
             stmt.read(index)
         }
-    }
 
-    override fun columnName(index: Int): String? {
-        return stmt.getColumnName(index)
-    }
+    override fun columnName(index: Int): String? = stmt.getColumnName(index)
 
     override val columnCount: Int
         get() = stmt.getColumnCount()
 
     override val columnNames: Map<String, Int> by lazy {
         buildMap {
             stmt.getColumnNames().forEachIndexed { index, key ->
-               val finalKey = if (containsKey(key)) {
-                    var index = 1
-                    val basicKey = "$key&JOIN"
-                    var finalKey = basicKey + index
-                    while (containsKey(finalKey)) {
-                        finalKey = basicKey + ++index
+                val finalKey =
+                    if (containsKey(key)) {
+                        var index = 1
+                        val basicKey = "$key&JOIN"
+                        var finalKey = basicKey + index
+                        while (containsKey(finalKey)) {
+                            finalKey = basicKey + ++index
+                        }
+                        finalKey
+                    } else {
+                        key
                     }
-                    finalKey
-                } else {
-                    key
-                }
 
                 put(finalKey, index)
             }
         }
     }
-
 }
 
 private inline fun <T> SqlCursor.getColumnValueOptional(

core/src/commonMain/kotlin/com/powersync/db/internal/ConnectionContext.kt

@@ -5,8 +5,12 @@ import androidx.sqlite.SQLiteStatement
 import com.powersync.PowerSyncException
 import com.powersync.db.SqlCursor
 import com.powersync.db.StatementBasedCursor
+import kotlin.native.HiddenFromObjC
 
 public interface ConnectionContext {
+    @HiddenFromObjC
+    public val rawConnection: SQLiteConnection
+
     @Throws(PowerSyncException::class)
     public fun execute(
         sql: String,
@@ -35,10 +39,12 @@ public interface ConnectionContext {
     ): RowType
 }
 
-internal class ConnectionContextImplementation(val connection: SQLiteConnection): ConnectionContext {
+internal class ConnectionContextImplementation(
+    override val rawConnection: SQLiteConnection,
+) : ConnectionContext {
     override fun execute(
         sql: String,
-        parameters: List<Any?>?
+        parameters: List<Any?>?,
     ): Long {
         withStatement(sql, parameters) {
             while (it.step()) {
@@ -53,46 +59,47 @@ internal class ConnectionContextImplementation(val connection: SQLiteConnection)
     override fun <RowType : Any> getOptional(
         sql: String,
         parameters: List<Any?>?,
-        mapper: (SqlCursor) -> RowType
-    ): RowType? {
-        return withStatement(sql, parameters) { stmt ->
+        mapper: (SqlCursor) -> RowType,
+    ): RowType? =
+        withStatement(sql, parameters) { stmt ->
             if (stmt.step()) {
                 mapper(StatementBasedCursor(stmt))
             } else {
                 null
             }
         }
-    }
 
     override fun <RowType : Any> getAll(
         sql: String,
         parameters: List<Any?>?,
-        mapper: (SqlCursor) -> RowType
-    ): List<RowType> {
-        return withStatement(sql, parameters) { stmt ->
+        mapper: (SqlCursor) -> RowType,
+    ): List<RowType> =
+        withStatement(sql, parameters) { stmt ->
             buildList {
                 val cursor = StatementBasedCursor(stmt)
                 while (stmt.step()) {
                     add(mapper(cursor))
                 }
             }
         }
-    }
 
     override fun <RowType : Any> get(
         sql: String,
         parameters: List<Any?>?,
-        mapper: (SqlCursor) -> RowType
-    ): RowType {
-        return getOptional(sql, parameters, mapper) ?: throw PowerSyncException("get() called with query that returned no rows", null)
-    }
+        mapper: (SqlCursor) -> RowType,
+    ): RowType = getOptional(sql, parameters, mapper) ?: throw PowerSyncException("get() called with query that returned no rows", null)
 
-    private inline fun <T> withStatement(sql: String, parameters: List<Any?>?, block: (SQLiteStatement) -> T): T {
-        return prepareStmt(sql, parameters).use(block)
-    }
+    private inline fun <T> withStatement(
+        sql: String,
+        parameters: List<Any?>?,
+        block: (SQLiteStatement) -> T,
+    ): T = prepareStmt(sql, parameters).use(block)
 
-    private fun prepareStmt(sql: String, parameters: List<Any?>?): SQLiteStatement {
-        return connection.prepare(sql).apply {
+    private fun prepareStmt(
+        sql: String,
+        parameters: List<Any?>?,
+    ): SQLiteStatement =
+        rawConnection.prepare(sql).apply {
             try {
                 parameters?.forEachIndexed { i, parameter ->
                     // SQLite parameters are 1-indexed
@@ -117,5 +124,4 @@ internal class ConnectionContextImplementation(val connection: SQLiteConnection)
                 throw e
             }
         }
-    }
 }