expo-sqlite 11.8.0 → 12.0.0

package/CHANGELOG.md

@@ -10,6 +10,26 @@
 
 ### 💡 Others
 
+## 12.0.0 — 2023-11-06
+
+### 🛠 Breaking changes
+
+- Bumped iOS deployment target to 13.4. ([#25063](https://github.com/expo/expo/pull/25063) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+- Remove CRSQLite support on legacy API. ([#25092](https://github.com/expo/expo/pull/25092) by [@kudo](https://github.com/kudo))
+
+### 🎉 New features
+
+- Added Android implementation for `sqlite/next` APIs. ([#25021](https://github.com/expo/expo/pull/25021) by [@kudo](https://github.com/kudo))
+- Added the `useSQLiteContext` hook that can be used across components. ([#25129](https://github.com/expo/expo/pull/25129) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- [ios] Fix some issues for `sqlite/next`. ([#25022](https://github.com/expo/expo/pull/25022) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- [Android] Removed the package included SQLite source and download in build time. ([#25186](https://github.com/expo/expo/pull/25186) by [@kudo](https://github.com/kudo))
+
 ## 11.8.0 — 2023-10-17
 
 ### 🛠 Breaking changes
@@ -19,6 +39,7 @@
 ### 🎉 New features
 
 - [Android] Rewrite implementations from low-level SQLite bindings. ([#24730](https://github.com/expo/expo/pull/24730) by [@kudo](https://github.com/kudo))
+- Introduced `expo-sqlite/next` new APIs. ([#24812](https://github.com/expo/expo/pull/24812) by [@kudo](https://github.com/kudo))
 
 ## 11.7.1 — 2023-09-18
 

package/android/CMakeLists.txt

@@ -14,14 +14,14 @@ add_library(
   ${PACKAGE_NAME}
   SHARED
   ${SOURCES}
-  "${CMAKE_SOURCE_DIR}/../vendor/sqlite3.c"
+  "${SQLITE3_SRC_DIR}/sqlite3.c"
 )
 
 target_include_directories(
   ${PACKAGE_NAME}
   PRIVATE
   ${SRC_DIR}
-  "${CMAKE_SOURCE_DIR}/../vendor"
+  "${SQLITE3_SRC_DIR}"
 )
 
 find_library(LOG_LIB log)

package/android/build.gradle

@@ -1,9 +1,10 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
+apply plugin: 'de.undercouch.download'
 
 group = 'host.exp.exponent'
-version = '11.8.0'
+version = '12.0.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -16,6 +17,11 @@ if (expoModulesCorePlugin.exists()) {
   }
 }
 
+def SQLITE_VERSION = '3420000'
+def customDownloadsDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
+def downloadsDir = customDownloadsDir ? new File(customDownloadsDir) : new File("$buildDir/downloads")
+def SQLITE3_SRC_DIR = new File("$buildDir/sqlite3_src")
+
 def reactNativeArchitectures() {
   def value = project.getProperties().get("reactNativeArchitectures")
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
@@ -42,6 +48,7 @@ buildscript {
 
   dependencies {
     classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+    classpath("de.undercouch:gradle-download-task:5.5.0")
   }
 }
 
@@ -99,12 +106,13 @@ android {
   namespace "expo.modules.sqlite"
   defaultConfig {
     versionCode 18
-    versionName "11.8.0"
+    versionName "12.0.0"
 
     externalNativeBuild {
       cmake {
         abiFilters (*reactNativeArchitectures())
-        arguments "-DANDROID_STL=c++_shared"
+        arguments "-DANDROID_STL=c++_shared",
+          "-DSQLITE3_SRC_DIR=${SQLITE3_SRC_DIR}"
       }
     }
   }
@@ -127,3 +135,42 @@ dependencies {
 
   compileOnly 'com.facebook.fbjni:fbjni:0.3.0'
 }
+
+def createNativeDepsDirectories = tasks.register('createNativeDepsDirectories') {
+  downloadsDir.mkdirs()
+  SQLITE3_SRC_DIR.mkdirs()
+}
+
+def downloadSQLite = tasks.create('downloadSQLite', Download) {
+  dependsOn(createNativeDepsDirectories)
+  src("https://www.sqlite.org/2023/sqlite-amalgamation-${SQLITE_VERSION}.zip")
+  onlyIfNewer(true)
+  overwrite(false)
+  dest(new File(downloadsDir, "sqlite-amalgamation-${SQLITE_VERSION}.zip"))
+}
+
+def prepareSQLite = tasks.register('prepareSQLite', Copy) {
+  dependsOn(downloadSQLite)
+  from(zipTree(downloadSQLite.dest))
+  into(SQLITE3_SRC_DIR)
+  eachFile {
+    // flatten files
+    path = name
+  }
+}
+
+void nativeBuildDependsOn(project, dependsOnTask) {
+  def buildTasks = project.tasks.findAll { task ->
+    def taskName = task.name
+    if (taskName.contains("Clean")) { return false }
+    if (taskName.contains("externalNative") || taskName.contains("CMake") || taskName.contains("generateJsonModel")) {
+      return true
+    }
+    return false
+  }
+  buildTasks.forEach { task -> task.dependsOn(dependsOnTask) }
+}
+
+afterEvaluate {
+  nativeBuildDependsOn(project, prepareSQLite)
+}

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

@@ -0,0 +1,142 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include "NativeDatabaseBinding.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+namespace {
+
+constexpr char TAG[] = "expo-sqlite";
+
+} // namespace
+
+// static
+void NativeDatabaseBinding::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", NativeDatabaseBinding::initHybrid),
+      makeNativeMethod("sqlite3_changes",
+                       NativeDatabaseBinding::sqlite3_changes),
+      makeNativeMethod("sqlite3_close", NativeDatabaseBinding::sqlite3_close),
+      makeNativeMethod("sqlite3_db_filename",
+                       NativeDatabaseBinding::sqlite3_db_filename),
+      makeNativeMethod("sqlite3_enable_load_extension",
+                       NativeDatabaseBinding::sqlite3_enable_load_extension),
+      makeNativeMethod("sqlite3_exec", NativeDatabaseBinding::sqlite3_exec),
+      makeNativeMethod("sqlite3_get_autocommit",
+                       NativeDatabaseBinding::sqlite3_get_autocommit),
+      makeNativeMethod("sqlite3_last_insert_rowid",
+                       NativeDatabaseBinding::sqlite3_last_insert_rowid),
+      makeNativeMethod("sqlite3_load_extension",
+                       NativeDatabaseBinding::sqlite3_load_extension),
+      makeNativeMethod("sqlite3_open", NativeDatabaseBinding::sqlite3_open),
+      makeNativeMethod("sqlite3_prepare_v2",
+                       NativeDatabaseBinding::sqlite3_prepare_v2),
+      makeNativeMethod("sqlite3_update_hook",
+                       NativeDatabaseBinding::sqlite3_update_hook),
+      makeNativeMethod("convertSqlLiteErrorToString",
+                       NativeDatabaseBinding::convertSqlLiteErrorToString),
+  });
+}
+
+int NativeDatabaseBinding::sqlite3_changes() { return ::sqlite3_changes(db); }
+
+int NativeDatabaseBinding::sqlite3_close() {
+  // Not setting `db = nullptr` here because we may need the db pointer to get
+  // error messages if sqlite3_close has errors.
+  return ::sqlite3_close(db);
+}
+
+std::string
+NativeDatabaseBinding::sqlite3_db_filename(const std::string &dbName) {
+  return ::sqlite3_db_filename(db, dbName.c_str());
+}
+
+int NativeDatabaseBinding::sqlite3_enable_load_extension(int onoff) {
+  return ::sqlite3_enable_load_extension(db, onoff);
+}
+
+int NativeDatabaseBinding::sqlite3_exec(const std::string &source) {
+  char *error;
+  int ret = ::sqlite3_exec(db, source.c_str(), nullptr, nullptr, &error);
+  if (ret != SQLITE_OK && error) {
+    std::string errorString(error);
+    ::sqlite3_free(error);
+    jni::throwNewJavaException(SQLiteErrorException::create(errorString).get());
+  }
+  return ret;
+}
+
+int NativeDatabaseBinding::sqlite3_get_autocommit() {
+  return ::sqlite3_get_autocommit(db);
+}
+
+int64_t NativeDatabaseBinding::sqlite3_last_insert_rowid() {
+  return ::sqlite3_last_insert_rowid(db);
+}
+
+int NativeDatabaseBinding::sqlite3_load_extension(
+    const std::string &libPath, const std::string &entryProc) {
+  char *error;
+  int ret =
+      ::sqlite3_load_extension(db, libPath.c_str(), entryProc.c_str(), &error);
+  if (ret != SQLITE_OK && error) {
+    std::string errorString(error);
+    ::sqlite3_free(error);
+    jni::throwNewJavaException(SQLiteErrorException::create(errorString).get());
+  }
+  return ret;
+}
+
+int NativeDatabaseBinding::sqlite3_open(const std::string &dbPath) {
+  return ::sqlite3_open(dbPath.c_str(), &db);
+}
+
+int NativeDatabaseBinding::sqlite3_prepare_v2(
+    const std::string &source,
+    jni::alias_ref<NativeStatementBinding::javaobject> statement) {
+  NativeStatementBinding *cStatement = cthis(statement);
+  return ::sqlite3_prepare_v2(db, source.c_str(), source.size(),
+                              &cStatement->stmt, nullptr);
+}
+
+void NativeDatabaseBinding::sqlite3_update_hook(bool enabled) {
+  if (enabled) {
+    ::sqlite3_update_hook(db, NativeDatabaseBinding::OnUpdateHook, this);
+  } else {
+    ::sqlite3_update_hook(db, nullptr, nullptr);
+  }
+}
+
+jni::local_ref<jni::JString>
+NativeDatabaseBinding::convertSqlLiteErrorToString() {
+  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
+jni::local_ref<NativeDatabaseBinding::jhybriddata>
+NativeDatabaseBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+// static
+void NativeDatabaseBinding::OnUpdateHook(void *arg, int action,
+                                         char const *dbName,
+                                         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(),
+         jni::make_jstring(tableName).get(), rowId);
+}
+
+} // namespace expo

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

@@ -0,0 +1,75 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <string>
+
+#include "NativeStatementBinding.h"
+#include "sqlite3.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+class NativeDatabaseBinding : public jni::HybridClass<NativeDatabaseBinding> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lexpo/modules/sqlite/NativeDatabaseBinding;";
+
+  static void registerNatives();
+
+  // sqlite3 bindings
+  int sqlite3_changes();
+  int sqlite3_close();
+  std::string sqlite3_db_filename(const std::string &dbName);
+  int sqlite3_enable_load_extension(int onoff);
+  int sqlite3_exec(const std::string &source);
+  int sqlite3_get_autocommit();
+  int64_t sqlite3_last_insert_rowid();
+  int sqlite3_load_extension(const std::string &libPath,
+                             const std::string &entryProc);
+  int sqlite3_open(const std::string &dbPath);
+  int sqlite3_prepare_v2(
+      const std::string &source,
+      jni::alias_ref<NativeStatementBinding::javaobject> statement);
+  void sqlite3_update_hook(bool enabled);
+
+  // helpers
+  jni::local_ref<jni::JString> convertSqlLiteErrorToString();
+
+private:
+  explicit NativeDatabaseBinding(
+      jni::alias_ref<NativeDatabaseBinding::jhybridobject> jThis)
+      : javaPart_(jni::make_global(jThis)) {}
+
+private:
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static void OnUpdateHook(void *arg, int action, char const *dbName,
+                           char const *tableName, sqlite3_int64 rowId);
+
+private:
+  friend HybridBase;
+
+  jni::global_ref<NativeDatabaseBinding::javaobject> javaPart_;
+  sqlite3 *db;
+};
+
+/**
+ * A convenient wrapper for the Kotlin SQLiteErrorException.
+ */
+class SQLiteErrorException
+    : public jni::JavaClass<SQLiteErrorException, CodedException> {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lexpo/modules/sqlite/SQLiteErrorException;";
+
+  static jni::local_ref<SQLiteErrorException>
+  create(const std::string &message) {
+    return SQLiteErrorException::newInstance(jni::make_jstring(message));
+  }
+};
+
+} // namespace expo

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

@@ -0,0 +1,146 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#include "NativeStatementBinding.h"
+
+#include <android/log.h>
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+namespace {
+
+constexpr char TAG[] = "expo-sqlite";
+
+} // namespace
+
+// static
+void NativeStatementBinding::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", NativeStatementBinding::initHybrid),
+      makeNativeMethod("sqlite3_bind_parameter_index",
+                       NativeStatementBinding::sqlite3_bind_parameter_index),
+      makeNativeMethod("sqlite3_column_count",
+                       NativeStatementBinding::sqlite3_column_count),
+      makeNativeMethod("sqlite3_column_name",
+                       NativeStatementBinding::sqlite3_column_name),
+      makeNativeMethod("sqlite3_finalize",
+                       NativeStatementBinding::sqlite3_finalize),
+      makeNativeMethod("sqlite3_reset", NativeStatementBinding::sqlite3_reset),
+      makeNativeMethod("sqlite3_step", NativeStatementBinding::sqlite3_step),
+      makeNativeMethod("bindStatementParam",
+                       NativeStatementBinding::bindStatementParam),
+      makeNativeMethod("getRow", NativeStatementBinding::getRow),
+  });
+}
+
+int NativeStatementBinding::sqlite3_bind_parameter_index(
+    const std::string &name) {
+  return ::sqlite3_bind_parameter_index(stmt, name.c_str());
+}
+
+int NativeStatementBinding::sqlite3_column_count() {
+  return ::sqlite3_column_count(stmt);
+}
+
+std::string NativeStatementBinding::sqlite3_column_name(int index) {
+  return ::sqlite3_column_name(stmt, index);
+}
+
+int NativeStatementBinding::sqlite3_finalize() {
+  return ::sqlite3_finalize(stmt);
+}
+
+int NativeStatementBinding::sqlite3_reset() { return ::sqlite3_reset(stmt); }
+
+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)) {
+    ret = sqlite3_bind_int(stmt, index,
+                           jni::static_ref_cast<jni::JInteger>(param)->value());
+  } else if (param->isInstanceOf(longClass)) {
+    ret = sqlite3_bind_int64(stmt, index,
+                             jni::static_ref_cast<jni::JLong>(param)->value());
+  } else if (param->isInstanceOf(doubleClass)) {
+    ret = sqlite3_bind_double(
+        stmt, index, jni::static_ref_cast<jni::JDouble>(param)->value());
+  } else if (param->isInstanceOf(booleanClass)) {
+    ret = sqlite3_bind_int(
+        stmt, index,
+        jni::static_ref_cast<jni::JBoolean>(param)->value() ? 1 : 0);
+  } else {
+    std::string stringArg;
+    if (param->isInstanceOf(stringClass)) {
+      stringArg = jni::static_ref_cast<jni::JString>(param)->toStdString();
+    } else {
+      stringArg = param->toString();
+    }
+    ret = sqlite3_bind_text(stmt, index, stringArg.c_str(), stringArg.length(),
+                            SQLITE_TRANSIENT);
+  }
+  return ret;
+}
+
+jni::local_ref<ArrayMap<jni::JString, jni::JObject>>
+NativeStatementBinding::getRow() {
+  int columnCount = sqlite3_column_count();
+  auto row = ArrayMap<jni::JString, jni::JObject>::create(columnCount);
+  for (int i = 0; i < columnCount; ++i) {
+    auto name = sqlite3_column_name(i);
+    auto value = getColumnValue(i);
+    row->put(jni::make_jstring(name), value);
+  }
+  return row;
+}
+
+// static
+jni::local_ref<NativeStatementBinding::jhybriddata>
+NativeStatementBinding::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+jni::local_ref<jni::JObject> NativeStatementBinding::getColumnValue(int index) {
+  int type = ::sqlite3_column_type(stmt, index);
+  switch (type) {
+  case SQLITE_INTEGER: {
+    return jni::JLong::valueOf(sqlite3_column_int64(stmt, index));
+  }
+  case SQLITE_FLOAT: {
+    return jni::JDouble::valueOf(sqlite3_column_double(stmt, index));
+  }
+  case SQLITE_TEXT: {
+    std::string text(
+        reinterpret_cast<const char *>(sqlite3_column_text(stmt, index)),
+        static_cast<size_t>(sqlite3_column_bytes(stmt, 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))));
+  }
+  case SQLITE_NULL: {
+    return nullptr;
+  }
+  default: {
+    std::string errorMessage =
+        "Unsupported parameter type: " + std::to_string(type);
+    jni::throwNewJavaException(
+        InvalidConvertibleException::create(errorMessage).get());
+  }
+  }
+}
+
+} // namespace expo

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

