pomegranate-db 0.1.0

package/native/android-jsi/src/main/java/com/pomegranate/jsi/PomegranateJSIModule.kt

@@ -0,0 +1,39 @@
+package com.pomegranate.jsi
+
+import android.util.Log
+import com.facebook.react.bridge.JavaScriptContextHolder
+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
+
+/**
+ * React Native module that installs the PomegranateDB JSI binding.
+ *
+ * JS should call PomegranateJSIBridge.install() early in the app lifecycle
+ * (before using any native SQLite adapter). This is a synchronous blocking
+ * method that registers the global nativePomegranateCreateAdapter function.
+ */
+@ReactModule(name = PomegranateJSIModule.NAME)
+class PomegranateJSIModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String = NAME
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun install(): Boolean =
+        try {
+            val jsContext: JavaScriptContextHolder =
+                reactApplicationContext.javaScriptContextHolder!!
+            JSIInstaller.install(reactApplicationContext, jsContext.get())
+            Log.i(NAME, "Successfully installed PomegranateDB JSI Bindings!")
+            true
+        } catch (exception: Exception) {
+            Log.e(NAME, "Failed to install PomegranateDB JSI Bindings!", exception)
+            false
+        }
+
+    companion object {
+        const val NAME = "PomegranateJSIBridge"
+    }
+}

package/native/android-jsi/src/main/java/com/pomegranate/jsi/PomegranateJSIPackage.kt

