0.5.0-SNAPSHOT

Author: kpgalligan

SQLiter/gradle.properties

@@ -17,7 +17,7 @@
 kotlin.code.style=official
 
 GROUP=co.touchlab
-VERSION_NAME=0.4.3-SNAPSHOT
+VERSION_NAME=0.5.0-SNAPSHOT
 
 STATELY_VERSION=0.4.0-SNAPSHOT
 KOTLIN_VERSION=1.3.10

SQLiter/src/commonMain/kotlin/co/touchlab/sqliter/DatabaseManager.kt

@@ -17,15 +17,26 @@
 package co.touchlab.sqliter
 
 interface DatabaseManager{
-    fun createConnection():DatabaseConnection
+    /**
+     * Create a connection with locked access to the underlying sqlite instance. Use this
+     * in most cases.
+     */
+    fun createMultiThreadedConnection():DatabaseConnection
+
+    /**
+     * Create a connection without locked access to the underlying sqlite instance. Use this only
+     * if you are absolutely sure you're only accessing from one thread. It will proactively fail
+     * if you are attempting otherwise. Performance is better, but marginally so.
+     */
+    fun createSingleThreadedConnection():DatabaseConnection
     val configuration:DatabaseConfiguration
 }
 
 //expect fun createDatabaseManager(configuration: DatabaseConfiguration):DatabaseManager
 //expect fun deleteDatabase(name:String)
 
 fun <R> DatabaseManager.withConnection(block:(DatabaseConnection) -> R):R{
-    val connection = createConnection()
+    val connection = createMultiThreadedConnection()
     try {
         return block(connection)
     }finally {

SQLiter/src/commonMain/kotlin/co/touchlab/sqliter/concurrency/ConcurrentDatabaseConnection.kt

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2018 Touchlab, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package co.touchlab.sqliter.concurrency
+
+import co.touchlab.sqliter.Cursor
+import co.touchlab.sqliter.DatabaseConnection
+import co.touchlab.sqliter.FieldType
+import co.touchlab.sqliter.Statement
+import co.touchlab.stately.concurrency.ReentrantLock
+import co.touchlab.stately.concurrency.withLock
+
+class ConcurrentDatabaseConnection(private val delegateConnection:DatabaseConnection):DatabaseConnection{
+    private val accessLock = ReentrantLock()
+
+    override fun createStatement(sql: String): Statement = accessLock.withLock { ConcurrentStatement(delegateConnection.createStatement(sql)) }
+
+    override fun beginTransaction() = accessLock.withLock { delegateConnection.beginTransaction() }
+
+    override fun setTransactionSuccessful() = accessLock.withLock { delegateConnection.setTransactionSuccessful() }
+
+    override fun endTransaction() = accessLock.withLock { delegateConnection.endTransaction() }
+
+    override fun close() = accessLock.withLock { delegateConnection.close() }
+
+    override val closed: Boolean
+        get() = accessLock.withLock { delegateConnection.closed }
+
+    inner class ConcurrentCursor(private val delegateCursor: Cursor):Cursor{
+        override fun next(): Boolean = accessLock.withLock { delegateCursor.next() }
+
+        override fun isNull(index: Int): Boolean = accessLock.withLock { delegateCursor.isNull(index) }
+
+        override fun getString(index: Int): String = accessLock.withLock { delegateCursor.getString(index) }
+
+        override fun getLong(index: Int): Long = accessLock.withLock { delegateCursor.getLong(index) }
+
+        override fun getBytes(index: Int): ByteArray = accessLock.withLock { delegateCursor.getBytes(index) }
+
+        override fun getDouble(index: Int): Double = accessLock.withLock { delegateCursor.getDouble(index) }
+
+        override fun getType(index: Int): FieldType = accessLock.withLock { delegateCursor.getType(index) }
+
+        override val columnCount: Int
+            get() = accessLock.withLock { delegateCursor.columnCount }
+
+        override fun columnName(index: Int): String = accessLock.withLock { delegateCursor.columnName(index) }
+
+        override val columnNames: Map<String, Int>
+            get() = accessLock.withLock { delegateCursor.columnNames }
+        override val statement: Statement
+            get() = accessLock.withLock { delegateCursor.statement }
+
+    }
+
+    inner class ConcurrentStatement(private val delegateStatement:Statement):Statement{
+        override fun execute() = accessLock.withLock { delegateStatement.execute() }
+
+        override fun executeInsert(): Long = accessLock.withLock { delegateStatement.executeInsert() }
+
+        override fun executeUpdateDelete(): Int = accessLock.withLock { delegateStatement.executeUpdateDelete() }
+
+        override fun query(): Cursor = accessLock.withLock { ConcurrentCursor(delegateStatement.query()) }
+
+        override fun finalizeStatement() = accessLock.withLock { delegateStatement.finalizeStatement() }
+
+        override fun resetStatement() = accessLock.withLock { delegateStatement.resetStatement() }
+
+        override fun clearBindings() = accessLock.withLock { delegateStatement.clearBindings() }
+
+        override fun bindNull(index: Int) = accessLock.withLock { delegateStatement.bindNull(index) }
+
+        override fun bindLong(index: Int, value: Long) = accessLock.withLock { delegateStatement.bindLong(index, value) }
+
+        override fun bindDouble(index: Int, value: Double) = accessLock.withLock { delegateStatement.bindDouble(index, value) }
+
+        override fun bindString(index: Int, value: String) = accessLock.withLock { delegateStatement.bindString(index, value) }
+
+        override fun bindBlob(index: Int, value: ByteArray) = accessLock.withLock { delegateStatement.bindBlob(index, value) }
+
+        override fun bindParameterIndex(paramName: String): Int = accessLock.withLock { delegateStatement.bindParameterIndex(paramName) }
+    }
+}

SQLiter/src/commonMain/kotlin/co/touchlab/sqliter/concurrency/SingleThreadDatabaseConnection.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2018 Touchlab, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package co.touchlab.sqliter.concurrency
+
+import co.touchlab.sqliter.DatabaseConnection
+import co.touchlab.stately.ensureNeverFrozen
+
+class SingleThreadDatabaseConnection(delegateConnection: DatabaseConnection):DatabaseConnection by delegateConnection
+{
+    init {
+        ensureNeverFrozen()
+    }
+}

SQLiter/src/nativeCommonMain/kotlin/co/touchlab/sqliter/NativeDatabaseManager.kt

@@ -16,12 +16,23 @@
 
 package co.touchlab.sqliter
 
+import co.touchlab.sqliter.concurrency.ConcurrentDatabaseConnection
+import co.touchlab.sqliter.concurrency.SingleThreadDatabaseConnection
 import platform.Foundation.NSLock
 import kotlin.native.concurrent.AtomicInt
+import kotlin.native.concurrent.freeze
 
 class NativeDatabaseManager(private val path:String,
                             override val configuration: DatabaseConfiguration
                             ):DatabaseManager{
+    override fun createMultiThreadedConnection(): DatabaseConnection {
+        return ConcurrentDatabaseConnection(createConnection()).freeze()
+    }
+
+    override fun createSingleThreadedConnection(): DatabaseConnection {
+        return SingleThreadDatabaseConnection(createConnection())
+    }
+
     val lock = NSLock()
 
     companion object {
@@ -30,7 +41,7 @@ class NativeDatabaseManager(private val path:String,
 
     internal val connectionCount = AtomicInt(0)
 
-    override fun createConnection(): DatabaseConnection {
+    private fun createConnection(): DatabaseConnection {
         lock.lock()
 
         try {

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/BasicTest.kt

@@ -26,7 +26,7 @@ class BasicTest{
     @Test
     fun createTable(){
         basicTestDb {manager ->
-            val connection = manager.createConnection()
+            val connection = manager.createSingleThreadedConnection()
             val start = getTimeMillis()
             connection.withTransaction {
                 val statement = it.createStatement("INSERT INTO test VALUES (?, ?, ?, ?)")

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/CursorTest.kt

@@ -16,8 +16,6 @@
 
 package co.touchlab.sqliter
 
-import kotlin.test.AfterEach
-import kotlin.test.BeforeEach
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -31,7 +29,7 @@ class CursorTest:BaseDatabaseTest(){
                 }
             }))
 
-        val connection = manager.createConnection()
+        val connection = manager.surpriseMeConnection()
         connection.withStatement("insert into test(num, str)values(?,?)"){
             bindLong(1, 2)
             bindString(2, "asdf")

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/DatabaseConfigurationTest.kt

@@ -62,7 +62,7 @@ class DatabaseConfigurationTest : BaseDatabaseTest(){
                 }
             }))
 
-        val conn = manager.createConnection()
+        val conn = manager.surpriseMeConnection()
         println("tr 0")
         assertEquals(conn.journalMode, JournalMode.WAL)
         println("tr 1")
@@ -86,7 +86,7 @@ class DatabaseConfigurationTest : BaseDatabaseTest(){
                 fail("Same version shouldn't run")
             }))
 
-        val conn2 = manager2.createConnection()
+        val conn2 = manager2.surpriseMeConnection()
         assertEquals(conn2.journalMode, JournalMode.WAL)
         conn2.close()
     }

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/DatabaseConnectionTest.kt

@@ -246,7 +246,7 @@ class DatabaseConnectionTest {
             )
         )
 
-        val conn1 = man.createConnection()
+        val conn1 = man.surpriseMeConnection()
 
         conn1.withTransaction {
                 it.withStatement("insert into test(num, str)values(?,?)") {
@@ -258,7 +258,7 @@ class DatabaseConnectionTest {
 
         assertEquals(1, conn1.longForQuery("select count(*) from test"))
 
-        val conn2 = man.createConnection()
+        val conn2 = man.surpriseMeConnection()
         conn2.withTransaction {
             it.withStatement("insert into test(num, str)values(?,?)") {
                 bindLong(1, 232)
@@ -283,7 +283,7 @@ class DatabaseConnectionTest {
     @Test
     fun closed(){
         basicTestDb(TWO_COL) {
-            val conn = it.createConnection()
+            val conn = it.surpriseMeConnection()
             assertFalse(conn.closed)
             conn.close()
             assertTrue(conn.closed)

SQLiter/src/nativeCommonTest/kotlin/co/touchlab/sqliter/DatabaseManagerTest.kt

@@ -23,7 +23,7 @@ class DatabaseManagerTest : BaseDatabaseTest(){
     @Test
     fun connectionCount(){
         basicTestDb {man ->
-            val conn = man.createConnection()
+            val conn = man.surpriseMeConnection()
             assertEquals(1, countLiveConnections(man))
             man.withConnection {
                 assertEquals(2, countLiveConnections(man))