@@ -0,0 +1,95 @@
+// 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 NativeDatabaseBinding;
+
+/**
+ * A convenient wrapper for the ArrayMap
+ */
+template <typename K = jobject, typename V = jobject>
+struct ArrayMap : public jni::JavaClass<ArrayMap<K, V>, jni::JMap<K, V>> {
+  static auto constexpr kJavaDescriptor = "Landroid/util/ArrayMap;";
+
+  static jni::local_ref<typename ArrayMap<K, V>::javaobject>
+  create(int capacity) {
+    return ArrayMap<K, V>::newInstance(capacity);
+  }
+};
+
+class NativeStatementBinding : public jni::HybridClass<NativeStatementBinding> {
+public:
+  static constexpr auto kJavaDescriptor =
+      "Lexpo/modules/sqlite/NativeStatementBinding;";
+
+  static void registerNatives();
+
+  // sqlite3 bindings
+  int sqlite3_bind_parameter_index(const std::string &name);
+  int sqlite3_column_count();
+  std::string sqlite3_column_name(int index);
+  int sqlite3_finalize();
+  int sqlite3_reset();
+  int sqlite3_step();
+
+  // helpers
+  int bindStatementParam(int index, jni::alias_ref<jni::JObject> param);
+  jni::local_ref<ArrayMap<jni::JString, jni::JObject>> getRow();
+
+private:
+  explicit NativeStatementBinding(
+      jni::alias_ref<NativeStatementBinding::jhybridobject> jThis)
+      : javaPart_(jni::make_global(jThis)) {}
+
+  jni::local_ref<jni::JObject> getColumnValue(int index);
+
+private:
+  static jni::local_ref<jhybriddata>
+  initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+private:
+  friend HybridBase;
+  friend NativeDatabaseBinding;
+
+  jni::global_ref<NativeStatementBinding::javaobject> javaPart_;
+  sqlite3_stmt *stmt;
+};
+
+/**
+ * A convenient wrapper for the Kotlin CodedException.
+ * TODO: Add prefabPublishing from expo-modules-core and remove the duplicated
+ * definition.
+ */
+class CodedException : public jni::JavaClass<CodedException, jni::JThrowable> {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lexpo/modules/kotlin/exception/CodedException;";
+
+  static jni::local_ref<CodedException> create(const std::string &message);
+};
+
+/**
+ * A convenient wrapper for the Kotlin InvalidConvertibleException.
+ */
+class InvalidConvertibleException
+    : public jni::JavaClass<InvalidConvertibleException, CodedException> {
+public:
+  static auto constexpr kJavaDescriptor =
+      "Lexpo/modules/sqlite/InvalidConvertibleException;";
+
+  static jni::local_ref<InvalidConvertibleException>
+  create(const std::string &message) {
+    return InvalidConvertibleException::newInstance(jni::make_jstring(message));
+  }
+};
+
+} // namespace expo

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

