RelationalDatabase.h

#pragma once
 
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/main/Application.h>
#include <xrpld/app/misc/Transaction.h>
#include <xrpld/core/Config.h>
#include <xrpld/core/DatabaseCon.h>
#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <boost/filesystem.hpp>
#include <boost/variant.hpp>
 
namespace xrpl {
 
struct LedgerHashPair
{
    uint256 ledgerHash;
    uint256 parentHash;
};
 
struct LedgerRange
{
    uint32_t min;
    uint32_t max;
};
 
class RelationalDatabase
{
public:
    struct CountMinMax
    {
        std::size_t numberOfRows;
        LedgerIndex minLedgerSequence;
        LedgerIndex maxLedgerSequence;
    };
 
    struct AccountTxMarker
    {
        std::uint32_t ledgerSeq = 0;
        std::uint32_t txnSeq = 0;
    };
 
    struct AccountTxOptions
    {
        AccountID const& account;
        std::uint32_t minLedger;
        std::uint32_t maxLedger;
        std::uint32_t offset;
        std::uint32_t limit;
        bool bUnlimited;
    };
 
    struct AccountTxPageOptions
    {
        AccountID const& account;
        std::uint32_t minLedger;
        std::uint32_t maxLedger;
        std::optional<AccountTxMarker> marker;
        std::uint32_t limit;
        bool bAdmin;
    };
 
    using AccountTx = std::pair<std::shared_ptr<Transaction>, std::shared_ptr<TxMeta>>;
    using AccountTxs = std::vector<AccountTx>;
    using txnMetaLedgerType = std::tuple<Blob, Blob, std::uint32_t>;
    using MetaTxsList = std::vector<txnMetaLedgerType>;
 
    using LedgerSequence = uint32_t;
    using LedgerHash = uint256;
    using LedgerShortcut = RPC::LedgerShortcut;
    using LedgerSpecifier = std::variant<LedgerRange, LedgerShortcut, LedgerSequence, LedgerHash>;
 
    struct AccountTxArgs
    {
        AccountID account;
        std::optional<LedgerSpecifier> ledger;
        bool binary = false;
        bool forward = false;
        uint32_t limit = 0;
        std::optional<AccountTxMarker> marker;
    };
 
    struct AccountTxResult
    {
        std::variant<AccountTxs, MetaTxsList> transactions;
        LedgerRange ledgerRange;
        uint32_t limit;
        std::optional<AccountTxMarker> marker;
    };
 
    static std::unique_ptr<RelationalDatabase>
    init(Application& app, Config const& config, JobQueue& jobQueue);
 
    virtual ~RelationalDatabase() = default;
 
    virtual std::optional<LedgerIndex>
    getMinLedgerSeq() = 0;
 
    virtual std::optional<LedgerIndex>
    getMaxLedgerSeq() = 0;
 
    virtual std::optional<LedgerHeader>
    getLedgerInfoByIndex(LedgerIndex ledgerSeq) = 0;
 
    virtual std::optional<LedgerHeader>
    getNewestLedgerInfo() = 0;
 
    virtual std::optional<LedgerHeader>
    getLedgerInfoByHash(uint256 const& ledgerHash) = 0;
 
    virtual uint256
    getHashByIndex(LedgerIndex ledgerIndex) = 0;
 
    virtual std::optional<LedgerHashPair>
    getHashesByIndex(LedgerIndex ledgerIndex) = 0;
 
    virtual std::map<LedgerIndex, LedgerHashPair>
    getHashesByIndex(LedgerIndex minSeq, LedgerIndex maxSeq) = 0;
 
    virtual std::vector<std::shared_ptr<Transaction>>
    getTxHistory(LedgerIndex startIndex) = 0;
 
    virtual bool
    ledgerDbHasSpace(Config const& config) = 0;
 
    virtual bool
    transactionDbHasSpace(Config const& config) = 0;
};
 
template <class T, class C>
T
rangeCheckedCast(C c)
{
    if ((c > std::numeric_limits<T>::max()) || (!std::numeric_limits<T>::is_signed && c < 0) ||
        (std::numeric_limits<T>::is_signed && std::numeric_limits<C>::is_signed &&
         c < std::numeric_limits<T>::lowest()))
    {
        // This should never happen
        // LCOV_EXCL_START
        UNREACHABLE("xrpl::rangeCheckedCast : domain error");
        JLOG(debugLog().error()) << "rangeCheckedCast domain error:"
                                 << " value = " << c << " min = " << std::numeric_limits<T>::lowest()
                                 << " max: " << std::numeric_limits<T>::max();
        // LCOV_EXCL_STOP
    }
 
    return static_cast<T>(c);
}
 
}  // namespace xrpl