expo-sqlite 12.2.1 → 13.1.0

package/CHANGELOG.md

@@ -10,6 +10,28 @@
 
 ### 💡 Others
 
+## 13.1.0 — 2023-12-13
+
+### 🛠 Breaking changes
+
+- Refactor `expo-sqlite/next` API to be more React idiomatic. ([#25657](https://github.com/expo/expo/pull/25657) by [@kudo](https://github.com/kudo))
+
+## 13.0.0 — 2023-12-12
+
+### 🎉 New features
+
+- Added binary data support to the `expo-sqlite/next` API through the `Uint8Array`. ([#25787](https://github.com/expo/expo/pull/25787) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- Fixed `expo-sqlite/next` crashes when access to finalized statements. ([#25623](https://github.com/expo/expo/pull/25623) by [@kudo](https://github.com/kudo))
+- Fixed `expo-sqlite/next` UTF-8 text issue and `:memory:` database issue. ([#25637](https://github.com/expo/expo/pull/25637) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- [iOS] Replace legacy `FileSystem` interfaces usage with core `FileSystemUtilities`. ([#25495](https://github.com/expo/expo/pull/25495) by [@alanhughes](https://github.com/alanjhughes))
+- Bump C++ compiler setting to C++20. ([#25548](https://github.com/expo/expo/pull/25548) by [@kudo](https://github.com/kudo))
+
 ## 12.2.1 — 2023-11-18
 
 ### 🐛 Bug fixes

package/android/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.4.1)
 project(expo-sqlite)
 
 set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(PACKAGE_NAME "expo-sqlite")
 set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
 

package/android/build.gradle

@@ -4,7 +4,7 @@ apply plugin: 'maven-publish'
 apply plugin: 'de.undercouch.download'
 
 group = 'host.exp.exponent'
-version = '12.2.1'
+version = '13.1.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -106,7 +106,7 @@ android {
   namespace "expo.modules.sqlite"
   defaultConfig {
     versionCode 18
-    versionName "12.2.1"
+    versionName "13.1.0"
 
     externalNativeBuild {
       cmake {

package/android/src/main/cpp/NativeDatabaseBinding.cpp

@@ -49,8 +49,8 @@ int NativeDatabaseBinding::sqlite3_close() {
 }
 
 std::string
-NativeDatabaseBinding::sqlite3_db_filename(const std::string &dbName) {
-  return ::sqlite3_db_filename(db, dbName.c_str());
+NativeDatabaseBinding::sqlite3_db_filename(const std::string &databaseName) {
+  return ::sqlite3_db_filename(db, databaseName.c_str());
 }
 
 int NativeDatabaseBinding::sqlite3_enable_load_extension(int onoff) {
@@ -128,14 +128,14 @@ NativeDatabaseBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
 
 // static
 void NativeDatabaseBinding::OnUpdateHook(void *arg, int action,
-                                         char const *dbName,
+                                         char const *databaseName,
                                          char const *tableName,
                                          sqlite3_int64 rowId) {
   NativeDatabaseBinding *pThis = reinterpret_cast<NativeDatabaseBinding *>(arg);
   static const auto method =
       jni::findClassStatic("expo/modules/sqlite/NativeDatabaseBinding")
           ->getMethod<void(jint, jstring, jstring, jlong)>("onUpdate");
-  method(pThis->javaPart_, action, jni::make_jstring(dbName).get(),
+  method(pThis->javaPart_, action, jni::make_jstring(databaseName).get(),
          jni::make_jstring(tableName).get(), rowId);
 }
 

package/android/src/main/cpp/NativeDatabaseBinding.h

@@ -22,7 +22,7 @@ public:
   // sqlite3 bindings
   int sqlite3_changes();
   int sqlite3_close();
-  std::string sqlite3_db_filename(const std::string &dbName);
+  std::string sqlite3_db_filename(const std::string &databaseName);
   int sqlite3_enable_load_extension(int onoff);
   int sqlite3_exec(const std::string &source);
   int sqlite3_get_autocommit();
@@ -47,7 +47,7 @@ private:
   static jni::local_ref<jhybriddata>
   initHybrid(jni::alias_ref<jhybridobject> jThis);
 
-  static void OnUpdateHook(void *arg, int action, char const *dbName,
+  static void OnUpdateHook(void *arg, int action, char const *databaseName,
                            char const *tableName, sqlite3_int64 rowId);
 
 private:

package/android/src/main/cpp/NativeStatementBinding.cpp

@@ -20,6 +20,8 @@ void NativeStatementBinding::registerNatives() {
       makeNativeMethod("initHybrid", NativeStatementBinding::initHybrid),
       makeNativeMethod("sqlite3_bind_parameter_index",
                        NativeStatementBinding::sqlite3_bind_parameter_index),
+      makeNativeMethod("sqlite3_clear_bindings",
+                       NativeStatementBinding::sqlite3_clear_bindings),
       makeNativeMethod("sqlite3_column_count",
                        NativeStatementBinding::sqlite3_column_count),
       makeNativeMethod("sqlite3_column_name",
@@ -42,6 +44,10 @@ int NativeStatementBinding::sqlite3_bind_parameter_index(
   return ::sqlite3_bind_parameter_index(stmt, name.c_str());
 }
 
+int NativeStatementBinding::sqlite3_clear_bindings() {
+  return ::sqlite3_clear_bindings(stmt);
+}
+
 int NativeStatementBinding::sqlite3_column_count() {
   return ::sqlite3_column_count(stmt);
 }
@@ -60,31 +66,30 @@ int NativeStatementBinding::sqlite3_step() { return ::sqlite3_step(stmt); }
 
 int NativeStatementBinding::bindStatementParam(
     int index, jni::alias_ref<jni::JObject> param) {
-  static const auto integerClass = jni::JInteger::javaClassStatic();
-  static const auto longClass = jni::JLong::javaClassStatic();
-  static const auto doubleClass = jni::JDouble::javaClassStatic();
-  static const auto stringClass = jni::JString::javaClassStatic();
-  static const auto booleanClass = jni::JBoolean::javaClassStatic();
-
   int ret = -1;
   if (param == nullptr) {
     ret = sqlite3_bind_null(stmt, index);
-  } else if (param->isInstanceOf(integerClass)) {
+  } else if (param->isInstanceOf(jni::JInteger::javaClassStatic())) {
     ret = sqlite3_bind_int(stmt, index,
                            jni::static_ref_cast<jni::JInteger>(param)->value());
-  } else if (param->isInstanceOf(longClass)) {
+  } else if (param->isInstanceOf(jni::JLong::javaClassStatic())) {
     ret = sqlite3_bind_int64(stmt, index,
                              jni::static_ref_cast<jni::JLong>(param)->value());
-  } else if (param->isInstanceOf(doubleClass)) {
+  } else if (param->isInstanceOf(jni::JDouble::javaClassStatic())) {
     ret = sqlite3_bind_double(
         stmt, index, jni::static_ref_cast<jni::JDouble>(param)->value());
-  } else if (param->isInstanceOf(booleanClass)) {
+  } else if (param->isInstanceOf(jni::JBoolean::javaClassStatic())) {
     ret = sqlite3_bind_int(
         stmt, index,
         jni::static_ref_cast<jni::JBoolean>(param)->value() ? 1 : 0);
+  } else if (param->isInstanceOf(jni::JArrayByte::javaClassStatic())) {
+    auto byteArray = jni::static_ref_cast<jni::JArrayByte>(param);
+    auto data = byteArray->getRegion(0, byteArray->size());
+    ret = sqlite3_bind_blob(stmt, index, data.get(), byteArray->size(),
+                            SQLITE_TRANSIENT);
   } else {
     std::string stringArg;
-    if (param->isInstanceOf(stringClass)) {
+    if (param->isInstanceOf(jni::JString::javaClassStatic())) {
       stringArg = jni::static_ref_cast<jni::JString>(param)->toStdString();
     } else {
       stringArg = param->toString();
@@ -137,10 +142,12 @@ jni::local_ref<jni::JObject> NativeStatementBinding::getColumnValue(int index) {
     return jni::make_jstring(text);
   }
   case SQLITE_BLOB: {
-    JNIEnv *env = jni::Environment::current();
-    return jni::adopt_local(env->NewString(
-        reinterpret_cast<const jchar *>(sqlite3_column_blob(stmt, index)),
-        static_cast<size_t>(sqlite3_column_bytes(stmt, index))));
+    size_t length = static_cast<size_t>(sqlite3_column_bytes(stmt, index));
+    auto byteArray = jni::JArrayByte::newArray(length);
+    byteArray->setRegion(
+        0, length,
+        static_cast<const signed char *>(sqlite3_column_blob(stmt, index)));
+    return byteArray;
   }
   case SQLITE_NULL: {
     return nullptr;

package/android/src/main/cpp/NativeStatementBinding.h

@@ -22,6 +22,7 @@ public:
 
   // sqlite3 bindings
   int sqlite3_bind_parameter_index(const std::string &name);
+  int sqlite3_clear_bindings();
   int sqlite3_column_count();
   std::string sqlite3_column_name(int index);
   int sqlite3_finalize();

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

@@ -4,7 +4,9 @@ package expo.modules.sqlite
 
 import expo.modules.kotlin.sharedobjects.SharedRef
 
-internal class NativeDatabase(val dbName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
+internal class NativeDatabase(val databaseName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
+  var isClosed = false
+
   override fun equals(other: Any?): Boolean {
     return other is NativeDatabase && this.ref == other.ref
   }

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

@@ -5,7 +5,7 @@ package expo.modules.sqlite
 import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
 
-private typealias UpdateListener = (dbName: String, tableName: String, operationType: Int, rowID: Long) -> Unit
+private typealias UpdateListener = (databaseName: String, tableName: String, operationType: Int, rowID: Long) -> Unit
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
@@ -39,7 +39,7 @@ internal class NativeDatabaseBinding {
 
   external fun sqlite3_changes(): Int
   external fun sqlite3_close(): Int
-  external fun sqlite3_db_filename(dbName: String): String
+  external fun sqlite3_db_filename(databaseName: String): String
   external fun sqlite3_enable_load_extension(onoff: Int): Int
   external fun sqlite3_exec(source: String): Int
   external fun sqlite3_get_autocommit(): Int
@@ -59,8 +59,8 @@ internal class NativeDatabaseBinding {
 
   @Suppress("unused")
   @DoNotStrip
-  private fun onUpdate(action: Int, dbName: String, tableName: String, rowId: Long) {
-    mUpdateListener?.invoke(dbName, tableName, action, rowId)
+  private fun onUpdate(action: Int, databaseName: String, tableName: String, rowId: Long) {
+    mUpdateListener?.invoke(databaseName, tableName, action, rowId)
   }
 
   // endregion

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

@@ -5,6 +5,8 @@ package expo.modules.sqlite
 import expo.modules.kotlin.sharedobjects.SharedRef
 
 internal class NativeStatement : SharedRef<NativeStatementBinding>(NativeStatementBinding()) {
+  var isFinalized = false
+
   override fun equals(other: Any?): Boolean {
     return other is NativeStatement && this.ref == other.ref
   }

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

@@ -5,8 +5,8 @@ package expo.modules.sqlite
 import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
 
-internal typealias ColumnNames = ArrayList<String>
-internal typealias ColumnValues = ArrayList<Any>
+internal typealias SQLiteColumnNames = ArrayList<String>
+internal typealias SQLiteColumnValues = ArrayList<Any>
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
@@ -21,6 +21,7 @@ internal class NativeStatementBinding {
   // region sqlite3 bindings
 
   external fun sqlite3_bind_parameter_index(name: String): Int
+  external fun sqlite3_clear_bindings(): Int
   external fun sqlite3_column_count(): Int
   external fun sqlite3_column_name(index: Int): String
   external fun sqlite3_finalize(): Int
@@ -28,8 +29,8 @@ internal class NativeStatementBinding {
   external fun sqlite3_step(): Int
 
   external fun bindStatementParam(index: Int, param: Any): Int
-  external fun getColumnNames(): ColumnNames
-  external fun getColumnValues(): ColumnValues
+  external fun getColumnNames(): SQLiteColumnNames
+  external fun getColumnValues(): SQLiteColumnValues
 
   // endregion
 

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

@@ -24,3 +24,9 @@ internal class SQLiteErrorException(message: String) :
 @DoNotStrip
 internal class InvalidConvertibleException(message: String) :
   CodedException(message)
+
+internal class AccessClosedResourceException :
+  CodedException("Access to closed resource")
+
+internal class InvalidBindParameterException :
+  CodedException("Invalid bind parameter")

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

@@ -19,36 +19,36 @@ class SQLiteModule : Module() {
   override fun definition() = ModuleDefinition {
     Name("ExpoSQLite")
 
-    AsyncFunction("exec") { dbName: String, queries: List<Query>, readOnly: Boolean ->
-      return@AsyncFunction execute(dbName, queries, readOnly)
+    AsyncFunction("exec") { databaseName: String, queries: List<Query>, readOnly: Boolean ->
+      return@AsyncFunction execute(databaseName, queries, readOnly)
     }
 
-    AsyncFunction("execRawQuery") { dbName: String, queries: List<Query>, readOnly: Boolean ->
-      return@AsyncFunction execute(dbName, queries, readOnly)
+    AsyncFunction("execRawQuery") { databaseName: String, queries: List<Query>, readOnly: Boolean ->
+      return@AsyncFunction execute(databaseName, queries, readOnly)
     }
 
-    AsyncFunction("close") { dbName: String ->
+    AsyncFunction("close") { databaseName: String ->
       cachedDatabase
-        .remove(dbName)
+        .remove(databaseName)
         ?.sqlite3_close()
     }
 
-    Function("closeSync") { dbName: String ->
+    Function("closeSync") { databaseName: String ->
       cachedDatabase
-        .remove(dbName)
+        .remove(databaseName)
         ?.sqlite3_close()
     }
 
-    AsyncFunction("deleteAsync") { dbName: String ->
-      if (cachedDatabase[dbName] != null) {
-        throw DeleteDatabaseException(dbName)
+    AsyncFunction("deleteAsync") { databaseName: String ->
+      if (cachedDatabase[databaseName] != null) {
+        throw DeleteDatabaseException(databaseName)
       }
-      val dbFile = File(pathForDatabaseName(dbName))
+      val dbFile = File(pathForDatabaseName(databaseName))
       if (!dbFile.exists()) {
-        throw DatabaseNotFoundException(dbName)
+        throw DatabaseNotFoundException(databaseName)
       }
       if (!dbFile.delete()) {
-        throw DeleteDatabaseFileException(dbName)
+        throw DeleteDatabaseFileException(databaseName)
       }
     }
 
@@ -66,28 +66,28 @@ class SQLiteModule : Module() {
     return "$directory${File.separator}$name"
   }
 
-  private fun openDatabase(dbName: String): SQLite3Wrapper? {
+  private fun openDatabase(databaseName: String): SQLite3Wrapper? {
     val path: String
     try {
-      path = pathForDatabaseName(dbName)
+      path = pathForDatabaseName(databaseName)
     } catch (_: IOException) {
       return null
     }
 
     if (File(path).exists()) {
-      cachedDatabase[dbName]?.let {
+      cachedDatabase[databaseName]?.let {
         return it
       }
     }
 
-    cachedDatabase.remove(dbName)
+    cachedDatabase.remove(databaseName)
     val db = SQLite3Wrapper.open(path) ?: return null
-    cachedDatabase[dbName] = db
+    cachedDatabase[databaseName] = db
     return db
   }
 
-  private fun execute(dbName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
-    val db = openDatabase(dbName) ?: throw OpenDatabaseException(dbName)
+  private fun execute(databaseName: String, queries: List<Query>, readOnly: Boolean): List<Any> {
+    val db = openDatabase(databaseName) ?: throw OpenDatabaseException(databaseName)
     return queries.map { db.executeSql(it.sql, it.args, readOnly) }
   }