@@ -2,9 +2,14 @@
 
 #include <fbjni/fbjni.h>
 
+#include "NativeDatabaseBinding.h"
+#include "NativeStatementBinding.h"
 #include "SQLite3Wrapper.h"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
-  return facebook::jni::initialize(
-      vm, [] { expo::SQLite3Wrapper::registerNatives(); });
+  return facebook::jni::initialize(vm, [] {
+    expo::NativeDatabaseBinding::registerNatives();
+    expo::NativeStatementBinding::registerNatives();
+    expo::SQLite3Wrapper::registerNatives();
+  });
 }

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

@@ -21,12 +21,6 @@ void SQLite3Wrapper::registerNatives() {
       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),
   });
 }
 
@@ -136,30 +130,6 @@ int SQLite3Wrapper::sqlite3_close() {
   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) {

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

@@ -25,10 +25,6 @@ public:
   // 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)

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

@@ -0,0 +1,11 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.sqlite
+
+import expo.modules.kotlin.sharedobjects.SharedRef
+
+internal class NativeDatabase(val dbName: String, val openOptions: OpenDatabaseOptions) : SharedRef<NativeDatabaseBinding>(NativeDatabaseBinding()) {
+  override fun equals(other: Any?): Boolean {
+    return other is NativeDatabase && this.ref == other.ref
+  }
+}