expo-sqlite 11.7.1 → 12.0.0

package/android/src/main/java/expo/modules/sqlite/SQLiteHelpers.kt

@@ -22,82 +22,3 @@ internal fun ensureDirExists(dir: File): File {
   }
   return dir
 }
-
-internal fun pluginResultsToPrimitiveData(results: List<SQLiteModule.SQLitePluginResult>): List<Any> {
-  return results.map { convertPluginResultToArray(it) }
-}
-
-private fun convertPluginResultToArray(result: SQLiteModule.SQLitePluginResult): List<Any?> {
-  val rowsContent = result.rows.map { row ->
-    row.map { value ->
-      when (value) {
-        null -> null
-        is String -> value
-        is Boolean -> value
-        else -> (value as Number).toDouble()
-      }
-    }
-  }
-
-  return arrayListOf(
-    result.error?.message,
-    result.insertId.toInt(),
-    result.rowsAffected,
-    result.columns,
-    rowsContent
-  )
-}
-
-private fun isPragma(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "pragma")
-}
-
-private fun isSelectCTE(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "with") && containsCaseInsensitive(str, "select")
-}
-
-private fun isPragmaReadOnly(str: String): Boolean {
-  return isPragma(str) && !str.contains('=')
-}
-
-internal fun isSelect(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "select") || isSelectCTE(str) || isPragmaReadOnly(str)
-}
-
-internal fun isInsert(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "insert")
-}
-
-internal fun isUpdate(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "update")
-}
-
-internal fun isDelete(str: String): Boolean {
-  return startsWithCaseInsensitive(str, "delete")
-}
-
-private fun startsWithCaseInsensitive(str: String, substr: String): Boolean {
-  return str.trimStart().startsWith(substr, true)
-}
-
-private fun containsCaseInsensitive(str: String, substr: String): Boolean {
-  return str.trimStart().contains(substr, true)
-}
-
-internal fun convertParamsToStringArray(paramArrayArg: List<Any?>): Array<String?> {
-  return paramArrayArg.map { param ->
-    when (param) {
-      is String -> unescapeBlob(param)
-      is Boolean -> if (param) "1" else "0"
-      is Double -> param.toString()
-      null -> null
-      else -> throw ClassCastException("Could not find proper SQLite data type for argument: $")
-    }
-  }.toTypedArray()
-}
-
-private fun unescapeBlob(str: String): String {
-  return str.replace("\u0001\u0001", "\u0000")
-    .replace("\u0001\u0002", "\u0001")
-    .replace("\u0002\u0002", "\u0002")
-}

package/android/src/main/java/expo/modules/sqlite/SQLiteModule.kt

@@ -2,237 +2,63 @@
 package expo.modules.sqlite
 
 import android.content.Context
-import android.database.Cursor
-import androidx.core.os.bundleOf
+import androidx.collection.ArrayMap
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import io.expo.android.database.sqlite.SQLiteCustomExtension
-import io.expo.android.database.sqlite.SQLiteDatabase
-import io.expo.android.database.sqlite.SQLiteDatabaseConfiguration
 import java.io.File
 import java.io.IOException
 import java.util.*
 
