Line data    Source code

       1             : // Copyright (c) 2020-2021 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_WALLET_SQLITE_H
       6             : #define BITCOIN_WALLET_SQLITE_H
       7             : 
       8             : #include <sync.h>
       9             : #include <wallet/db.h>
      10             : 
      11             : struct bilingual_str;
      12             : 
      13             : struct sqlite3_stmt;
      14             : struct sqlite3;
      15             : 
      16             : namespace wallet {
      17             : class SQLiteDatabase;
      18             : 
      19             : /** RAII class that provides a database cursor */
      20             : class SQLiteCursor : public DatabaseCursor
      21             : {
      22             : public:
      23           0 :     sqlite3_stmt* m_cursor_stmt{nullptr};
      24             :     // Copies of the prefix things for the prefix cursor.
      25             :     // Prevents SQLite from accessing temp variables for the prefix things.
      26             :     std::vector<std::byte> m_prefix_range_start;
      27             :     std::vector<std::byte> m_prefix_range_end;
      28             : 
      29           0 :     explicit SQLiteCursor() {}
      30           0 :     explicit SQLiteCursor(std::vector<std::byte> start_range, std::vector<std::byte> end_range)
      31           0 :         : m_prefix_range_start(std::move(start_range)),
      32           0 :         m_prefix_range_end(std::move(end_range))
      33           0 :     {}
      34             :     ~SQLiteCursor() override;
      35             : 
      36             :     Status Next(DataStream& key, DataStream& value) override;
      37             : };
      38             : 
      39             : /** RAII class that provides access to a WalletDatabase */
      40             : class SQLiteBatch : public DatabaseBatch
      41             : {
      42             : private:
      43             :     SQLiteDatabase& m_database;
      44             : 
      45             :     sqlite3_stmt* m_read_stmt{nullptr};
      46             :     sqlite3_stmt* m_insert_stmt{nullptr};
      47             :     sqlite3_stmt* m_overwrite_stmt{nullptr};
      48             :     sqlite3_stmt* m_delete_stmt{nullptr};
      49             :     sqlite3_stmt* m_delete_prefix_stmt{nullptr};
      50             : 
      51             :     void SetupSQLStatements();
      52             :     bool ExecStatement(sqlite3_stmt* stmt, Span<const std::byte> blob);
      53             : 
      54             :     bool ReadKey(DataStream&& key, DataStream& value) override;
      55             :     bool WriteKey(DataStream&& key, DataStream&& value, bool overwrite = true) override;
      56             :     bool EraseKey(DataStream&& key) override;
      57             :     bool HasKey(DataStream&& key) override;
      58             :     bool ErasePrefix(Span<const std::byte> prefix) override;
      59             : 
      60             : public:
      61             :     explicit SQLiteBatch(SQLiteDatabase& database);
      62           0 :     ~SQLiteBatch() override { Close(); }
      63             : 
      64             :     /* No-op. See comment on SQLiteDatabase::Flush */
      65           0 :     void Flush() override {}
      66             : 
      67             :     void Close() override;
      68             : 
      69             :     std::unique_ptr<DatabaseCursor> GetNewCursor() override;
      70             :     std::unique_ptr<DatabaseCursor> GetNewPrefixCursor(Span<const std::byte> prefix) override;
      71             :     bool TxnBegin() override;
      72             :     bool TxnCommit() override;
      73             :     bool TxnAbort() override;
      74             : };
      75             : 
      76             : /** An instance of this class represents one SQLite3 database.
      77             :  **/
      78             : class SQLiteDatabase : public WalletDatabase
      79             : {
      80             : private:
      81             :     const bool m_mock{false};
      82             : 
      83             :     const std::string m_dir_path;
      84             : 
      85             :     const std::string m_file_path;
      86             : 
      87             :     /**
      88             :      * This mutex protects SQLite initialization and shutdown.
      89             :      * sqlite3_config() and sqlite3_shutdown() are not thread-safe (sqlite3_initialize() is).
      90             :      * Concurrent threads that execute SQLiteDatabase::SQLiteDatabase() should have just one
      91             :      * of them do the init and the rest wait for it to complete before all can proceed.
      92             :      */
      93             :     static Mutex g_sqlite_mutex;
      94             :     static int g_sqlite_count GUARDED_BY(g_sqlite_mutex);
      95             : 
      96             :     void Cleanup() noexcept EXCLUSIVE_LOCKS_REQUIRED(!g_sqlite_mutex);
      97             : 
      98             : public:
      99             :     SQLiteDatabase() = delete;
     100             : 
     101             :     /** Create DB handle to real database */
     102             :     SQLiteDatabase(const fs::path& dir_path, const fs::path& file_path, const DatabaseOptions& options, bool mock = false);
     103             : 
     104             :     ~SQLiteDatabase();
     105             : 
     106             :     bool Verify(bilingual_str& error);
     107             : 
     108             :     /** Open the database if it is not already opened */
     109             :     void Open() override;
     110             : 
     111             :     /** Close the database */
     112             :     void Close() override;
     113             : 
     114             :     /* These functions are unused */
     115           0 :     void AddRef() override { assert(false); }
     116           0 :     void RemoveRef() override { assert(false); }
     117             : 
     118             :     /** Rewrite the entire database on disk */
     119             :     bool Rewrite(const char* skip = nullptr) override;
     120             : 
     121             :     /** Back up the entire database to a file.
     122             :      */
     123             :     bool Backup(const std::string& dest) const override;
     124             : 
     125             :     /** No-ops
     126             :      *
     127             :      * SQLite always flushes everything to the database file after each transaction
     128             :      * (each Read/Write/Erase that we do is its own transaction unless we called
     129             :      * TxnBegin) so there is no need to have Flush or Periodic Flush.
     130             :      *
     131             :      * There is no DB env to reload, so ReloadDbEnv has nothing to do
     132             :      */
     133           0 :     void Flush() override {}
     134           0 :     bool PeriodicFlush() override { return false; }
     135           0 :     void ReloadDbEnv() override {}
     136             : 
     137           0 :     void IncrementUpdateCounter() override { ++nUpdateCounter; }
     138             : 
     139           0 :     std::string Filename() override { return m_file_path; }
     140           0 :     std::string Format() override { return "sqlite"; }
     141             : 
     142             :     /** Make a SQLiteBatch connected to this database */
     143             :     std::unique_ptr<DatabaseBatch> MakeBatch(bool flush_on_close = true) override;
     144             : 
     145             :     sqlite3* m_db{nullptr};
     146             :     bool m_use_unsafe_sync;
     147             : };
     148             : 
     149             : std::unique_ptr<SQLiteDatabase> MakeSQLiteDatabase(const fs::path& path, const DatabaseOptions& options, DatabaseStatus& status, bilingual_str& error);
     150             : 
     151             : std::string SQLiteDatabaseVersion();
     152             : } // namespace wallet
     153             : 
     154             : #endif // BITCOIN_WALLET_SQLITE_H