Durable wallet key-value storage using SQLite

501    sqlite3_stmt* stmt;
502    if (overwrite) {
503        stmt = m_overwrite_stmt;
504    } else {
505        stmt = m_insert_stmt;
506    }
507
508    // Bind: leftmost parameter in statement is index 1
509    // Insert index 1 is key, 2 is value
510    if (!BindBlobToStatement(stmt, 1, key, "key")) return false;
511    if (!BindBlobToStatement(stmt, 2, value, "value")) return false;
512
513    // Acquire semaphore if not previously acquired when creating a transaction.
514    if (!m_txn) m_database.m_write_semaphore.acquire();
515
516    // Execute
517    int res = sqlite3_step(stmt);
518    sqlite3_clear_bindings(stmt);
519    sqlite3_reset(stmt);
520    if (res != SQLITE_DONE) {
521        LogWarning("Unable to execute write statement: %s", sqlite3_errstr(res));
522    }
523
524    if (!m_txn) m_database.m_write_semaphore.release();
525
526    return res == SQLITE_DONE;
527}
528
529bool SQLiteBatch::ExecStatement(sqlite3_stmt* stmt, std::span<const std::byte> blob)
530{
531    if (!m_database.m_db) return false;
532    assert(stmt);
533
534    // Bind: leftmost parameter in statement is index 1
535    if (!BindBlobToStatement(stmt, 1, blob, "key")) return false;
536
537    // Acquire semaphore if not previously acquired when creating a transaction.
538    if (!m_txn) m_database.m_write_semaphore.acquire();
539
540    // Execute
541    int res = sqlite3_step(stmt);
542    sqlite3_clear_bindings(stmt);
543    sqlite3_reset(stmt);
544    if (res != SQLITE_DONE) {
545        LogWarning("Unable to execute exec statement: %s", sqlite3_errstr(res));
546    }
547
548    if (!m_txn) m_database.m_write_semaphore.release();
549
550    return res == SQLITE_DONE;
551}
552
553bool SQLiteBatch::EraseKey(DataStream&& key)
554{
555    return ExecStatement(m_delete_stmt, key);
556}
557
558bool SQLiteBatch::ErasePrefix(std::span<const std::byte> prefix)
559{
560    return ExecStatement(m_delete_prefix_stmt, prefix);
561}
562
563bool SQLiteBatch::HasKey(DataStream&& key)
564{
565    if (!m_database.m_db) return false;
566    assert(m_read_stmt);
567
568    // Bind: leftmost parameter in statement is index 1
569    if (!BindBlobToStatement(m_read_stmt, 1, key, "key")) return false;
570    int res = sqlite3_step(m_read_stmt);
571    sqlite3_clear_bindings(m_read_stmt);
572    sqlite3_reset(m_read_stmt);
573    return res == SQLITE_ROW;
574}
575
576DatabaseCursor::Status SQLiteCursor::Next(DataStream& key, DataStream& value)
577{
578    int res = sqlite3_step(m_cursor_stmt);
579    if (res == SQLITE_DONE) {
580        return Status::DONE;
581    }
582    if (res != SQLITE_ROW) {
583        LogWarning("Unable to execute cursor step: %s", sqlite3_errstr(res));
584        return Status::FAIL;
585    }
586
587    key.clear();
588    value.clear();
589
590    // Leftmost column in result is index 0
591    key.write(SpanFromBlob(m_cursor_stmt, 0));
592    value.write(SpanFromBlob(m_cursor_stmt, 1));
593    return Status::MORE;
594}
595
596SQLiteCursor::~SQLiteCursor()
597{
598    sqlite3_clear_bindings(m_cursor_stmt);
599    sqlite3_reset(m_cursor_stmt);
600    int res = sqlite3_finalize(m_cursor_stmt);
601    if (res != SQLITE_OK) {
602        LogWarning("Cursor closed but could not finalize cursor statement: %s",
603                   sqlite3_errstr(res));
604    }
605}
606
607std::unique_ptr<DatabaseCursor> SQLiteBatch::GetNewCursor()
608{
609    if (!m_database.m_db) return nullptr;
610    auto cursor = std::make_unique<SQLiteCursor>();
611
612    const char* stmt_text = "SELECT key, value FROM main";
613    int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, &cursor->m_cursor_stmt, nullptr);
614    if (res != SQLITE_OK) {
615        throw std::runtime_error(strprintf(
616            "%s: Failed to setup cursor SQL statement: %s\n", __func__, sqlite3_errstr(res)));
617    }
618
619    return cursor;
620}
621
622std::unique_ptr<DatabaseCursor> SQLiteBatch::GetNewPrefixCursor(std::span<const std::byte> prefix)
623{
624    if (!m_database.m_db) return nullptr;
625
626    // To get just the records we want, the SQL statement does a comparison of the binary data
627    // where the data must be greater than or equal to the prefix, and less than
628    // the prefix incremented by one (when interpreted as an integer)
629    std::vector<std::byte> start_range(prefix.begin(), prefix.end());
630    std::vector<std::byte> end_range(prefix.begin(), prefix.end());
631    auto it = end_range.rbegin();
632    for (; it != end_range.rend(); ++it) {
633        if (*it == std::byte(std::numeric_limits<unsigned char>::max())) {
634            *it = std::byte(0);
635            continue;
636        }
637        *it = std::byte(std::to_integer<unsigned char>(*it) + 1);
638        break;
639    }
640    if (it == end_range.rend()) {
641        // If the prefix is all 0xff bytes, clear end_range as we won't need it
642        end_range.clear();
643    }
644
645    auto cursor = std::make_unique<SQLiteCursor>(start_range, end_range);
646    if (!cursor) return nullptr;
647
648    const char* stmt_text = end_range.empty() ? "SELECT key, value FROM main WHERE key >= ?" :
649                            "SELECT key, value FROM main WHERE key >= ? AND key < ?";
650    int res = sqlite3_prepare_v2(m_database.m_db, stmt_text, -1, &cursor->m_cursor_stmt, nullptr);
651    if (res != SQLITE_OK) {
652        throw std::runtime_error(strprintf(
653            "SQLiteDatabase: Failed to setup cursor SQL statement: %s\n", sqlite3_errstr(res)));
654    }
655
656    if (!BindBlobToStatement(cursor->m_cursor_stmt, 1, cursor->m_prefix_range_start, "prefix_start")) return nullptr;
657    if (!end_range.empty()) {
658        if (!BindBlobToStatement(cursor->m_cursor_stmt, 2, cursor->m_prefix_range_end, "prefix_end")) return nullptr;
659    }
660
661    return cursor;
662}
663
664bool SQLiteBatch::TxnBegin()
665{
666    if (!m_database.m_db || m_txn) return false;
667    m_database.m_write_semaphore.acquire();
668    Assert(!m_database.HasActiveTxn());
669    int res = Assert(m_exec_handler)->Exec(m_database, "BEGIN TRANSACTION");
670    if (res != SQLITE_OK) {
671        LogWarning("SQLiteBatch: Failed to begin the transaction");
672        m_database.m_write_semaphore.release();
673    } else {
674        m_txn = true;
675    }
676    return res == SQLITE_OK;
677}
678
679bool SQLiteBatch::TxnCommit()
680{
681    if (!m_database.m_db || !m_txn) return false;
682    Assert(m_database.HasActiveTxn());
683    int res = Assert(m_exec_handler)->Exec(m_database, "COMMIT TRANSACTION");
684    if (res != SQLITE_OK) {
685        LogWarning("SQLiteBatch: Failed to commit the transaction");
686    } else {
687        m_txn = false;
688        m_database.m_write_semaphore.release();
689    }
690    return res == SQLITE_OK;
691}
692
693bool SQLiteBatch::TxnAbort()
694{
695    if (!m_database.m_db || !m_txn) return false;
696    Assert(m_database.HasActiveTxn());
697    int res = Assert(m_exec_handler)->Exec(m_database, "ROLLBACK TRANSACTION");
698    if (res != SQLITE_OK) {
699        LogWarning("SQLiteBatch: Failed to abort the transaction");
700    } else {
701        m_txn = false;
702        m_database.m_write_semaphore.release();
703    }
704    return res == SQLITE_OK;
705}
706
707std::unique_ptr<SQLiteDatabase> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error)
708{
709    try {
710        fs::path data_file = SQLiteDataFile(path);
711        auto db = std::make_unique<SQLiteDatabase>(data_file.parent_path(), data_file, options);
712        if (options.verify && !db->Verify(error)) {
713            status = DatabaseStatus::FAILED_VERIFY;
714            return nullptr;
715        }
716        status = DatabaseStatus::SUCCESS;
717        return db;
718    } catch (const std::runtime_error& e) {
719        status = DatabaseStatus::FAILED_LOAD;
720        error = Untranslated(e.what());
721        return nullptr;
722    }
723}
724
725InMemoryWalletDatabase::InMemoryWalletDatabase()
726    : SQLiteDatabase(fs::path{}, fs::path{":memory:"}, DatabaseOptions(), SQLITE_OPEN_MEMORY)
727{}
728
729std::unique_ptr<WalletDatabase> MakeInMemoryWalletDatabase()
730{
731    return std::make_unique<InMemoryWalletDatabase>();
732}
733
734std::string SQLiteDatabaseVersion()
735{
736    return std::string(sqlite3_libversion());
737}
738} // namespace wallet
739