-private val EMPTY_ROWS = emptyArray<Array<Any?>>()
-private val EMPTY_COLUMNS = emptyArray<String?>()
-private val EMPTY_RESULT = SQLiteModule.SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, null)
-private val DATABASES: MutableMap<String, SQLiteDatabase?> = HashMap()
-
 class SQLiteModule : Module() {
+  private val cachedDatabase = ArrayMap<String, SQLite3Wrapper>()
+
   private val context: Context
     get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
 
   override fun definition() = ModuleDefinition {
     Name("ExpoSQLite")
 
-    Events("onDatabaseChange")
-
     AsyncFunction("exec") { dbName: String, queries: List<Query>, readOnly: Boolean ->
       return@AsyncFunction execute(dbName, queries, readOnly)
     }
 
     AsyncFunction("execRawQuery") { dbName: String, queries: List<Query>, readOnly: Boolean ->
-      return@AsyncFunction execute(dbName, queries, readOnly, raw = true)
+      return@AsyncFunction execute(dbName, queries, readOnly)
     }
 
     AsyncFunction("close") { dbName: String ->
-      DATABASES
+      cachedDatabase
         .remove(dbName)
-        ?.close()
+        ?.sqlite3_close()
     }
 
     Function("closeSync") { dbName: String ->
-      DATABASES
+      cachedDatabase
         .remove(dbName)
-        ?.close()
+        ?.sqlite3_close()
     }
 
     AsyncFunction("deleteAsync") { dbName: String ->
-      if (DATABASES.containsKey(dbName)) {
-        throw OpenDatabaseException(dbName)
+      if (cachedDatabase[dbName] != null) {
+        throw DeleteDatabaseException(dbName)
       }
       val dbFile = File(pathForDatabaseName(dbName))
       if (!dbFile.exists()) {
         throw DatabaseNotFoundException(dbName)
       }
       if (!dbFile.delete()) {
-        throw DeleteDatabaseException(dbName)
+        throw DeleteDatabaseFileException(dbName)
       }
     }
 
     OnDestroy {
-      DATABASES.values.forEach {
-        it?.rawQuery("SELECT crsql_finalize()", emptyArray())
-      }
-    }
-  }
-
-  private fun execute(dbName: String, queries: List<Query>, readOnly: Boolean, raw: Boolean = false): List<Any> {
-    val db = getDatabase(dbName)
-    val results = queries.map { sqlQuery ->
-      val sql = sqlQuery.sql
-      val bindArgs = convertParamsToStringArray(sqlQuery.args)
-      try {
-        if (isSelect(sql)) {
-          doSelectInBackgroundAndPossiblyThrow(sql, bindArgs, db)
-        } else { // update/insert/delete
-          if (readOnly) {
-            SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, ReadOnlyException())
-          } else {
-            if (raw) {
-              doRawUpdate(sql, bindArgs, db)
-            } else {
-              doUpdateInBackgroundAndPossiblyThrow(sql, bindArgs, db)
-            }
-          }
-        }
-      } catch (e: Throwable) {
-        SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, 0, 0, e)
-      }
-    }
-    return pluginResultsToPrimitiveData(results)
-  }
-
-  // do a update/delete/insert operation
-  private fun doUpdateInBackgroundAndPossiblyThrow(
-    sql: String,
-    bindArgs: Array<String?>?,
-    db: SQLiteDatabase
-  ): SQLitePluginResult {
-    return db.compileStatement(sql).use { statement ->
-      if (bindArgs != null) {
-        for (i in bindArgs.size downTo 1) {
-          val args = bindArgs[i - 1]
-          if (args != null) {
-            statement.bindString(i, args)
-          } else {
-            statement.bindNull(i)
-          }
-        }
-      }
-      if (isInsert(sql)) {
-        val insertId = statement.executeInsert()
-        val rowsAffected = if (insertId >= 0) 1 else 0
-        SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, rowsAffected, insertId, null)
-      } else if (isDelete(sql) || isUpdate(sql)) {
-        val rowsAffected = statement.executeUpdateDelete()
-        SQLitePluginResult(EMPTY_ROWS, EMPTY_COLUMNS, rowsAffected, 0, null)
-      } else {
-        // in this case, we don't need rowsAffected or insertId, so we can have a slight
-        // perf boost by just executing the query
-        statement.execute()
-        EMPTY_RESULT
-      }
-    }
-  }
-
-  private fun doRawUpdate(
-    sql: String,
-    bindArgs: Array<String?>,
-    db: SQLiteDatabase
-  ): SQLitePluginResult {
-    return db.rawQuery(sql, bindArgs).use { cursor ->
-      val numRows = cursor.count
-      if (numRows == 0) {
-        return EMPTY_RESULT
-      }
-
-      val numColumns = cursor.columnCount
-      val columnNames = cursor.columnNames
-      val rows: Array<Array<Any?>> = Array(numRows) { arrayOfNulls(numColumns) }
-      var i = 0
-      while (cursor.moveToNext()) {
-        val row = rows[i]
-        for (j in 0 until numColumns) {
-          row[j] = getValueFromCursor(cursor, j, cursor.getType(j))
-        }
-        rows[i] = row
-        i++
-      }
-
-      if (isInsert(sql)) {
-        val rowsAffected = getRowsAffected(db)
-        val insertId = getInsertId(db)
-        SQLitePluginResult(rows, columnNames, rowsAffected, insertId, null)
-      } else if (isDelete(sql) || isUpdate(sql)) {
-        val rowsAffected = getRowsAffected(db)
-        SQLitePluginResult(rows, columnNames, rowsAffected, 0, null)
-      } else {
-        EMPTY_RESULT
+      cachedDatabase.values.forEach {
+        it.sqlite3_close()
       }
     }
   }
 
-  private fun getRowsAffected(
-    db: SQLiteDatabase,
-  ): Int {
-    val cursor = db.rawQuery("SELECT changes() AS numRowsAffected", null)
-    val rowsAffected = if (cursor.moveToFirst()) {
-      val index = cursor.getColumnIndex("numRowsAffected")
-      cursor.getInt(index)
-    } else {
-      -1
-    }
-    cursor.close()
-    return rowsAffected
-  }
-
-  private fun getInsertId(
-    db: SQLiteDatabase,
-  ): Long {
-    val cursor = db.rawQuery("SELECT last_insert_rowid() AS insertId", null)
-    val insertId = if (cursor.moveToFirst()) {
-      val index = cursor.getColumnIndex("insertId")
-      cursor.getLong(index)
-    } else {
-      -1
-    }
-    cursor.close()
-    return insertId
-  }
-
-  // do a select operation
-  private fun doSelectInBackgroundAndPossiblyThrow(
-    sql: String,
-    bindArgs: Array<String?>,
-    db: SQLiteDatabase
-  ): SQLitePluginResult {
-    return db.rawQuery(sql, bindArgs).use { cursor ->
-      val numRows = cursor.count
-      if (numRows == 0) {
-        return EMPTY_RESULT
-      }
-      val numColumns = cursor.columnCount
-      val columnNames = cursor.columnNames
-      val rows: Array<Array<Any?>> = Array(numRows) { arrayOfNulls(numColumns) }
-      var i = 0
-      while (cursor.moveToNext()) {
-        val row = rows[i]
-        for (j in 0 until numColumns) {
-          row[j] = getValueFromCursor(cursor, j, cursor.getType(j))
-        }
-        rows[i] = row
-        i++
-      }
-      SQLitePluginResult(rows, columnNames, 0, 0, null)
-    }
-  }
-
-  private fun getValueFromCursor(cursor: Cursor, index: Int, columnType: Int): Any? {
-    return when (columnType) {
-      Cursor.FIELD_TYPE_FLOAT -> cursor.getDouble(index)
-      Cursor.FIELD_TYPE_INTEGER -> cursor.getLong(index)
-      Cursor.FIELD_TYPE_BLOB ->
-        // convert byte[] to binary string; it's good enough, because
-        // WebSQL doesn't support blobs anyway
-        String(cursor.getBlob(index))
-
-      Cursor.FIELD_TYPE_STRING -> cursor.getString(index)
-      else -> null
-    }
-  }
-
   @Throws(IOException::class)
   private fun pathForDatabaseName(name: String): String {
     val directory = File("${context.filesDir}${File.separator}SQLite")
@@ -240,44 +66,29 @@ class SQLiteModule : Module() {
     return "$directory${File.separator}$name"
   }
 
-  @Throws(IOException::class)
-  private fun getDatabase(name: String): SQLiteDatabase {
-    var database: SQLiteDatabase? = null
-    val path = pathForDatabaseName(name)
-    if (File(path).exists()) {
-      database = DATABASES[name]
+  private fun openDatabase(dbName: String): SQLite3Wrapper? {
+    val path: String
+    try {
+      path = pathForDatabaseName(dbName)
+    } catch (_: IOException) {
+      return null
     }
-    if (database == null) {
-      DATABASES.remove(name)
-      val config = createConfig(path)
-      database = SQLiteDatabase.openDatabase(config, null, null)
-      addUpdateListener(database)
-      DATABASES[name] = database
+
+    if (File(path).exists()) {
+      cachedDatabase[dbName]?.let {
+        return it
+      }
     }
-    return database!!
-  }
 
-  private fun createConfig(path: String): SQLiteDatabaseConfiguration {
-    val crsqliteExtension = SQLiteCustomExtension("libcrsqlite", "sqlite3_crsqlite_init")
-    return SQLiteDatabaseConfiguration(path, SQLiteDatabase.CREATE_IF_NECESSARY, emptyList(), emptyList(), listOf(crsqliteExtension))
+    cachedDatabase.remove(dbName)
+    val db = SQLite3Wrapper.open(path) ?: return null
+    cachedDatabase[dbName] = db
+    return db
   }
 
-  private fun addUpdateListener(database: SQLiteDatabase?) {
-    database?.addUpdateListener { tableName: String, operationType: Int, rowID: Int ->
-      sendEvent(
-        "onDatabaseChange",
-        bundleOf(
-          "tableName" to tableName,
-          "rowId" to rowID,
-          "typeId" to when (operationType) {
-            9 -> SqlAction.DELETE.value
-            18 -> SqlAction.INSERT.value
-            23 -> SqlAction.UPDATE.value
-            else -> SqlAction.UNKNOWN.value
-          }
-        )
-      )
-    }
+  private fun execute(dbName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
+    val db = openDatabase(dbName) ?: throw OpenDatabaseException(dbName)
+    return queries.map { db.executeSql(it.sql, it.args, readOnly) }
   }
 
   internal class SQLitePluginResult(
@@ -287,6 +98,4 @@ class SQLiteModule : Module() {
     val insertId: Long,
     val error: Throwable?
   )
-
-  private class ReadOnlyException : Exception("could not prepare statement (23 not authorized)")
 }