@@ -0,0 +1,17 @@
+package com.pomegranate.jsi
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package that provides the PomegranateDB JSI module.
+ * Add this to your MainApplication's getPackages() list.
+ */
+class PomegranateJSIPackage : ReactPackage {
+    override fun createNativeModules(reactAppContext: ReactApplicationContext): List<NativeModule> =
+        listOf(PomegranateJSIModule(reactAppContext))
+
+    override fun createViewManagers(reactAppContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/native/ios/DatabasePlatformIOS.mm

@@ -0,0 +1,83 @@
+/**
+ * PomegranateDB — iOS platform implementation.
+ *
+ * Provides platform::resolveDatabasePath via NSDocumentDirectory,
+ * and platform::consoleLog/consoleError via NSLog.
+ */
+
+#include "Database.h"
+#import <Foundation/Foundation.h>
+#include <mutex>
+#include <sqlite3.h>
+
+#define LOG_TAG "pomegranate.jsi"
+
+namespace pomegranate {
+namespace platform {
+
+// ─── Logging ─────────────────────────────────────────────────────────────────
+
+void consoleLog(const std::string &message) {
+    NSLog(@"[%s] %s", LOG_TAG, message.c_str());
+}
+
+void consoleError(const std::string &message) {
+    NSLog(@"[%s] ERROR: %s", LOG_TAG, message.c_str());
+}
+
+// ─── SQLite initialization ───────────────────────────────────────────────────
+
+static void sqliteLogCallback(void *, int err, const char *message) {
+    int errType = err & 255;
+    if (errType == SQLITE_WARNING) {
+        NSLog(@"[%s] sqlite warning (%d): %s", LOG_TAG, err, message);
+    } else if (errType == 0 || errType == SQLITE_CONSTRAINT ||
+               errType == SQLITE_SCHEMA || errType == SQLITE_NOTICE) {
+        // verbose — skip
+    } else {
+        NSLog(@"[%s] sqlite error (%d): %s", LOG_TAG, err, message);
+    }
+}
+
+static std::once_flag sqliteInitFlag;
+
+static void initializeSqlite() {
+    std::call_once(sqliteInitFlag, []() {
+        sqlite3_config(SQLITE_CONFIG_LOG, &sqliteLogCallback, nullptr);
+        sqlite3_soft_heap_limit(8 * 1024 * 1024);
+        sqlite3_initialize();
+    });
+}
+
+// ─── Path resolution ─────────────────────────────────────────────────────────
+
+std::string resolveDatabasePath(const std::string &dbName) {
+    initializeSqlite();
+
+    NSError *err = nil;
+    NSURL *documentsUrl =
+        [NSFileManager.defaultManager URLForDirectory:NSDocumentDirectory
+                                             inDomain:NSUserDomainMask
+                                    appropriateForURL:nil
+                                               create:YES
+                                                error:&err];
+    if (err || !documentsUrl) {
+        NSString *desc = err ? err.localizedDescription : @"unknown";
+        throw std::runtime_error(
+            "PomegranateDB: failed to resolve documents directory — " +
+            std::string([desc cStringUsingEncoding:NSUTF8StringEncoding]));
+    }
+
+    NSString *filename = [NSString stringWithFormat:@"%s.db", dbName.c_str()];
+    NSURL *dbUrl = [documentsUrl URLByAppendingPathComponent:filename];
+    const char *cPath = dbUrl.path.UTF8String;
+
+    if (!cPath) {
+        throw std::runtime_error("PomegranateDB: failed to construct db path for " + dbName);
+    }
+
+    return std::string(cPath);
+}
+
+}  // namespace platform
+}  // namespace pomegranate

package/native/ios/PomegranateJSI.h

@@ -0,0 +1,15 @@
+/**
+ * PomegranateDB — iOS JSI Bridge.
+ *
+ * React Native bridge module that installs the PomegranateDB JSI binding.
+ * JS calls PomegranateJSI.install() early in the app lifecycle (before
+ * using any NativeSQLiteAdapter) to register the global
+ * nativePomegranateCreateAdapter function into the JS runtime.
+ */
+
+#pragma once
+
+#import <React/RCTBridgeModule.h>
+
+@interface PomegranateJSI : NSObject <RCTBridgeModule>
+@end

package/native/ios/PomegranateJSI.mm

@@ -0,0 +1,59 @@
+/**
+ * PomegranateDB — iOS JSI Bridge implementation.
+ *
+ * Conforms to RCTBridgeModule and provides a synchronous install() method
+ * that registers nativePomegranateCreateAdapter into the JS runtime via JSI.
+ *
+ * Usage (JS side, early in app lifecycle):
+ *   import { NativeModules } from 'react-native';
+ *   NativeModules.PomegranateJSIBridge.install();
+ */
+
+#import "PomegranateJSI.h"
+#import <React/RCTBridge+Private.h>
+#import <React/RCTLog.h>
+#import <jsi/jsi.h>
+
+// Our C++ database bridge
+#import "Database.h"
+
+@implementation PomegranateJSI
+
+@synthesize bridge = _bridge;
+
+// ─── RCTBridgeModule boilerplate ──────────────────────────────────────────────
+
+RCT_EXPORT_MODULE(PomegranateJSIBridge)
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+// ─── install() ────────────────────────────────────────────────────────────────
+
+/**
+ * Synchronously installs the JSI global into the current JS runtime.
+ * Must be called before using NativeSQLiteAdapter.
+ * Returns @YES on success, @NO if the bridge doesn't expose a runtime.
+ */
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+    @try {
+        RCTCxxBridge *cxxBridge = (RCTCxxBridge *)_bridge;
+        if (!cxxBridge || !cxxBridge.runtime) {
+            RCTLogError(@"[PomegranateDB] Bridge or runtime is nil — cannot install JSI binding. "
+                        @"Are you using the JSC / Hermes runtime?");
+            return @(NO);
+        }
+
+        auto *runtime = (facebook::jsi::Runtime *)cxxBridge.runtime;
+        pomegranate::Database::install(*runtime);
+
+        RCTLogInfo(@"[PomegranateDB] Successfully installed JSI bindings!");
+        return @(YES);
+    } @catch (NSException *exception) {
+        RCTLogError(@"[PomegranateDB] Failed to install JSI bindings: %@", exception.reason);
+        return @(NO);
+    }
+}
+
+@end

package/native/shared/Database.cpp

@@ -0,0 +1,283 @@
+/**
+ * PomegranateDB — JSI Database Bridge implementation.
+ */
+
+#include "Database.h"
+#include <sstream>
+#include <vector>
+
+namespace pomegranate {
+
+using namespace facebook;
+
+// ─── Database lifecycle ──────────────────────────────────────────────────────
+
+Database::Database(jsi::Runtime &rt, const std::string &path) {
+    db_ = std::make_unique<SqliteDb>(path);
+
+    // Pragmas for performance
+    db_->execute("PRAGMA journal_mode = WAL");
+    db_->execute("PRAGMA synchronous = NORMAL");
+    db_->execute("PRAGMA busy_timeout = 5000");
+    db_->execute("PRAGMA temp_store = MEMORY");
+    db_->execute("PRAGMA cache_size = -8000");  // 8 MB
+
+    platform::consoleLog("PomegranateDB: opened " + path);
+}
+
+Database::~Database() {
+    close();
+}
+
+void Database::close() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    clearStmtCache();
+    db_.reset();
+}
+
+// ─── Statement cache ─────────────────────────────────────────────────────────
+
+sqlite3_stmt *Database::cachedPrepare(const std::string &sql) {
+    auto it = stmtCache_.find(sql);
+    if (it != stmtCache_.end()) {
+        return it->second;
+    }
+    sqlite3_stmt *stmt = db_->prepare(sql);
+    stmtCache_[sql] = stmt;
+    return stmt;
+}
+
+void Database::clearStmtCache() {
+    for (auto &pair : stmtCache_) {
+        sqlite3_finalize(pair.second);
+    }
+    stmtCache_.clear();
+}
+
+// ─── Argument binding ────────────────────────────────────────────────────────
+
+void Database::bindArgs(sqlite3_stmt *stmt, const jsi::Array &args, jsi::Runtime &rt) {
+    size_t count = args.size(rt);
+    for (size_t i = 0; i < count; i++) {
+        jsi::Value val = args.getValueAtIndex(rt, i);
+        int idx = static_cast<int>(i) + 1;  // SQLite 1-indexed
+
+        if (val.isNull() || val.isUndefined()) {
+            sqlite3_bind_null(stmt, idx);
+        } else if (val.isBool()) {
+            sqlite3_bind_int(stmt, idx, val.getBool() ? 1 : 0);
+        } else if (val.isNumber()) {
+            double num = val.getNumber();
+            // If it looks like an integer, bind as int for efficiency
+            if (num == static_cast<double>(static_cast<int64_t>(num)) && num >= -9007199254740992.0 &&
+                num <= 9007199254740992.0) {
+                sqlite3_bind_int64(stmt, idx, static_cast<int64_t>(num));
+            } else {
+                sqlite3_bind_double(stmt, idx, num);
+            }
+        } else if (val.isString()) {
+            std::string str = val.getString(rt).utf8(rt);
+            sqlite3_bind_text(stmt, idx, str.c_str(), static_cast<int>(str.size()), SQLITE_TRANSIENT);
+        } else {
+            throw jsi::JSError(rt, "PomegranateDB: unsupported binding type at index " + std::to_string(i));
+        }
+    }
+}
+
+// ─── Row reading ─────────────────────────────────────────────────────────────
+
+jsi::Object Database::rowToObject(sqlite3_stmt *stmt, jsi::Runtime &rt) {
+    jsi::Object obj(rt);
+    int columnCount = sqlite3_column_count(stmt);
+
+    for (int i = 0; i < columnCount; i++) {
+        const char *name = sqlite3_column_name(stmt, i);
+        int type = sqlite3_column_type(stmt, i);
+
+        switch (type) {
+            case SQLITE_NULL:
+                obj.setProperty(rt, name, jsi::Value::null());
+                break;
+            case SQLITE_INTEGER:
+                obj.setProperty(rt, name, jsi::Value(static_cast<double>(sqlite3_column_int64(stmt, i))));
+                break;
+            case SQLITE_FLOAT:
+                obj.setProperty(rt, name, jsi::Value(sqlite3_column_double(stmt, i)));
+                break;
+            case SQLITE_TEXT: {
+                const char *text = reinterpret_cast<const char *>(sqlite3_column_text(stmt, i));
+                obj.setProperty(rt, name, jsi::String::createFromUtf8(rt, text ? text : ""));
+                break;
+            }
+            case SQLITE_BLOB: {
+                // Store blobs as base64 strings? For simplicity, skip for now
+                const char *text = reinterpret_cast<const char *>(sqlite3_column_text(stmt, i));
+                obj.setProperty(rt, name, jsi::String::createFromUtf8(rt, text ? text : ""));
+                break;
+            }
+        }
+    }
+    return obj;
+}
+
+// ─── Database operations ─────────────────────────────────────────────────────
+
+void Database::execute(const std::string &sql, const jsi::Array &args, jsi::Runtime &rt) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!db_) {
+        throw jsi::JSError(rt, "PomegranateDB: database is closed");
+    }
+
+    sqlite3_stmt *stmt = cachedPrepare(sql);
+    SqliteStatement guard(stmt);
+    bindArgs(stmt, args, rt);
+
+    int result = sqlite3_step(stmt);
+    if (result != SQLITE_DONE && result != SQLITE_ROW) {
+        throw jsi::JSError(rt, "PomegranateDB: execute failed: " + db_->lastErrorMessage());
+    }
+}
+
+jsi::Array Database::query(const std::string &sql, const jsi::Array &args, jsi::Runtime &rt) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!db_) {
+        throw jsi::JSError(rt, "PomegranateDB: database is closed");
+    }
+
+    sqlite3_stmt *stmt = cachedPrepare(sql);
+    SqliteStatement guard(stmt);
+    bindArgs(stmt, args, rt);
+
+    std::vector<jsi::Object> rows;
+    while (true) {
+        int result = sqlite3_step(stmt);
+        if (result == SQLITE_ROW) {
+            rows.push_back(rowToObject(stmt, rt));
+        } else if (result == SQLITE_DONE) {
+            break;
+        } else {
+            throw jsi::JSError(rt, "PomegranateDB: query failed: " + db_->lastErrorMessage());
+        }
+    }
+
+    jsi::Array arr(rt, rows.size());
+    for (size_t i = 0; i < rows.size(); i++) {
+        arr.setValueAtIndex(rt, i, std::move(rows[i]));
+    }
+    return arr;
+}
+
+int Database::executeBatch(const jsi::Array &commands, jsi::Runtime &rt) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!db_) {
+        throw jsi::JSError(rt, "PomegranateDB: database is closed");
+    }
+
+    int totalChanges = 0;
+    size_t count = commands.size(rt);
+
+    db_->execute("BEGIN TRANSACTION");
+    try {
+        for (size_t i = 0; i < count; i++) {
+            jsi::Object cmd = commands.getValueAtIndex(rt, i).getObject(rt);
+            std::string sql = cmd.getProperty(rt, "sql").getString(rt).utf8(rt);
+            jsi::Array args = cmd.getProperty(rt, "args").getObject(rt).getArray(rt);
+
+            sqlite3_stmt *stmt = cachedPrepare(sql);
+            SqliteStatement guard(stmt);
+            bindArgs(stmt, args, rt);
+
+            int result = sqlite3_step(stmt);
+            if (result != SQLITE_DONE && result != SQLITE_ROW) {
+                throw std::runtime_error(db_->lastErrorMessage());
+            }
+            totalChanges += sqlite3_changes(db_->getHandle());
+        }
+        db_->execute("COMMIT");
+    } catch (...) {
+        db_->execute("ROLLBACK");
+        throw;
+    }
+
+    return totalChanges;
+}
+
+// ─── JSI Installation ────────────────────────────────────────────────────────
+
+void Database::install(jsi::Runtime &rt) {
+    auto createAdapter = jsi::Function::createFromHostFunction(
+        rt, jsi::PropNameID::forAscii(rt, "nativePomegranateCreateAdapter"),
+        1,  // dbName
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isString()) {
+                throw jsi::JSError(rt, "nativePomegranateCreateAdapter: expected database name string");
+            }
+
+            std::string dbName = args[0].getString(rt).utf8(rt);
+            std::string dbPath = platform::resolveDatabasePath(dbName);
+
+            auto database = std::make_shared<Database>(rt, dbPath);
+
+            jsi::Object adapter(rt);
+
+            // ─── execute(sql, args) ──────────────────────────────
+            adapter.setProperty(
+                rt, "execute",
+                jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "execute"), 2,
+                                                      [database](jsi::Runtime &rt, const jsi::Value &,
+                                                                 const jsi::Value *args, size_t count) -> jsi::Value {
+                                                          if (count < 2) {
+                                                              throw jsi::JSError(rt, "execute: expected (sql, args)");
+                                                          }
+                                                          std::string sql = args[0].getString(rt).utf8(rt);
+                                                          jsi::Array bindArgs = args[1].getObject(rt).getArray(rt);
+                                                          database->execute(sql, bindArgs, rt);
+                                                          return jsi::Value::undefined();
+                                                      }));
+
+            // ─── query(sql, args) → Array<Object> ───────────────
+            adapter.setProperty(
+                rt, "query",
+                jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "query"), 2,
+                                                      [database](jsi::Runtime &rt, const jsi::Value &,
+                                                                 const jsi::Value *args, size_t count) -> jsi::Value {
+                                                          if (count < 2) {
+                                                              throw jsi::JSError(rt, "query: expected (sql, args)");
+                                                          }
+                                                          std::string sql = args[0].getString(rt).utf8(rt);
+                                                          jsi::Array bindArgs = args[1].getObject(rt).getArray(rt);
+                                                          return database->query(sql, bindArgs, rt);
+                                                      }));
+
+            // ─── executeBatch(commands) → number ─────────────────
+            adapter.setProperty(rt, "executeBatch",
+                                jsi::Function::createFromHostFunction(
+                                    rt, jsi::PropNameID::forAscii(rt, "executeBatch"), 1,
+                                    [database](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args,
+                                               size_t count) -> jsi::Value {
+                                        if (count < 1) {
+                                            throw jsi::JSError(rt, "executeBatch: expected (commands)");
+                                        }
+                                        jsi::Array commands = args[0].getObject(rt).getArray(rt);
+                                        int changes = database->executeBatch(commands, rt);
+                                        return jsi::Value(changes);
+                                    }));
+
+            // ─── close() ────────────────────────────────────────
+            adapter.setProperty(
+                rt, "close",
+                jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, "close"), 0,
+                                                      [database](jsi::Runtime &rt, const jsi::Value &,
+                                                                 const jsi::Value *args, size_t count) -> jsi::Value {
+                                                          database->close();
+                                                          return jsi::Value::undefined();
+                                                      }));
+
+            return adapter;
+        });
+
+    rt.global().setProperty(rt, "nativePomegranateCreateAdapter", std::move(createAdapter));
+    platform::consoleLog("PomegranateDB: JSI bridge installed");
+}
+
+}  // namespace pomegranate

