RelationalDatabase.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2020 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_APP_RDB_RELATIONALDATABASE_H_INCLUDED
#define RIPPLE_APP_RDB_RELATIONALDATABASE_H_INCLUDED
 
#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/RPCHelpers.h>
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <boost/filesystem.hpp>
#include <boost/variant.hpp>
 
namespace ripple {
 
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<LedgerInfo>
    getLedgerInfoByIndex(LedgerIndex ledgerSeq) = 0;
 
    virtual std::optional<LedgerInfo>
    getNewestLedgerInfo() = 0;
 
    virtual std::optional<LedgerInfo>
    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("ripple::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 ripple
 
#endif