file rework

Author: krizzu

samples/android/src/main/java/com/asyncstorage/sqlite/android/example/MainActivity.kt

@@ -13,6 +13,7 @@ class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         db = SqliteStorageFactory(this).create("my_db")
+        db.files.size()
         setContent {
             MainScreen(db)
         }

sqlite-storage/src/androidMain/kotlin/org/asyncstorage/sqlitestorage/AndroidDatabaseFile.kt

@@ -2,19 +2,25 @@ package org.asyncstorage.sqlitestorage
 
 import java.io.File
 
-internal class AndroidDatabaseFile(private val dbFile: File) : DatabaseFile {
-    override fun path(): String = dbFile.absolutePath
+internal class AndroidDatabaseFile(private val dbFile: File) : DatabaseFiles {
+    override fun path(type: DatabaseFileType): String = when (type) {
+        DatabaseFileType.Main -> dbFile.absolutePath
+        DatabaseFileType.Wal -> "${dbFile.absolutePath}-wal"
+        DatabaseFileType.Index -> "${dbFile.absolutePath}-shm"
+    }
 
     override fun dirPath(): String = dbFile.parentFile!!.absolutePath
 
     override fun delete(): Boolean {
-        val dbName = dbFile.name
         return try {
-            val parent = dbFile.parentFile!!
             val deleted = mutableListOf<Boolean>()
 
-            listOf(dbName, "$dbName-wal", "$dbName-shm").forEach { dbFile ->
-                deleted += File(parent, dbFile).delete()
+            listOf(
+                path(DatabaseFileType.Main),
+                path(DatabaseFileType.Wal),
+                path(DatabaseFileType.Index)
+            ).forEach { path ->
+                deleted += File(path).delete()
             }
             true
         } catch (e: SecurityException) {
@@ -23,11 +29,12 @@ internal class AndroidDatabaseFile(private val dbFile: File) : DatabaseFile {
         }
     }
 
-    override fun size(): Long {
-        var size = -1L
-        if (dbFile.exists()) {
-            size = (dbFile.length() / 1024L)
+    override fun size(type: DatabaseFileType): Long? {
+        val file = File(path(type))
+        return if (file.exists()) {
+            (dbFile.length() / 1024L)
+        } else {
+            null
         }
-        return size
     }
 }

sqlite-storage/src/androidUnitTest/kotlin/org/asyncstorage/sqlitestorage/DatabaseFileTest.android.kt

@@ -6,7 +6,7 @@ import org.asyncstorage.sqlitestorage.utils.JunitRunner
 import org.junit.Test
 import org.junit.runner.RunWith
 
-internal actual fun createDatabaseFile(name: String): DatabaseFile {
+internal actual fun createDatabaseFile(name: String): DatabaseFiles {
     val ctx: Context = ApplicationProvider.getApplicationContext()
     return AndroidDatabaseFile(ctx.getDatabasePath(name))
 }
@@ -18,9 +18,23 @@ class AndroidDatabaseFileTest {
         val dbName = "testing_my_db.db"
         val file = createDatabaseFile(dbName)
         val dbPath = file.path()
-        val expected = "databases/$dbName"
-        assert(dbPath.endsWith("databases/$dbName")) {
-            "db path not matching, expected: $expected, received: $dbPath"
+
+        with(file.path()) {
+            assert(this.endsWith(dbName)) {
+                "db path not matching, expected: $dbName, received: $this"
+            }
+        }
+
+        with(file.path(DatabaseFileType.Index)) {
+            assert(this.endsWith("${dbName}-shm")) {
+                "index path not matching, expected: ${dbName}-shm, received: $this"
+            }
+        }
+
+        with(file.path(DatabaseFileType.Wal)) {
+            assert(this.endsWith("${dbName}-wal")) {
+                "wal path not matching, expected: ${dbName}-wal, received: $this"
+            }
         }
     }
 }

sqlite-storage/src/commonMain/kotlin/org/asyncstorage/sqlitestorage/DatabaseFile.kt

@@ -0,0 +1,36 @@
+package org.asyncstorage.sqlitestorage
+
+
+// todo: bring implementation to common, rather per platform
+//       requires per platform file access
+interface DatabaseFiles {
+    /**
+     * Returns an absolute path to the selected database file
+     */
+    fun path(type: DatabaseFileType = DatabaseFileType.Main): String
+
+    /**
+     * An absolute path to a directory containing database files
+     */
+    fun dirPath(): String
+
+    /**
+     * Removes the database file and all related WAL files (-wal and -shm).
+     */
+    fun delete(): Boolean
+
+    /**
+     * Returns a size of a selected database file
+     * If the file does not exists or cannot be read for some reason, returns null
+     */
+    fun size(type: DatabaseFileType = DatabaseFileType.Main): Long?
+}
+
+/**
+ * https://www.sqlite.org/walformat.html
+ */
+enum class DatabaseFileType {
+    Main,
+    Wal,
+    Index
+}

sqlite-storage/src/commonMain/kotlin/org/asyncstorage/sqlitestorage/DatabaseFiles.kt

@@ -10,14 +10,13 @@ import kotlinx.coroutines.withContext
 import org.asyncstorage.sqlitestorage.db.AsyncStorageDB
 import org.asyncstorage.sqlitestorage.dispatchers.DispatcherIO
 import org.asyncstorage.sqlitestorage.extensions.executePragmaOptimize
-import org.asyncstorage.sqlitestorage.extensions.executePragmaWalCheckpoint
 import org.asyncstorage.sqlitestorage.models.Entry
 import org.asyncstorage.sqlitestorage.models.Key
 import org.asyncstorage.sqlitestorage.utils.mergePossibleJsonValues
 
 internal class DefaultSqliteStorage(
     private val driver: SqlDriver,
-    private val dbFile: DatabaseFile,
+    override val files: DatabaseFiles,
     private val dispatcher: CoroutineDispatcher = DispatcherIO,
 ) : SqliteStorage {
     private val queries = AsyncStorageDB(driver).async_storage_entriesQueries
@@ -123,18 +122,4 @@ internal class DefaultSqliteStorage(
             driver.executePragmaOptimize()
             driver.close()
         }
-
-    override fun getDbPath() = dbFile.path()
-
-    override suspend fun getDbSize(): Long =
-        withContext(dispatcher) {
-            driver.executePragmaWalCheckpoint()
-            dbFile.size()
-        }
-
-    override suspend fun dropDatabase() =
-        withContext(dispatcher) {
-            driver.close()
-            dbFile.delete()
-        }
 }

sqlite-storage/src/commonMain/kotlin/org/asyncstorage/sqlitestorage/DefaultSqliteStorage.kt

@@ -10,6 +10,12 @@ import org.asyncstorage.sqlitestorage.models.Key
  * The connection is required for any database access action, otherwise an exception is thrown.
  */
 interface SqliteStorage {
+    /**
+     * Access database files related to instance of this SqliteStorage directly
+     * See [DatabaseFiles]
+     */
+    val files: DatabaseFiles
+
     /**
      * Reads a single entry, matching provided key.
      * If entry does not exist in database, Entry will contain `null` value.
@@ -110,38 +116,14 @@ interface SqliteStorage {
      */
     @Throws(Throwable::class)
     suspend fun closeConnection()
-
-    /**
-     * Returns an absolute path to database file on the device.
-     */
-    fun getDbPath(): String
-
-    /**
-     * Returns a size of database file on filesystem, in KB.
-     * If file does not exist, or there's an exception while accessing it, returns -1.
-     * Throws if DB connection is closed.
-     */
-    @Throws(Throwable::class)
-    suspend fun getDbSize(): Long
-
-    /**
-     * Closes current connection to database and removes its file from filesystem.
-     * After this action, this StorageAccess instance should no longer be used.
-     * Returns boolean if file deletion was successful or not.
-     * Throws if DB connection is closed.
-     *
-     * This action is not recoverable.
-     */
-    @Throws(Throwable::class)
-    suspend fun dropDatabase(): Boolean
 }
 
 fun SqliteStorage(
     driver: SqlDriver,
-    dbFile: DatabaseFile,
+    dbFile: DatabaseFiles,
 ): SqliteStorage {
     return DefaultSqliteStorage(
         driver = driver,
-        dbFile = dbFile,
+        files = dbFile,
     )
 }

sqlite-storage/src/commonMain/kotlin/org/asyncstorage/sqlitestorage/SqliteStorage.kt

@@ -7,7 +7,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
-internal expect fun createDatabaseFile(name: String = "Test"): DatabaseFile
+internal expect fun createDatabaseFile(name: String = "Test"): DatabaseFiles
 
 @RunWith(JunitRunner::class)
 class DatabaseFileTest {
@@ -16,7 +16,7 @@ class DatabaseFileTest {
         val dbName = "testing_my_db.db"
         val file = createDatabaseFile(dbName)
         val dbPath = file.dirPath()
-        assertTrue(file.dirPath().endsWith("databases/$dbName"), "db path not matching $dbPath")
+        assertTrue(file.dirPath().endsWith("/databases"), "db path not matching $dbPath")
     }
 
     @Test
@@ -38,6 +38,6 @@ class DatabaseFileTest {
         file.delete()
         assertTrue(!helper.exists(), "db file still exists")
         val size = file.size()
-        assertEquals(-1L, size, "size should be -1, instead: $size")
+        assertEquals(null, size, "size should be null, instead: $size")
     }
 }

sqlite-storage/src/commonTest/kotlin/org/asyncstorage/sqlitestorage/DatabaseFileTest.kt

@@ -28,7 +28,7 @@ class SqliteStorageTest {
         return realRunTest(context = testDispatcher, testBody = {
             val db = createDb()
             testBody(db)
-            db.dropDatabase()
+            db.clear()
         })
     }
 

sqlite-storage/src/commonTest/kotlin/org/asyncstorage/sqlitestorage/SqliteStorageTest.kt

@@ -11,7 +11,7 @@ import platform.Foundation.NSSearchPathForDirectoriesInDomains
 import platform.Foundation.NSUserDomainMask
 import platform.posix.remove
 
-internal class IosDatabaseFile(private val dbName: String) : DatabaseFile {
+internal class IosDatabaseFile(private val dbName: String) : DatabaseFiles {
     /**
      * Main location to store database file is at
      * Application Support/App_Bundle_Id/${MainBundleName or SqliteStorage}/databases
@@ -29,32 +29,38 @@ internal class IosDatabaseFile(private val dbName: String) : DatabaseFile {
         "$docDirectory/$bundleId/databases"
     }
 
-    override fun path(): String = "$dbDir/$dbName"
+    override fun path(type: DatabaseFileType): String =
+        when (type) {
+            DatabaseFileType.Main -> "$dbDir/$dbName"
+            DatabaseFileType.Wal -> "$dbDir/$dbName-wal"
+            DatabaseFileType.Index -> "$dbDir/$dbName-shm"
+        }
 
     override fun dirPath() = dbDir
 
     override fun delete(): Boolean {
         val deleted = mutableListOf<Boolean>()
-        val dbFile = path()
-        listOf(dbFile, "$dbFile-wal", "$dbFile-shm").forEach { file ->
+        listOf(
+            path(DatabaseFileType.Main),
+            path(DatabaseFileType.Wal),
+            path(DatabaseFileType.Index)
+        ).forEach { file ->
             deleted += remove(file) == 0
         }
         return deleted.all { it }
     }
 
-    override fun size(): Long {
-        val file = path()
-        var size = -1L
-        try {
+    override fun size(type: DatabaseFileType): Long? {
+        val file = path(type)
+        return try {
             val attrs = NSFileManager.defaultManager.attributesOfItemAtPath(file, null)
             val fileSize = attrs?.get(NSFileSize) as Long?
-            if (fileSize != null) {
-                size = fileSize / 1024L
+            fileSize?.let {
+                it / 1024L
             }
         } catch (e: Exception) {
-            // potentially means trying to get attributes file that does not exist
+            return null
         }
-        return size
     }
 
     /**