SQLiteDatabase.h

#pragma once
 
#include <xrpl/rdb/RelationalDatabase.h>
 
#include <map>
#include <memory>
#include <optional>
#include <variant>
#include <vector>
 
namespace xrpl {
 
class Config;
class JobQueue;
class ServiceRegistry;
 
class SQLiteDatabase final : public RelationalDatabase
{
public:
    std::optional<LedgerIndex>
    getMinLedgerSeq() override;
 
    std::optional<LedgerIndex>
    getMaxLedgerSeq() override;
 
    std::optional<LedgerHeader>
    getLedgerInfoByIndex(LedgerIndex ledgerSeq) override;
 
    std::optional<LedgerHeader>
    getNewestLedgerInfo() override;
 
    std::optional<LedgerHeader>
    getLedgerInfoByHash(uint256 const& ledgerHash) override;
 
    uint256
    getHashByIndex(LedgerIndex ledgerIndex) override;
 
    std::optional<LedgerHashPair>
    getHashesByIndex(LedgerIndex ledgerIndex) override;
 
    std::map<LedgerIndex, LedgerHashPair>
    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) override;
 
    std::vector<std::shared_ptr<Transaction>>
    getTxHistory(LedgerIndex startIndex) override;
 
    std::optional<LedgerIndex>
    getTransactionsMinLedgerSeq() override;
 
    std::optional<LedgerIndex>
    getAccountTransactionsMinLedgerSeq() override;
 
    void
    deleteTransactionByLedgerSeq(LedgerIndex ledgerSeq) override;
 
    void
    deleteBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
    void
    deleteTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
    void
    deleteAccountTransactionsBeforeLedgerSeq(LedgerIndex ledgerSeq) override;
 
    std::size_t
    getTransactionCount() override;
 
    std::size_t
    getAccountTransactionCount() override;
 
    CountMinMax
    getLedgerCountMinMax() override;
 
    bool
    saveValidatedLedger(std::shared_ptr<Ledger const> const& ledger, bool current) override;
 
    std::optional<LedgerHeader>
    getLimitedOldestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
 
    std::optional<LedgerHeader>
    getLimitedNewestLedgerInfo(LedgerIndex ledgerFirstIndex) override;
 
    AccountTxs
    getOldestAccountTxs(AccountTxOptions const& options) override;
 
    AccountTxs
    getNewestAccountTxs(AccountTxOptions const& options) override;
 
    MetaTxsList
    getOldestAccountTxsB(AccountTxOptions const& options) override;
 
    MetaTxsList
    getNewestAccountTxsB(AccountTxOptions const& options) override;
 
    std::pair<AccountTxs, std::optional<AccountTxMarker>>
    oldestAccountTxPage(AccountTxPageOptions const& options) override;
 
    std::pair<AccountTxs, std::optional<AccountTxMarker>>
    newestAccountTxPage(AccountTxPageOptions const& options) override;
 
    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
    oldestAccountTxPageB(AccountTxPageOptions const& options) override;
 
    std::pair<MetaTxsList, std::optional<AccountTxMarker>>
    newestAccountTxPageB(AccountTxPageOptions const& options) override;
 
    std::variant<AccountTx, TxSearched>
    getTransaction(
        uint256 const& id,
        std::optional<ClosedInterval<std::uint32_t>> const& range,
        error_code_i& ec) override;
 
    std::uint32_t
    getKBUsedAll() override;
 
    std::uint32_t
    getKBUsedLedger() override;
 
    std::uint32_t
    getKBUsedTransaction() override;
 
    void
    closeLedgerDB() override;
 
    void
    closeTransactionDB() override;
 
    SQLiteDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue);
 
    SQLiteDatabase(SQLiteDatabase const&) = delete;
    SQLiteDatabase(SQLiteDatabase&& rhs) noexcept;
 
    SQLiteDatabase&
    operator=(SQLiteDatabase const&) = delete;
    SQLiteDatabase&
    operator=(SQLiteDatabase&&) = delete;
 
    bool
    ledgerDbHasSpace(Config const& config);
 
    bool
    transactionDbHasSpace(Config const& config);
 
private:
    ServiceRegistry& registry_;
    bool useTxTables_;
    beast::Journal j_;
    std::unique_ptr<DatabaseCon> ledgerDb_, txdb_;
 
    bool
    makeLedgerDBs(
        Config const& config,
        DatabaseCon::Setup const& setup,
        DatabaseCon::CheckpointerSetup const& checkpointerSetup);
 
    bool
    existsLedger()
    {
        return static_cast<bool>(ledgerDb_);
    }
 
    bool
    existsTransaction()
    {
        return static_cast<bool>(txdb_);
    }
 
    auto
    checkoutLedger()
    {
        return ledgerDb_->checkoutDb();
    }
 
    auto
    checkoutTransaction()
    {
        return txdb_->checkoutDb();
    }
};
 
SQLiteDatabase
setup_RelationalDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue);
 
}  // namespace xrpl