package/native/shared/Database.h

@@ -0,0 +1,84 @@
+/**
+ * PomegranateDB — JSI Database Bridge.
+ *
+ * Exposes a `nativePomegranateCreateAdapter` global function to JS.
+ * When called, creates a C++ SQLite database and returns a JSI object
+ * with methods: open, execute, query, executeBatch, close.
+ *
+ * This is the core performance layer — all calls are synchronous JSI,
+ * no bridge serialization, no async queue.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include "Sqlite.h"
+
+namespace pomegranate {
+
+using namespace facebook;
+
+/**
+ * Platform-specific functions that must be implemented per-platform
+ * (Android, iOS, etc.)
+ */
+namespace platform {
+/** Resolve a database name to an absolute path on disk. */
+std::string resolveDatabasePath(const std::string &dbName);
+
+/** Log to the platform console. */
+void consoleLog(const std::string &message);
+void consoleError(const std::string &message);
+}  // namespace platform
+
+/**
+ * The JSI database bridge.
+ *
+ * Calling Database::install(runtime) registers the global factory function.
+ * JS calls it to get adapter objects with synchronous database methods.
+ */
+class Database {
+   public:
+    Database(jsi::Runtime &rt, const std::string &path);
+    ~Database();
+
+    /** Install the global `nativePomegranateCreateAdapter` function. */
+    static void install(jsi::Runtime &rt);
+
+    // ─── Database operations ───────────────────────────────────────────
+
+    /** Execute a SQL statement with no return value. */
+    void execute(const std::string &sql, const jsi::Array &args, jsi::Runtime &rt);
+
+    /** Execute a query and return rows as an array of objects. */
+    jsi::Array query(const std::string &sql, const jsi::Array &args, jsi::Runtime &rt);
+
+    /** Execute multiple statements in a transaction. Returns rows affected. */
+    int executeBatch(const jsi::Array &commands, jsi::Runtime &rt);
+
+    /** Close the database. */
+    void close();
+
+   private:
+    std::unique_ptr<SqliteDb> db_;
+    std::mutex mutex_;
+    std::unordered_map<std::string, sqlite3_stmt *> stmtCache_;
+
+    /** Get or create a cached prepared statement. */
+    sqlite3_stmt *cachedPrepare(const std::string &sql);
+
+    /** Bind JSI arguments to a prepared statement. */
+    void bindArgs(sqlite3_stmt *stmt, const jsi::Array &args, jsi::Runtime &rt);
+
+    /** Read a result row into a JSI object. */
+    jsi::Object rowToObject(sqlite3_stmt *stmt, jsi::Runtime &rt);
+
+    /** Finalize all cached statements. */
+    void clearStmtCache();
+};
+
+}  // namespace pomegranate

