SQLiteDatabase.h

#pragma once
 
#include <xrpl/basics/RangeSet.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/LedgerHeader.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/TxSearched.h>
#include <xrpl/rdb/DatabaseCon.h>
#include <xrpl/rdb/RelationalDatabase.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <utility>
#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,
        ErrorCodeI& 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:
    std::reference_wrapper<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
setupRelationalDatabase(ServiceRegistry& registry, Config const& config, JobQueue& jobQueue);
 
}  // namespace xrpl