expo-sqlite 11.7.0 → 11.8.0

package/CHANGELOG.md

@@ -10,6 +10,26 @@
 
 ### 💡 Others
 
+## 11.8.0 — 2023-10-17
+
+### 🛠 Breaking changes
+
+- Dropped support for Android SDK 21 and 22. ([#24201](https://github.com/expo/expo/pull/24201) by [@behenate](https://github.com/behenate))
+
+### 🎉 New features
+
+- [Android] Rewrite implementations from low-level SQLite bindings. ([#24730](https://github.com/expo/expo/pull/24730) by [@kudo](https://github.com/kudo))
+
+## 11.7.1 — 2023-09-18
+
+### 🐛 Bug fixes
+
+- Fix broken JS test. ([#24498](https://github.com/expo/expo/pull/24498) by [@alanjhughes](https://github.com/alanjhughes))
+
+### 💡 Others
+
+- [iOS] Bump `SQLite`version to latest. ([#24375](https://github.com/expo/expo/pull/24375) by [@alanjhughes](https://github.com/alanjhughes))
+
 ## 11.7.0 — 2023-09-15
 
 ### 🐛 Bug fixes
@@ -21,6 +41,7 @@
 ### 🎉 New features
 
 - Add support for running raw queries on Android. ([#24320](https://github.com/expo/expo/pull/24320) by [@alanjhughes](https://github.com/alanjhughes))
+- On Android, add support for `CRSQLite`. ([#24322](https://github.com/expo/expo/pull/24322) by [@alanjhughes](https://github.com/alanjhughes))
 
 ### 🐛 Bug fixes
 

package/android/CMakeLists.txt

@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.4.1)
+
+project(expo-sqlite)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 17)
+set(PACKAGE_NAME "expo-sqlite")
+set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
+
+set(SRC_DIR "${CMAKE_SOURCE_DIR}/src/main/cpp")
+file(GLOB SOURCES "${SRC_DIR}/*.cpp")
+
+add_library(
+  ${PACKAGE_NAME}
+  SHARED
+  ${SOURCES}
+  "${CMAKE_SOURCE_DIR}/../vendor/sqlite3.c"
+)
+
+target_include_directories(
+  ${PACKAGE_NAME}
+  PRIVATE
+  ${SRC_DIR}
+  "${CMAKE_SOURCE_DIR}/../vendor"
+)
+
+find_library(LOG_LIB log)
+find_package(fbjni REQUIRED CONFIG)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  fbjni::fbjni
+  android
+)

package/android/build.gradle

@@ -3,15 +3,25 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '11.7.0'
+version = '11.8.0'
 
-buildscript {
-  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-  if (expoModulesCorePlugin.exists()) {
-    apply from: expoModulesCorePlugin
-    applyKotlinExpoModulesCorePlugin()
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+if (expoModulesCorePlugin.exists()) {
+  apply from: expoModulesCorePlugin
+  applyKotlinExpoModulesCorePlugin()
+  // Remove this check, but keep the contents after SDK49 support is dropped
+  if (safeExtGet("expoProvidesDefaultConfig", false)) {
+    useExpoPublishing()
+    useCoreDependencies()
   }
+}
 
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -35,23 +45,44 @@ buildscript {
   }
 }
 
-afterEvaluate {
-  publishing {
-    publications {
-      release(MavenPublication) {
-        from components.release
+// Remove this if and it's contents, when support for SDK49 is dropped
+if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+  afterEvaluate {
+    publishing {
+      publications {
+        release(MavenPublication) {
+          from components.release
+        }
       }
-    }
-    repositories {
-      maven {
-        url = mavenLocal().url
+      repositories {
+        maven {
+          url = mavenLocal().url
+        }
       }
     }
   }
 }
 
 android {
-  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
+
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 23)
+      targetSdkVersion safeExtGet("targetSdkVersion", 33)
+    }
+
+    publishing {
+      singleVariant("release") {
+        withSourcesJar()
+      }
+    }
+
+    lintOptions {
+      abortOnError false
+    }
+  }
 
   def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
   if (agpVersion.tokenize('.')[0].toInteger() < 8) {
@@ -67,25 +98,32 @@ android {
 
   namespace "expo.modules.sqlite"
   defaultConfig {
-    minSdkVersion safeExtGet("minSdkVersion", 21)
-    targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 18
-    versionName "11.7.0"
-  }
-  lintOptions {
-    abortOnError false
+    versionName "11.8.0"
+
+    externalNativeBuild {
+      cmake {
+        abiFilters (*reactNativeArchitectures())
+        arguments "-DANDROID_STL=c++_shared"
+      }
+    }
   }
-  publishing {
-    singleVariant("release") {
-      withSourcesJar()
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
     }
   }
+  buildFeatures {
+    prefab true
+  }
 }
 
 dependencies {
-  implementation project(':expo-modules-core')
+  // Remove this if and it's contents, when support for SDK49 is dropped
+  if (!safeExtGet("expoProvidesDefaultConfig", false)) {
+    implementation project(':expo-modules-core')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  }
 
-  implementation 'com.github.requery:sqlite-android:3.39.2'
-  implementation "androidx.sqlite:sqlite-ktx:2.3.1"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  compileOnly 'com.facebook.fbjni:fbjni:0.3.0'
 }

package/android/src/main/cpp/SQLite3Main.cpp

@@ -0,0 +1,10 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include <fbjni/fbjni.h>
+
+#include "SQLite3Wrapper.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(
+      vm, [] { expo::SQLite3Wrapper::registerNatives(); });
+}

package/android/src/main/cpp/SQLite3Wrapper.cpp

@@ -0,0 +1,253 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include "SQLite3Wrapper.h"
+
+#include <android/log.h>
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+namespace {
+
+constexpr char TAG[] = "expo-sqlite";
+
+} // namespace
+
+// static
+void SQLite3Wrapper::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", SQLite3Wrapper::initHybrid),
+      makeNativeMethod("executeSql", SQLite3Wrapper::executeSql),
+      makeNativeMethod("sqlite3_open", SQLite3Wrapper::sqlite3_open),
+      makeNativeMethod("sqlite3_close", SQLite3Wrapper::sqlite3_close),
+      makeNativeMethod("sqlite3_enable_load_extension",
+                       SQLite3Wrapper::sqlite3_enable_load_extension),
+      makeNativeMethod("sqlite3_load_extension",
+                       SQLite3Wrapper::sqlite3_load_extension),
+      makeNativeMethod("sqlite3_update_hook",
+                       SQLite3Wrapper::sqlite3_update_hook),
+  });
+}
+
+jni::local_ref<jni::JList<jni::JObject>>
+SQLite3Wrapper::executeSql(const std::string &sql,
+                           jni::alias_ref<jni::JList<jni::JObject>> args,
+                           bool readOnly) {
+  auto resultRows = jni::JArrayList<jni::JObject>::create();
+  sqlite3_stmt *statement = nullptr;
+  int rowsAffected = 0;
+  sqlite3_int64 insertId = 0;
+  jni::local_ref<jni::JString> error;
+
+  if (sqlite3_prepare_v2(db, sql.c_str(), -1, &statement, nullptr) !=
+      SQLITE_OK) {
+    auto results = jni::JArrayList<jni::JObject>::create();
+    results->add(convertSqlLiteErrorToString(db));
+    return results;
+  }
+
+  bool queryIsReadOnly = sqlite3_stmt_readonly(statement) > 0;
+  if (readOnly && !queryIsReadOnly) {
+    auto results = jni::JArrayList<jni::JObject>::create();
+    std::string error("could not prepare ");
+    error += sql;
+    results->add(jni::make_jstring(error));
+    return results;
+  }
+
+  int index = 1;
+  for (const auto &arg : *args) {
+    bindStatement(statement, arg, index++);
+  }
+
+  int columnCount = 0;
+  auto columnNames = jni::JArrayList<jni::JString>::create();
+  int columnType;
+  bool fetchedColumns = false;
+  jni::local_ref<jni::JObject> value;
+  bool hasMore = true;
+
+  while (hasMore) {
+    switch (sqlite3_step(statement)) {
+    case SQLITE_ROW: {
+      if (!fetchedColumns) {
+        columnCount = sqlite3_column_count(statement);
+
+        for (int i = 0; i < columnCount; ++i) {
+          const char *columnName = sqlite3_column_name(statement, i);
+          columnNames->add(jni::make_jstring(columnName));
+        }
+        fetchedColumns = true;
+      }
+
+      auto entry = jni::JArrayList<jni::JObject>::create();
+
+      for (int i = 0; i < columnCount; ++i) {
+        columnType = sqlite3_column_type(statement, i);
+        value = getSqlValue(columnType, statement, i);
+        entry->add(value);
+      }
+      resultRows->add(entry);
+      break;
+    }
+    case SQLITE_DONE: {
+      hasMore = false;
+      break;
+    }
+    default: {
+      error = convertSqlLiteErrorToString(db);
+      break;
+    }
+    }
+  }
+
+  if (!queryIsReadOnly) {
+    rowsAffected = sqlite3_changes(db);
+    if (rowsAffected > 0) {
+      insertId = sqlite3_last_insert_rowid(db);
+    }
+  }
+
+  sqlite3_finalize(statement);
+
+  if (error) {
+    auto results = jni::JArrayList<jni::JObject>::create();
+    results->add(error);
+    return results;
+  }
+
+  auto results = jni::JArrayList<jni::JObject>::create();
+  results->add(nullptr);
+  results->add(jni::JLong::valueOf(insertId));
+  results->add(jni::JInteger::valueOf(rowsAffected));
+  results->add(columnNames);
+  results->add(resultRows);
+  return results;
+}
+
+int SQLite3Wrapper::sqlite3_open(const std::string &dbPath) {
+  return ::sqlite3_open(dbPath.c_str(), &db);
+}
+
+int SQLite3Wrapper::sqlite3_close() {
+  int ret = ::sqlite3_close(db);
+  db = nullptr;
+  return ret;
+}
+
+int SQLite3Wrapper::sqlite3_enable_load_extension(int onoff) {
+  return ::sqlite3_enable_load_extension(db, onoff);
+}
+
+int SQLite3Wrapper::sqlite3_load_extension(const std::string &libPath,
+                                           const std::string &entryProc) {
+  char *errorMessage;
+  int ret = ::sqlite3_load_extension(db, libPath.c_str(), entryProc.c_str(),
+                                     &errorMessage);
+  if (errorMessage) {
+    __android_log_write(ANDROID_LOG_ERROR, TAG, errorMessage);
+    ::sqlite3_free(errorMessage);
+  }
+  return ret;
+}
+
+void SQLite3Wrapper::sqlite3_update_hook(bool enabled) {
+  if (enabled) {
+    ::sqlite3_update_hook(db, SQLite3Wrapper::OnUpdateHook, this);
+  } else {
+    ::sqlite3_update_hook(db, nullptr, nullptr);
+  }
+}
+
+// static
+jni::local_ref<SQLite3Wrapper::jhybriddata>
+SQLite3Wrapper::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+// static
+jni::local_ref<jni::JString>
+SQLite3Wrapper::convertSqlLiteErrorToString(sqlite3 *db) {
+  int code = sqlite3_errcode(db);
+  const char *message = sqlite3_errmsg(db);
+  std::string result("Error code ");
+  result += code;
+  result += ": ";
+  result += message;
+  return jni::make_jstring(result);
+}
+
+// static
+void SQLite3Wrapper::bindStatement(sqlite3_stmt *statement,
+                                   jni::alias_ref<jni::JObject> arg,
+                                   int index) {
+  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();
+
+  if (arg == nullptr) {
+    sqlite3_bind_null(statement, index);
+  } else if (arg->isInstanceOf(integerClass)) {
+    sqlite3_bind_int(statement, index,
+                     jni::static_ref_cast<jni::JInteger>(arg)->value());
+  } else if (arg->isInstanceOf(longClass)) {
+    sqlite3_bind_int64(statement, index,
+                       jni::static_ref_cast<jni::JLong>(arg)->value());
+  } else if (arg->isInstanceOf(doubleClass)) {
+    sqlite3_bind_double(statement, index,
+                        jni::static_ref_cast<jni::JDouble>(arg)->value());
+  } else {
+    std::string stringArg;
+    if (arg->isInstanceOf(stringClass)) {
+      stringArg = jni::static_ref_cast<jni::JString>(arg)->toStdString();
+    } else {
+      stringArg = arg->toString();
+    }
+    sqlite3_bind_text(statement, index, stringArg.c_str(), stringArg.length(),
+                      SQLITE_TRANSIENT);
+  }
+}
+
+// static
+jni::local_ref<jni::JObject>
+SQLite3Wrapper::getSqlValue(int columnType, sqlite3_stmt *statement,
+                            int index) {
+  switch (columnType) {
+  case SQLITE_INTEGER: {
+    return jni::JLong::valueOf(sqlite3_column_int64(statement, index));
+  }
+  case SQLITE_FLOAT: {
+    return jni::JDouble::valueOf(sqlite3_column_double(statement, index));
+  }
+  case SQLITE_BLOB: {
+    JNIEnv *env = jni::Environment::current();
+    return jni::adopt_local(env->NewString(
+        reinterpret_cast<const jchar *>(sqlite3_column_blob(statement, index)),
+        static_cast<size_t>(sqlite3_column_bytes(statement, index))));
+  }
+  case SQLITE_TEXT: {
+    std::string text(
+        reinterpret_cast<const char *>(sqlite3_column_text(statement, index)),
+        static_cast<size_t>(sqlite3_column_bytes(statement, index)));
+    return jni::make_jstring(text);
+  }
+  default: {
+    return nullptr;
+  }
+  }
+}
+
+// static
+void SQLite3Wrapper::OnUpdateHook(void *arg, int action, char const *dbName,
+                                  char const *tableName, sqlite3_int64 rowId) {
+  SQLite3Wrapper *pThis = reinterpret_cast<SQLite3Wrapper *>(arg);
+  static const auto method =
+      jni::findClassStatic("expo/modules/sqlite/SQLite3Wrapper")
+          ->getMethod<void(jint, jstring, jstring, jlong)>("onUpdate");
+  method(pThis->javaPart_, action, jni::make_jstring(dbName).get(),
+         jni::make_jstring(tableName).get(), rowId);
+}
+
+} // namespace expo

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

@@ -0,0 +1,59 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <string>
+
+#include "sqlite3.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+class SQLite3Wrapper : public jni::HybridClass<SQLite3Wrapper> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lexpo/modules/sqlite/SQLite3Wrapper;";
+
+  static void registerNatives();
+
+  jni::local_ref<jni::JList<jni::JObject>>
+  executeSql(const std::string &sql,
+             jni::alias_ref<jni::JList<jni::JObject>> args, bool readOnly);
+
+  // sqlite3 bindings
+  int sqlite3_open(const std::string &dbPath);
+  int sqlite3_close();
+  int sqlite3_enable_load_extension(int onoff);
+  int sqlite3_load_extension(const std::string &libPath,
+                             const std::string &entryProc);
+  void sqlite3_update_hook(bool enabled);
+
+private:
+  explicit SQLite3Wrapper(jni::alias_ref<SQLite3Wrapper::jhybridobject> jThis)
+      : javaPart_(jni::make_global(jThis)) {}
+
+private:
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static jni::local_ref<jni::JString> convertSqlLiteErrorToString(sqlite3 *db);
+
+  static void bindStatement(sqlite3_stmt *statement,
+                            jni::alias_ref<jni::JObject> arg, int index);
+
+  static jni::local_ref<jni::JObject>
+  getSqlValue(int columnType, sqlite3_stmt *statement, int index);
+
+  static void OnUpdateHook(void *arg, int action, char const *dbName,
+                           char const *tableName, sqlite3_int64 rowId);
+
+private:
+  friend HybridBase;
+
+  jni::global_ref<SQLite3Wrapper::javaobject> javaPart_;
+  sqlite3 *db;
+};
+
+} // namespace expo

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

@@ -2,6 +2,7 @@ package expo.modules.sqlite
 
 import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.Enumerable
 
 data class Query(
   @Field
@@ -9,3 +10,10 @@ data class Query(
   @Field
   val args: List<Any?>
 ) : Record
+
+enum class SqlAction(val value: String) : Enumerable {
+  INSERT("insert"),
+  UPDATE("update"),
+  DELETE("delete"),
+  UNKNOWN("unknown")
+}

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

@@ -0,0 +1,81 @@
+package expo.modules.sqlite
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+
+private typealias UpdateListener = (tableName: String, operationType: Int, rowID: Long) -> Unit
+
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class SQLite3Wrapper private constructor() {
+  @DoNotStrip
+  private val mHybridData: HybridData
+
+  private var mUpdateListener: UpdateListener? = null
+
+  init {
+    mHybridData = initHybrid()
+  }
+
+  /**
+   * Execute SQL commands
+   */
+  external fun executeSql(sql: String, args: List<Any?>, readOnly: Boolean): List<Any>
+
+  /**
+   * Enable data change notifications
+   */
+  fun enableUpdateHook(listener: UpdateListener) {
+    sqlite3_update_hook(true)
+    mUpdateListener = listener
+  }
+
+  /**
+   * Disable data change notifications
+   */
+  fun disableUpdateHook() {
+    mUpdateListener = null
+    sqlite3_update_hook(false)
+  }
+
+  // region sqlite3 bindings
+
+  external fun sqlite3_open(dbPath: String): Int
+  external fun sqlite3_close(): Int
+
+  external fun sqlite3_enable_load_extension(onoff: Int): Int
+  external fun sqlite3_load_extension(libPath: String, entryProc: String): Int
+
+  private external fun sqlite3_update_hook(enabled: Boolean)
+
+  // endregion
+
+  // region internals
+
+  private external fun initHybrid(): HybridData
+
+  @DoNotStrip
+  private fun onUpdate(action: Int, dbName: String, tableName: String, rowId: Long) {
+    mUpdateListener?.invoke(tableName, action, rowId)
+  }
+
+  // endregion
+
+  companion object {
+    init {
+      System.loadLibrary("expo-sqlite")
+    }
+
+    @JvmStatic
+    fun open(dbPath: String): SQLite3Wrapper? {
+      val instance = SQLite3Wrapper()
+      if (instance.sqlite3_open(dbPath) != SQLITE_OK) {
+        return null
+      }
+      return instance
+    }
+
+    // These error code should be synced with sqlite3.h
+    const val SQLITE_OK = 0
+  }
+}