react-native-nitro-storage 0.12.0 → 0.14.0

package/android/src/main/java/com/nitrostorage/DiskSqliteStore.kt

@@ -2,21 +2,49 @@ package com.nitrostorage
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.database.DatabaseErrorHandler
 import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteDatabaseCorruptException
+import android.database.sqlite.SQLiteException
+import java.io.ByteArrayOutputStream
 import java.io.File
 
+internal typealias DiskDatabaseOpener = (path: String, flags: Int) -> SQLiteDatabase
+
+internal fun openDiskDatabase(path: String, flags: Int): SQLiteDatabase {
+    return SQLiteDatabase.openDatabase(path, null, flags, DatabaseErrorHandler { })
+}
+
+internal fun openDiskDatabaseWithWalFallback(
+    path: String,
+    opener: DiskDatabaseOpener,
+): SQLiteDatabase {
+    val flags = SQLiteDatabase.CREATE_IF_NECESSARY or SQLiteDatabase.NO_LOCALIZED_COLLATORS
+    return try {
+        opener(path, flags or SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING)
+    } catch (walError: SQLiteDatabaseCorruptException) {
+        throw walError
+    } catch (walError: SQLiteException) {
+        try {
+            opener(path, flags)
+        } catch (fallbackError: Exception) {
+            walError.addSuppressed(fallbackError)
+            throw walError
+        }
+    }
+}
+
 internal class DiskSqliteStore(
     context: Context,
     private val legacyPreferences: SharedPreferences,
+    opener: DiskDatabaseOpener = ::openDiskDatabase,
 ) {
     private val db: SQLiteDatabase =
-        SQLiteDatabase.openOrCreateDatabase(File(context.filesDir, DATABASE_NAME), null)
+        openDiskDatabaseWithWalFallback(databaseFile(context).path, opener)
 
     init {
         try {
-            // PRAGMA journal_mode returns a row; Android forbids result-bearing SQL on execSQL.
-            db.rawQuery("PRAGMA journal_mode=WAL", null).close()
-            db.execSQL("PRAGMA synchronous=NORMAL")
+            db.execSQL(synchronousPragmaFor(queryPragma("PRAGMA journal_mode")))
             db.execSQL(
                 "CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY NOT NULL, value TEXT NOT NULL)",
             )
@@ -30,6 +58,17 @@ internal class DiskSqliteStore(
         }
     }
 
+    private fun queryPragma(sql: String): String? {
+        return db.rawQuery(sql, null).use { cursor ->
+            if (cursor.moveToFirst()) cursor.getString(0) else null
+        }
+    }
+
+    @Synchronized
+    fun close() {
+        db.close()
+    }
+
     @Synchronized
     fun set(key: String, value: String) {
         db.execSQL(
@@ -40,9 +79,39 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun get(key: String): String? {
-        db.rawQuery("SELECT value FROM kv WHERE key = ? LIMIT 1", arrayOf(key)).use { cursor ->
-            return if (cursor.moveToFirst()) cursor.getString(0) else null
+        db.rawQuery(
+            "SELECT length(CAST(value AS BLOB)), " +
+                "CASE WHEN length(CAST(value AS BLOB)) <= $VALUE_CHUNK_BYTES THEN value END " +
+                "FROM kv WHERE key = ? LIMIT 1",
+            arrayOf(key),
+        ).use { cursor ->
+            if (!cursor.moveToFirst()) {
+                return null
+            }
+            if (!cursor.isNull(1)) {
+                return cursor.getString(1)
+            }
+            return readLargeValue(key, cursor.getLong(0))
+        }
+    }
+
+    private fun readLargeValue(key: String, byteCount: Long): String {
+        val bytes = ByteArrayOutputStream(byteCount.coerceAtMost(Int.MAX_VALUE.toLong()).toInt())
+        var offset = 1L
+        while (offset <= byteCount) {
+            val chunk = db.rawQuery(
+                "SELECT substr(CAST(value AS BLOB), ?, $VALUE_CHUNK_BYTES) FROM kv WHERE key = ?",
+                arrayOf(offset.toString(), key),
+            ).use { cursor ->
+                if (cursor.moveToFirst()) cursor.getBlob(0) else null
+            }
+            if (chunk == null || chunk.isEmpty()) {
+                break
+            }
+            bytes.write(chunk, 0, chunk.size)
+            offset += chunk.size
         }
+        return String(bytes.toByteArray(), Charsets.UTF_8)
     }
 
     @Synchronized
@@ -61,17 +130,13 @@ internal class DiskSqliteStore(
     @Synchronized
     fun setBatch(keys: Array<String>, values: Array<String>) {
         val count = minOf(keys.size, values.size)
-        db.beginTransaction()
-        try {
+        inTransaction {
             for (index in 0 until count) {
                 db.execSQL(
                     "INSERT OR REPLACE INTO kv(key, value) VALUES(?, ?)",
                     arrayOf(keys[index], values[index]),
                 )
             }
-            db.setTransactionSuccessful()
-        } finally {
-            db.endTransaction()
         }
     }
 
@@ -82,14 +147,10 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun removeBatch(keys: Array<String>) {
-        db.beginTransaction()
-        try {
+        inTransaction {
             for (key in keys) {
                 db.execSQL("DELETE FROM kv WHERE key = ?", arrayOf(key))
             }
-            db.setTransactionSuccessful()
-        } finally {
-            db.endTransaction()
         }
         removeLegacyKeys(keys.asIterable())
     }
@@ -107,19 +168,12 @@ internal class DiskSqliteStore(
 
     @Synchronized
     fun getKeysByPrefix(prefix: String): Array<String> {
-        val pattern = buildString {
-            for (character in prefix) {
-                // LIKE stops at NUL; startsWith below checks the complete prefix.
-                if (character == '\u0000') break
-                if (character == '%' || character == '_' || character == '\\') append('\\')
-                append(character)
-            }
-            append('%')
+        val cursor = if (hasUnpairedSurrogate(prefix)) {
+            db.rawQuery("SELECT key FROM kv WHERE key LIKE ? ESCAPE '\\'", arrayOf(likePattern(prefix)))
+        } else {
+            db.rawQuery("SELECT key FROM kv WHERE key >= ?1 AND key < (?1 || x'FF')", arrayOf(prefix))
         }
-        db.rawQuery(
-            "SELECT key FROM kv WHERE key LIKE ? ESCAPE '\\'",
-            arrayOf(pattern),
-        ).use { cursor ->
+        cursor.use {
             val keys = ArrayList<String>(cursor.count)
             while (cursor.moveToNext()) {
                 val key = cursor.getString(0)
@@ -156,8 +210,7 @@ internal class DiskSqliteStore(
             }
         }
 
-        db.beginTransaction()
-        try {
+        inTransaction {
             for ((key, value) in legacyPreferences.all) {
                 if (value is String) {
                     db.execSQL(
@@ -170,9 +223,25 @@ internal class DiskSqliteStore(
                 "INSERT OR REPLACE INTO meta(k, v) VALUES(?, ?)",
                 arrayOf(PREFS_MIGRATION_KEY, "1"),
             )
+        }
+    }
+
+    private inline fun inTransaction(block: () -> Unit) {
+        db.beginTransaction()
+        var failure: Throwable? = null
+        try {
+            block()
             db.setTransactionSuccessful()
+        } catch (error: Throwable) {
+            failure = error
+            throw error
         } finally {
-            db.endTransaction()
+            try {
+                db.endTransaction()
+            } catch (error: SQLiteException) {
+                val primary = failure ?: throw error
+                primary.addSuppressed(error)
+            }
         }
     }
 
@@ -186,8 +255,52 @@ internal class DiskSqliteStore(
         editor.apply()
     }
 
-    private companion object {
-        const val DATABASE_NAME = "nitro-storage-disk.sqlite"
-        const val PREFS_MIGRATION_KEY = "prefs_v1"
+    companion object {
+        private const val DATABASE_NAME = "nitro-storage-disk.sqlite"
+        private const val PREFS_MIGRATION_KEY = "prefs_v1"
+        private const val VALUE_CHUNK_BYTES = 512 * 1024
+
+        fun databaseFile(context: Context): File = File(context.filesDir, DATABASE_NAME)
+
+        fun deleteDatabaseFiles(context: Context) {
+            SQLiteDatabase.deleteDatabase(databaseFile(context))
+        }
+    }
+}
+
+private fun hasUnpairedSurrogate(value: String): Boolean {
+    var index = 0
+    while (index < value.length) {
+        val character = value[index]
+        if (Character.isHighSurrogate(character)) {
+            if (index + 1 >= value.length || !Character.isLowSurrogate(value[index + 1])) {
+                return true
+            }
+            index += 2
+        } else if (Character.isLowSurrogate(character)) {
+            return true
+        } else {
+            index += 1
+        }
+    }
+    return false
+}
+
+private fun likePattern(prefix: String): String {
+    return buildString {
+        for (character in prefix) {
+            if (character == '\u0000') break
+            if (character == '%' || character == '_' || character == '\\') append('\\')
+            append(character)
+        }
+        append('%')
+    }
+}
+
+internal fun synchronousPragmaFor(journalMode: String?): String {
+    return if (journalMode.equals("wal", ignoreCase = true)) {
+        "PRAGMA synchronous=NORMAL"
+    } else {
+        "PRAGMA synchronous=FULL"
     }
 }

package/cpp/bindings/HybridStorage.cpp

@@ -434,6 +434,7 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
 }
 
 void HybridStorage::removeByPrefix(const std::string& prefix, double scope) {
+    toScope(scope);
     if (prefix.empty()) {
         return;
     }
@@ -462,17 +463,23 @@ void HybridStorage::setSecureAccessControl(double level) {
         throw std::runtime_error("NitroStorage: Invalid access control level");
     }
     ensureAdapter();
-    nativeAdapter_->setSecureAccessControl(intLevel);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setSecureAccessControl(intLevel); },
+        "Secure access control");
 }
 
 void HybridStorage::setSecureWritesAsync(bool enabled) {
     ensureAdapter();
-    nativeAdapter_->setSecureWritesAsync(enabled);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setSecureWritesAsync(enabled); },
+        "Secure write mode");
 }
 
 void HybridStorage::setKeychainAccessGroup(const std::string& group) {
     ensureAdapter();
-    nativeAdapter_->setKeychainAccessGroup(group);
+    runAdapterOperation(
+        [&] { nativeAdapter_->setKeychainAccessGroup(group); },
+        "Keychain access group");
 }
 
 // --- Biometric ---
@@ -517,7 +524,8 @@ void HybridStorage::deleteSecureBiometric(const std::string& key) {
 
 bool HybridStorage::hasSecureBiometric(const std::string& key) {
     ensureAdapter();
-    return nativeAdapter_->hasSecureBiometric(key);
+    return runAdapterOperation(
+        [&] { return nativeAdapter_->hasSecureBiometric(key); }, "Biometric has");
 }
 
 void HybridStorage::clearSecureBiometric() {

package/cpp/core/SqliteDiskStore.cpp

@@ -3,10 +3,12 @@
 #include <sqlite3.h>
 
 #include <algorithm>
+#include <cerrno>
 #include <cstdlib>
 #include <filesystem>
 #include <memory>
 #include <stdexcept>
+#include <system_error>
 
 namespace NitroStorage {
 namespace {
@@ -21,13 +23,19 @@ std::mutex& sharedMutex() {
     return mutex;
 }
 
-const char* storageErrorTag(int code) {
+const char* storageErrorTag(sqlite3* db, int code) {
     switch (code & 0xff) {
         case SQLITE_FULL:
             return "[nitro-error:storage_full] ";
         case SQLITE_CORRUPT:
         case SQLITE_NOTADB:
             return "[nitro-error:storage_corruption] ";
+        case SQLITE_IOERR: {
+            const int systemError = db != nullptr ? sqlite3_system_errno(db) : 0;
+            return systemError == ENOSPC || systemError == EDQUOT
+                ? "[nitro-error:storage_full] "
+                : "";
+        }
         default:
             return "";
     }
@@ -36,21 +44,22 @@ const char* storageErrorTag(int code) {
 [[noreturn]] void throwSqlite(sqlite3* db, const char* operation, int code) {
     const char* message = db != nullptr ? sqlite3_errmsg(db) : sqlite3_errstr(code);
     throw std::runtime_error(
-        std::string(storageErrorTag(code)) + "NitroStorage: Disk SQLite " + operation +
+        std::string(storageErrorTag(db, code)) + "NitroStorage: Disk SQLite " + operation +
         " failed: " + (message != nullptr ? message : "unknown error")
     );
 }
 
 void bindText(sqlite3_stmt* stmt, int index, const std::string& value) {
-    const int rc = sqlite3_bind_text(
+    const int rc = sqlite3_bind_text64(
         stmt,
         index,
         value.data(),
-        static_cast<int>(value.size()),
-        SQLITE_TRANSIENT
+        static_cast<sqlite3_uint64>(value.size()),
+        SQLITE_TRANSIENT,
+        SQLITE_UTF8
     );
     if (rc != SQLITE_OK) {
-        throw std::runtime_error("NitroStorage: Disk SQLite bind failed");
+        throwSqlite(sqlite3_db_handle(stmt), "bind", rc);
     }
 }
 
@@ -69,16 +78,23 @@ std::string escapeLikePrefix(const std::string& prefix) {
     return escaped;
 }
 
+std::optional<std::string> prefixUpperBound(const std::string& prefix) {
+    std::string upper = prefix;
+    while (!upper.empty() && static_cast<unsigned char>(upper.back()) == 0xFF) {
+        upper.pop_back();
+    }
+    if (upper.empty()) {
+        return std::nullopt;
+    }
+    upper.back() = static_cast<char>(static_cast<unsigned char>(upper.back()) + 1);
+    return upper;
+}
+
 } // namespace
 
 SqliteDiskStore::SqliteDiskStore(std::string path) : path_(std::move(path)) {
     std::lock_guard<std::mutex> lock(mutex_);
-    try {
-        openLocked();
-    } catch (...) {
-        closeLocked();
-        throw;
-    }
+    reopenLocked();
 }
 
 SqliteDiskStore::~SqliteDiskStore() {
@@ -95,6 +111,98 @@ SqliteDiskStore& SqliteDiskStore::shared(const std::string& path) {
     return *store;
 }
 
+bool SqliteDiskStore::isValidUtf8(const std::string& value) {
+    const auto* bytes = reinterpret_cast<const unsigned char*>(value.data());
+    const size_t size = value.size();
+    size_t index = 0;
+    while (index < size) {
+        const unsigned char lead = bytes[index];
+        size_t length = 0;
+        unsigned int minimum = 0;
+        unsigned int codePoint = 0;
+        if (lead < 0x80) {
+            index += 1;
+            continue;
+        } else if ((lead & 0xE0) == 0xC0) {
+            length = 2;
+            minimum = 0x80;
+            codePoint = lead & 0x1Fu;
+        } else if ((lead & 0xF0) == 0xE0) {
+            length = 3;
+            minimum = 0x800;
+            codePoint = lead & 0x0Fu;
+        } else if ((lead & 0xF8) == 0xF0) {
+            length = 4;
+            minimum = 0x10000;
+            codePoint = lead & 0x07u;
+        } else {
+            return false;
+        }
+        if (size - index < length) {
+            return false;
+        }
+        for (size_t offset = 1; offset < length; ++offset) {
+            const unsigned char continuation = bytes[index + offset];
+            if ((continuation & 0xC0) != 0x80) {
+                return false;
+            }
+            codePoint = (codePoint << 6) | (continuation & 0x3Fu);
+        }
+        if (codePoint < minimum || codePoint > 0x10FFFF || (codePoint >= 0xD800 && codePoint <= 0xDFFF)) {
+            return false;
+        }
+        index += length;
+    }
+    return true;
+}
+
+void SqliteDiskStore::recreateShared(const std::string& path) {
+    std::lock_guard<std::mutex> lock(sharedMutex());
+    auto& store = sharedStore();
+    if (store && store->path() == path) {
+        store->recreate();
+        return;
+    }
+    store.reset();
+    removeDatabaseFiles(path);
+    store = std::make_unique<SqliteDiskStore>(path);
+}
+
+void SqliteDiskStore::removeDatabaseFiles(const std::string& path) {
+    for (const char* suffix : {"", "-wal", "-shm", "-journal"}) {
+        std::error_code error;
+        std::filesystem::remove(path + suffix, error);
+        if (error) {
+            throw std::runtime_error(
+                "NitroStorage: Disk SQLite clear failed: cannot delete the database file: " +
+                error.message()
+            );
+        }
+    }
+}
+
+void SqliteDiskStore::recreate() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    closeLocked();
+    removeDatabaseFiles(path_);
+    reopenLocked();
+}
+
+void SqliteDiskStore::reopenLocked() {
+    try {
+        openLocked();
+    } catch (...) {
+        closeLocked();
+        throw;
+    }
+}
+
+void SqliteDiskStore::ensureOpenLocked() {
+    if (db_ == nullptr) {
+        reopenLocked();
+    }
+}
+
 void SqliteDiskStore::resetShared() {
     std::lock_guard<std::mutex> lock(sharedMutex());
     sharedStore().reset();
@@ -121,17 +229,22 @@ void SqliteDiskStore::openLocked() {
     const int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
     const int openRc = sqlite3_open_v2(path_.c_str(), &db, flags, nullptr);
     if (openRc != SQLITE_OK) {
-        const int code = openRc;
-        if (db != nullptr) {
-            sqlite3_close(db);
+        try {
+            throwSqlite(db, "open", openRc);
+        } catch (...) {
+            if (db != nullptr) {
+                sqlite3_close(db);
+            }
+            throw;
         }
-        throwSqlite(nullptr, "open", code);
     }
     db_ = db;
     sqlite3_busy_timeout(db_, 5000);
     execLocked("PRAGMA journal_mode=WAL;");
     execLocked("PRAGMA synchronous=NORMAL;");
     execLocked("PRAGMA temp_store=MEMORY;");
+    execLocked("PRAGMA wal_autocheckpoint=1000;");
+    execLocked("PRAGMA journal_size_limit=32768;");
     execLocked(
         "CREATE TABLE IF NOT EXISTS kv ("
         "key TEXT PRIMARY KEY NOT NULL,"
@@ -149,7 +262,9 @@ void SqliteDiskStore::openLocked() {
     removeStmt_ = prepareLocked("DELETE FROM kv WHERE key = ?1;");
     hasStmt_ = prepareLocked("SELECT 1 FROM kv WHERE key = ?1 LIMIT 1;");
     keysStmt_ = prepareLocked("SELECT key FROM kv;");
-    prefixStmt_ = prepareLocked("SELECT key FROM kv WHERE key LIKE ?1 ESCAPE '\\';");
+    prefixRangeStmt_ = prepareLocked("SELECT key FROM kv WHERE key >= ?1 AND key < ?2;");
+    prefixFromStmt_ = prepareLocked("SELECT key FROM kv WHERE key >= ?1;");
+    prefixLikeStmt_ = prepareLocked("SELECT key FROM kv WHERE key LIKE ?1 ESCAPE '\\';");
     sizeStmt_ = prepareLocked("SELECT COUNT(*) FROM kv;");
     clearStmt_ = prepareLocked("DELETE FROM kv;");
     insertAbsentStmt_ = prepareLocked(
@@ -171,7 +286,9 @@ void SqliteDiskStore::closeLocked() {
     finalize(removeStmt_);
     finalize(hasStmt_);
     finalize(keysStmt_);
-    finalize(prefixStmt_);
+    finalize(prefixRangeStmt_);
+    finalize(prefixFromStmt_);
+    finalize(prefixLikeStmt_);
     finalize(sizeStmt_);
     finalize(clearStmt_);
     finalize(insertAbsentStmt_);
@@ -192,9 +309,16 @@ void SqliteDiskStore::execLocked(const char* sql) {
 
 void SqliteDiskStore::limitPageCountForTesting(int pages) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     execLocked(("PRAGMA max_page_count=" + std::to_string(pages) + ";").c_str());
 }
 
+void SqliteDiskStore::limitValueLengthForTesting(int bytes) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
+    sqlite3_limit(db_, SQLITE_LIMIT_LENGTH, bytes);
+}
+
 void SqliteDiskStore::beginLocked() {
     execLocked("BEGIN IMMEDIATE;");
 }
@@ -264,21 +388,25 @@ void SqliteDiskStore::removeLocked(const std::string& key) {
 
 void SqliteDiskStore::set(const std::string& key, const std::string& value) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     setLocked(key, value);
 }
 
 std::optional<std::string> SqliteDiskStore::get(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     return getLocked(key);
 }
 
 void SqliteDiskStore::remove(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     removeLocked(key);
 }
 
 bool SqliteDiskStore::has(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     sqlite3_reset(hasStmt_);
     sqlite3_clear_bindings(hasStmt_);
     bindText(hasStmt_, 1, key);
@@ -298,6 +426,7 @@ void SqliteDiskStore::setBatch(
     const std::vector<std::string>& values
 ) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     beginLocked();
     try {
         const size_t count = std::min(keys.size(), values.size());
@@ -315,6 +444,7 @@ std::vector<std::optional<std::string>> SqliteDiskStore::getBatch(
     const std::vector<std::string>& keys
 ) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     std::vector<std::optional<std::string>> results;
     results.reserve(keys.size());
     for (const auto& key : keys) {
@@ -325,6 +455,7 @@ std::vector<std::optional<std::string>> SqliteDiskStore::getBatch(
 
 void SqliteDiskStore::removeBatch(const std::vector<std::string>& keys) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     beginLocked();
     try {
         for (const auto& key : keys) {
@@ -339,6 +470,7 @@ void SqliteDiskStore::removeBatch(const std::vector<std::string>& keys) {
 
 std::vector<std::string> SqliteDiskStore::getAllKeys() {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     sqlite3_reset(keysStmt_);
     std::vector<std::string> keys;
     while (true) {
@@ -363,21 +495,30 @@ std::vector<std::string> SqliteDiskStore::getAllKeys() {
 
 std::vector<std::string> SqliteDiskStore::getKeysByPrefix(const std::string& prefix) {
     std::lock_guard<std::mutex> lock(mutex_);
-    sqlite3_reset(prefixStmt_);
-    sqlite3_clear_bindings(prefixStmt_);
-    bindText(prefixStmt_, 1, escapeLikePrefix(prefix));
+    ensureOpenLocked();
+    const bool useRange = isValidUtf8(prefix);
+    const auto upperBound = useRange ? prefixUpperBound(prefix) : std::nullopt;
+    sqlite3_stmt* stmt = !useRange
+        ? prefixLikeStmt_
+        : upperBound.has_value() ? prefixRangeStmt_ : prefixFromStmt_;
+    sqlite3_reset(stmt);
+    sqlite3_clear_bindings(stmt);
+    bindText(stmt, 1, useRange ? prefix : escapeLikePrefix(prefix));
+    if (upperBound.has_value()) {
+        bindText(stmt, 2, *upperBound);
+    }
     std::vector<std::string> keys;
     while (true) {
-        const int rc = sqlite3_step(prefixStmt_);
+        const int rc = sqlite3_step(stmt);
         if (rc == SQLITE_DONE) {
             break;
         }
         if (rc != SQLITE_ROW) {
-            sqlite3_reset(prefixStmt_);
+            sqlite3_reset(stmt);
             throwSqlite(db_, "getKeysByPrefix", rc);
         }
-        const unsigned char* text = sqlite3_column_text(prefixStmt_, 0);
-        const int bytes = sqlite3_column_bytes(prefixStmt_, 0);
+        const unsigned char* text = sqlite3_column_text(stmt, 0);
+        const int bytes = sqlite3_column_bytes(stmt, 0);
         std::string key(
             text != nullptr ? reinterpret_cast<const char*>(text) : "",
             static_cast<size_t>(bytes)
@@ -386,12 +527,13 @@ std::vector<std::string> SqliteDiskStore::getKeysByPrefix(const std::string& pre
             keys.push_back(std::move(key));
         }
     }
-    sqlite3_reset(prefixStmt_);
+    sqlite3_reset(stmt);
     return keys;
 }
 
 size_t SqliteDiskStore::size() {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     sqlite3_reset(sizeStmt_);
     const int rc = sqlite3_step(sizeStmt_);
     if (rc != SQLITE_ROW) {
@@ -405,6 +547,7 @@ size_t SqliteDiskStore::size() {
 
 void SqliteDiskStore::clear() {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     sqlite3_reset(clearStmt_);
     const int rc = sqlite3_step(clearStmt_);
     sqlite3_reset(clearStmt_);
@@ -463,6 +606,7 @@ void SqliteDiskStore::migrateIfAbsent(
         return;
     }
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     beginLocked();
     try {
         insertAbsentLocked(entries);
@@ -475,6 +619,7 @@ void SqliteDiskStore::migrateIfAbsent(
 
 bool SqliteDiskStore::hasMigrationMarker(const std::string& name) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     return hasMigrationMarkerLocked(name);
 }
 
@@ -483,6 +628,7 @@ void SqliteDiskStore::migrateOnce(
     const std::vector<std::pair<std::string, std::string>>& entries
 ) {
     std::lock_guard<std::mutex> lock(mutex_);
+    ensureOpenLocked();
     beginLocked();
     try {
         if (hasMigrationMarkerLocked(name)) {