package/native/shared/Sqlite.cpp

@@ -0,0 +1,61 @@
+/**
+ * PomegranateDB — Native SQLite C++ implementation.
+ */
+
+#include "Sqlite.h"
+#include <stdexcept>
+
+namespace pomegranate {
+
+SqliteDb::SqliteDb(const std::string &path) {
+    int result = sqlite3_open(path.c_str(), &db_);
+    if (result != SQLITE_OK) {
+        std::string error = db_ ? sqlite3_errmsg(db_) : "Unknown error";
+        if (db_) {
+            sqlite3_close(db_);
+            db_ = nullptr;
+        }
+        throw std::runtime_error("Failed to open database: " + error);
+    }
+}
+
+SqliteDb::~SqliteDb() {
+    if (db_) {
+        // Finalize any remaining statements
+        sqlite3_stmt *stmt = nullptr;
+        while ((stmt = sqlite3_next_stmt(db_, nullptr)) != nullptr) {
+            sqlite3_finalize(stmt);
+        }
+        sqlite3_close(db_);
+        db_ = nullptr;
+    }
+}
+
+void SqliteDb::execute(const std::string &sql) {
+    char *errMsg = nullptr;
+    int result = sqlite3_exec(db_, sql.c_str(), nullptr, nullptr, &errMsg);
+    if (result != SQLITE_OK) {
+        std::string error = errMsg ? errMsg : "Unknown error";
+        sqlite3_free(errMsg);
+        throw std::runtime_error("SQL execution failed: " + error);
+    }
+}
+
+sqlite3_stmt *SqliteDb::prepare(const std::string &sql) {
+    sqlite3_stmt *stmt = nullptr;
+    int result = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
+    if (result != SQLITE_OK) {
+        throw std::runtime_error("Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)) + " SQL: " + sql);
+    }
+    return stmt;
+}
+
+std::string SqliteDb::lastErrorMessage() const {
+    return db_ ? sqlite3_errmsg(db_) : "No database";
+}
+
+int SqliteDb::lastErrorCode() const {
+    return db_ ? sqlite3_extended_errcode(db_) : 0;
+}
+
+}  // namespace pomegranate