@op-engineering/op-sqlite 2.0.7-rc2 → 2.0.8

package/README.md

@@ -119,10 +119,49 @@ const db = open({
 db.execute('PRAGMA mmap_size=268435456');
 ```
 
-If you use prepared statements plus memory mapping, you can get to inches of MMKV for the most performance critical queries, here is a simple example writing/reading a single value.
+You can also set journaling to memory (or even OFF if you are kinda crazy) to gain even more speed. Journaling is what allows SQLite to ROLLBACK statements and it is dangerous, so do it at your own risk
+
+```ts
+db.execute('PRAGMA journal_mode = MEMORY;'); // or OFF
+```
+
+If you use [prepared statements](#prepared-statements) plus memory mapping and set journaling to memory, you can get to inches of MMKV for the most performance critical queries, here is a simple example writing/reading a single value.
 
 ![mmkv comparison](mmkv.png)
 
+# SQLite Gotchas
+
+## Strictness
+
+It's important to notice SQLite unlike other databases by default does not strictly check for types, if you want true type safety when you declare your tables you need to use the `STRICT` keyword.
+
+```ts
+db.execute('CREATE TABLE Test (
+              id INT PRIMARY KEY,
+              name TEXT
+          ) STRICT;');
+```
+
+If you don't set it, SQLite will happily write whatever you insert in your table, independtly of the declared type.
+
+## Foreign constraints
+
+When SQLite evaluates your query and you have forgein key constraints, it keeps track of the satisfied relations via a counter. Once your statement finishes executing and the counter is not 0, it throws a foreign key constraint failed error. Unfortunately, this simple design means it is impossible to catch which foreign constraint is failed and you will receive a generic error. Nothing op-sqlite can do about it, it's a design flaw in SQLite.
+
+In order to catch foreign key errors, you also need to execute the pragma when you open your connection:
+
+```
+PRAGMA foreign_keys = true
+```
+
+## Error codes
+
+Sometimes you might be using valid SQL syntax for other engines or you might be doing something else wrong. The errors returned by op-sqlite contain the raw error code returned by SQLite and you should check [the reference](https://www.sqlite.org/rescode.html) for more detailed information.
+
+## Quirks
+
+See the [full list of SQLite quirks](https://www.sqlite.org/quirks.html).
+
 # API
 
 ```typescript

package/android/src/main/java/com/op/sqlite/OPSQLiteModule.kt

@@ -1,7 +1,6 @@
 package com.op.sqlite
 
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.module.annotations.ReactModule;
 

package/android/src/main/java/com/op/sqlite/OPSQLitePackage.kt

@@ -1,18 +1,11 @@
 package com.op.sqlite
 
-
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
-import com.facebook.react.module.annotations.ReactModuleList;
 import com.facebook.react.module.model.ReactModuleInfo
 
-//@ReactModuleList(
-//    nativeModules = {
-//            OPSQLiteModule.class,
-//    }
-//)
 class OPSQLitePackage : TurboReactPackage() {
     override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
         if(name == OPSQLiteModule.NAME) {

package/cpp/DumbHostObject.cpp

@@ -36,7 +36,35 @@ jsi::Value DumbHostObject::get(jsi::Runtime &rt,
     }
   }
 
+  for (auto pairField : ownValues) {
+    if (name == pairField.first) {
+      return toJSI(rt, pairField.second);
+    }
+  }
+
   return {};
 }
 
+void DumbHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
+                         const jsi::Value &value) {
+  auto key = name.utf8(rt);
+  auto fields = metadata.get();
+  for (int i = 0; i < fields->size(); i++) {
+    auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
+    if (fieldName == key) {
+      values[i] = toVariant(rt, value);
+      return;
+    }
+  }
+
+  for (auto pairField : ownValues) {
+    if (key == pairField.first) {
+      pairField.second = toVariant(rt, value);
+      return;
+    }
+  }
+
+  ownValues.push_back(std::make_pair(key, toVariant(rt, value)));
+}
+
 } // namespace opsqlite

package/cpp/DumbHostObject.h

@@ -23,9 +23,14 @@ public:
 
   jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value);
+
   std::vector<JSVariant> values;
 
   std::shared_ptr<std::vector<SmartHostObject>> metadata;
+
+  std::vector<std::pair<std::string, JSVariant>> ownValues;
 };
 
 } // namespace opsqlite

package/cpp/utils.cpp

@@ -38,6 +38,49 @@ jsi::Value toJSI(jsi::Runtime &rt, JSVariant value) {
   return jsi::Value::null();
 }
 
+JSVariant toVariant(jsi::Runtime &rt, const jsi::Value &value) {
+  if (value.isNull() || value.isUndefined()) {
+    return JSVariant(nullptr);
+  } else if (value.isBool()) {
+    return JSVariant(value.getBool());
+  } else if (value.isNumber()) {
+    double doubleVal = value.asNumber();
+    int intVal = (int)doubleVal;
+    long long longVal = (long)doubleVal;
+    if (intVal == doubleVal) {
+      return JSVariant(intVal);
+    } else if (longVal == doubleVal) {
+      return JSVariant(longVal);
+    } else {
+      return JSVariant(doubleVal);
+    }
+  } else if (value.isString()) {
+    std::string strVal = value.asString(rt).utf8(rt);
+    return JSVariant(strVal);
+  } else if (value.isObject()) {
+    auto obj = value.asObject(rt);
+    if (obj.isArrayBuffer(rt)) {
+      auto buffer = obj.getArrayBuffer(rt);
+
+      uint8_t *data = new uint8_t[buffer.size(rt)];
+      // You cannot share raw memory between native and JS
+      // always copy the data
+      // see https://github.com/facebook/hermes/pull/419 and
+      // https://github.com/facebook/hermes/issues/564.
+      memcpy(data, buffer.data(rt), buffer.size(rt));
+
+      return JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                                   .size = buffer.size(rt)});
+    } else {
+      throw std::invalid_argument(
+          "Unknown JSI ArrayBuffer to variant value conversion, received "
+          "object instead of ArrayBuffer");
+    }
+  } else {
+    throw std::invalid_argument("Unknown JSI to variant value conversion");
+  }
+}
+
 std::vector<JSVariant> toVariantVec(jsi::Runtime &rt,
                                     jsi::Value const &params) {
   std::vector<JSVariant> res;

package/cpp/utils.h

@@ -33,6 +33,8 @@ struct BatchResult {
 
 jsi::Value toJSI(jsi::Runtime &rt, JSVariant value);
 
+JSVariant toVariant(jsi::Runtime &rt, jsi::Value const &value);
+
 std::vector<JSVariant> toVariantVec(jsi::Runtime &rt, jsi::Value const &args);
 
 jsi::Value createResult(jsi::Runtime &rt, BridgeResult status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "2.0.7-rc2",
+  "version": "2.0.8",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -26,7 +26,7 @@
     "typescript": "tsc --noEmit",
     "prepare": "bob build",
     "example": "yarn --cwd example",
-    "pods": "cd example && npx pod-install --quiet",
+    "pods": "cd example && yarn pods",
     "bootstrap": "yarn example && yarn && yarn pods",
     "bump": "./bump-version.sh"
   },
@@ -48,7 +48,7 @@
   "devDependencies": {
     "lefthook": "^1.5.5",
     "react": "18.2.0",
-    "react-native": "0.73.0",
+    "react-native": "0.73.1",
     "react-native-builder-bob": "^0.23.2",
     "typescript": "5.0.4"
   },