rocksdb_common.hpp

Go to the documentation of this file.

#ifndef IROHA_ROCKSDB_COMMON_HPP
#define IROHA_ROCKSDB_COMMON_HPP

#include <charconv>
#include <mutex>
#include <string>
#include <string_view>

#include <fmt/compile.h>
#include <fmt/format.h>
#include <rocksdb/db.h>
#include <rocksdb/utilities/optimistic_transaction_db.h>
#include <rocksdb/utilities/transaction.h>
#include "ametsuchi/impl/executor_common.hpp"
#include "common/irohad_version.hpp"
#include "common/result.hpp"
#include "interfaces/common_objects/amount.hpp"
#include "interfaces/common_objects/types.hpp"
#include "interfaces/permissions.hpp"

// clang-format off
// clang-format on

#define RDB_DELIMITER "/"
#define RDB_XXX RDB_DELIMITER "{}" RDB_DELIMITER

#define RDB_ROOT ""
#define RDB_STORE "s"
#define RDB_WSV "w"
#define RDB_NETWORK "n"
#define RDB_SETTINGS "i"
#define RDB_ASSETS "x"
#define RDB_ROLES "r"
#define RDB_TRANSACTIONS "t"
#define RDB_ACCOUNTS "a"
#define RDB_PEERS "p"
#define RDB_STATUSES "u"
#define RDB_DETAILS "d"
#define RDB_GRANTABLE_PER "g"
#define RDB_POSITION "P"
#define RDB_TIMESTAMP "T"
#define RDB_DOMAIN "D"
#define RDB_SIGNATORIES "S"
#define RDB_OPTIONS "O"
#define RDB_ADDRESS "M"
#define RDB_TLS "N"

#define RDB_F_QUORUM "q"
#define RDB_F_ASSET_SIZE "I"
#define RDB_F_TOP_BLOCK "Q"
#define RDB_F_PEERS_COUNT "Z"
#define RDB_F_TOTAL_COUNT "V"
#define RDB_F_VERSION "v"

#define RDB_PATH_DOMAIN RDB_ROOT  RDB_WSV  RDB_DOMAIN  RDB_XXX
#define RDB_PATH_ACCOUNT RDB_PATH_DOMAIN  RDB_ACCOUNTS  RDB_XXX

namespace iroha::ametsuchi::fmtstrings {
  static constexpr size_t kDelimiterSize =
      sizeof(RDB_DELIMITER) / sizeof(RDB_DELIMITER[0]) - 1ull;

  static constexpr size_t kDelimiterCountForAField = 2ull;

  static const std::string kDelimiter{RDB_DELIMITER};

  // domain_id/account_name
  static auto constexpr kPathAccountRoles{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_ROLES)};

  static auto constexpr kPathWsv{FMT_STRING(RDB_ROOT  RDB_WSV)};

  static auto constexpr kPathStore{FMT_STRING(RDB_ROOT  RDB_STORE)};

  // domain_id/account_name
  static auto constexpr kPathAccount{FMT_STRING(RDB_PATH_ACCOUNT)};

  // no params
  static auto constexpr kPathPeers{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_NETWORK  RDB_PEERS  RDB_ADDRESS)};

  // domain_id/account_name
  static auto constexpr kPathSignatories{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_SIGNATORIES)};

  // no param
  static auto constexpr kPathRoles{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_ROLES)};

  // account
  static auto constexpr kPathTransactionByTs{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS 
                     RDB_ACCOUNTS  RDB_XXX  RDB_TIMESTAMP)};

  // account
  static auto constexpr kPathTransactionByPosition{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS 
                     RDB_ACCOUNTS  RDB_XXX  RDB_POSITION)};

  // domain_id/account_name ➡️ value
  static auto constexpr kPathAccountDetail{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_DETAILS)};

  // account_domain_id/account_name/asset_id
  static auto constexpr kPathAccountAssets{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_ASSETS)};

  // height ➡️ block data
  static auto constexpr kBlockDataInStore{
      FMT_STRING(RDB_ROOT  RDB_STORE  RDB_XXX)};

  // account/height/index/ts ➡️ tx_hash
  static auto constexpr kTransactionByPosition{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS  RDB_ACCOUNTS 
          RDB_XXX  RDB_POSITION  RDB_XXX  RDB_XXX  RDB_XXX)};

  // account/ts/height/index ➡️ tx_hash
  static auto constexpr kTransactionByTs{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS  RDB_ACCOUNTS 
          RDB_XXX  RDB_TIMESTAMP  RDB_XXX  RDB_XXX  RDB_XXX)};

  // account/height ➡️ tx_hash
  static auto constexpr kTransactionByHeight{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS  RDB_ACCOUNTS 
          RDB_XXX  RDB_POSITION  RDB_XXX)};

  // account/ts/height/index ➡️ tx_hash
  static auto constexpr kTransactionByTsLowerBound{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS  RDB_ACCOUNTS 
          RDB_XXX  RDB_TIMESTAMP  RDB_XXX)};

  // tx_hash ➡️ status
  static auto constexpr kTransactionStatus{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS 
                     RDB_STATUSES  RDB_XXX)};

  // domain_id/account_name/role_name
  static auto constexpr kAccountRole{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_ROLES  RDB_XXX)};

  // role_name ➡️ permissions
  static auto constexpr kRole{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_ROLES 
                     RDB_XXX)};

  // domain_id/account_name/pubkey ➡️ ""
  static auto constexpr kSignatory{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_SIGNATORIES  RDB_XXX)};

  // domain_id/asset_name ➡️ precision
  static auto constexpr kAsset{
      FMT_STRING(RDB_PATH_DOMAIN  RDB_ASSETS  RDB_XXX)};

  // account_domain_id/account_name/asset_id ➡️ amount
  static auto constexpr kAccountAsset{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_ASSETS  RDB_XXX)};

  // domain_id/account_name/writer_id/key ➡️
  // value
  static auto constexpr kAccountDetail{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_DETAILS  RDB_XXX  RDB_XXX)};

  // pubkey ➡️ address
  static auto constexpr kPeerAddress{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_NETWORK  RDB_PEERS 
                     RDB_ADDRESS  RDB_XXX)};

  // pubkey ➡️ tls
  static auto constexpr kPeerTLS{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_NETWORK  RDB_PEERS 
                     RDB_TLS  RDB_XXX)};

  // domain_id/account_name/grantee_domain_id/grantee_account_name
  // ➡️ permissions
  static auto constexpr kGranted{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_GRANTABLE_PER  RDB_XXX)};

  // key ➡️ value
  static auto constexpr kSetting{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_SETTINGS  RDB_XXX)};

  // domain_id ➡️ default role
  static auto constexpr kDomain{FMT_STRING(RDB_PATH_DOMAIN)};

  // "" ➡️ height # hash
  static auto constexpr kTopBlock{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_NETWORK  RDB_STORE 
                     RDB_F_TOP_BLOCK)};

  // domain_id/account_name
  static auto constexpr kQuorum{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_OPTIONS  RDB_F_QUORUM)};

  // account_domain_id/account_name ➡️ size
  static auto constexpr kAccountAssetSize{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_OPTIONS  RDB_F_ASSET_SIZE)};

  static auto constexpr kPeersCount{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_NETWORK  RDB_PEERS 
                     RDB_F_PEERS_COUNT)};

  // account ➡️ txs total count
  static auto constexpr kTxsTotalCount{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS 
                     RDB_ACCOUNTS  RDB_XXX  RDB_F_TOTAL_COUNT)};

  // ➡️ value
  static auto constexpr kBlocksTotalCount{
      FMT_STRING(RDB_ROOT  RDB_STORE  RDB_F_TOTAL_COUNT)};

  // ➡️ txs total count
  static auto constexpr kAllTxsTotalCount{FMT_STRING(
      RDB_ROOT  RDB_WSV  RDB_TRANSACTIONS  RDB_F_TOTAL_COUNT)};

  // ➡️ domains total count
  static auto constexpr kDomainsTotalCount{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_DOMAIN  RDB_F_TOTAL_COUNT)};

  // domain_id/account_name/ ➡️ value
  static auto constexpr kAccountDetailsCount{
      FMT_STRING(RDB_PATH_ACCOUNT  RDB_OPTIONS  RDB_F_TOTAL_COUNT)};

  // ➡️ value
  static auto constexpr kStoreVersion{
      FMT_STRING(RDB_ROOT  RDB_STORE  RDB_F_VERSION)};

  // ➡️ value
  static auto constexpr kWsvVersion{
      FMT_STRING(RDB_ROOT  RDB_WSV  RDB_F_VERSION)};

}  // namespace iroha::ametsuchi::fmtstrings

#undef RDB_ADDRESS
#undef RDB_TLS
#undef RDB_OPTIONS
#undef RDB_F_ASSET_SIZE
#undef RDB_PATH_DOMAIN
#undef RDB_PATH_ACCOUNT
#undef RDB_F_QUORUM
#undef RDB_DELIMITER
#undef RDB_ROOT
#undef RDB_STORE
#undef RDB_WSV
#undef RDB_NETWORK
#undef RDB_SETTINGS
#undef RDB_ASSETS
#undef RDB_ROLES
#undef RDB_TRANSACTIONS
#undef RDB_ACCOUNTS
#undef RDB_PEERS
#undef RDB_STATUSES
#undef RDB_DETAILS
#undef RDB_GRANTABLE_PER
#undef RDB_POSITION
#undef RDB_TIMESTAMP
#undef RDB_DOMAIN
#undef RDB_SIGNATORIES
#undef RDB_ITEM
#undef RDB_F_TOP_BLOCK
#undef RDB_F_PEERS_COUNT
#undef RDB_F_TOTAL_COUNT
#undef RDB_F_VERSION

namespace {
  auto constexpr kValue{FMT_STRING("{}")};
}

namespace iroha::ametsuchi {

  struct RocksDBPort;
  class RocksDbCommon;

  struct RocksDBContext {
    RocksDBContext(RocksDBContext const &) = delete;
    RocksDBContext &operator=(RocksDBContext const &) = delete;

    explicit RocksDBContext(std::shared_ptr<RocksDBPort> dbp)
        : db_port(std::move(dbp)) {
      assert(db_port);
    }

   private:
    friend class RocksDbCommon;
    friend struct RocksDBPort;

    std::unique_ptr<rocksdb::Transaction> transaction;

    fmt::memory_buffer key_buffer;

    std::string value_buffer;

    std::shared_ptr<RocksDBPort> db_port;

    std::mutex this_context_cs;
  };

  enum DbErrorCode {
    kOk = 0,
    kErrorNoPermissions = 2,
    kNotFound = 3,
    kNoAccount = 3,
    kMustNotExist = 4,
    kNoRoles = 4,
    kInvalidPagination = 4,
    kInvalidStatus = 12,
    kInitializeFailed = 15,
    kOperationFailed = 16,
  };

  struct DbError final {
    uint32_t code;
    std::string description;
  };

  template <typename T, typename... Args>
  inline expected::Result<T, DbError> makeError(uint32_t code,
                                                char const *format,
                                                Args &&... args) {
    assert(format != nullptr);
    return expected::makeError(
        DbError{code, fmt::format(format, std::forward<Args>(args)...)});
  }

  template <typename T>
  inline expected::Result<T, DbError> makeError(uint32_t code, DbError &&e) {
    return expected::makeError(DbError{code, std::move(e.description)});
  }

  struct RocksDBPort {
    RocksDBPort(RocksDBPort const &) = delete;
    RocksDBPort &operator=(RocksDBPort const &) = delete;
    RocksDBPort() = default;

    expected::Result<void, DbError> initialize(std::string const &db_name) {
      if (db_name_) {
        assert(*db_name_ == db_name);
        return {};
      }

      rocksdb::Options options;
      options.create_if_missing = true;

      rocksdb::OptimisticTransactionDB *transaction_db;
      auto status = rocksdb::OptimisticTransactionDB::Open(
          options, db_name, &transaction_db);

      if (!status.ok())
        return makeError<void>(DbErrorCode::kInitializeFailed,
                               "Db {} initialization failed with status: {}.",
                               db_name,
                               status.ToString());

      transaction_db_.reset(transaction_db);
      db_name_ = db_name;
      return {};
    }

   private:
    std::unique_ptr<rocksdb::OptimisticTransactionDB> transaction_db_;
    std::optional<std::string> db_name_;
    friend class RocksDbCommon;

    void prepareTransaction(RocksDBContext &tx_context) {
      assert(transaction_db_);
      tx_context.transaction.reset(
          transaction_db_->BeginTransaction(rocksdb::WriteOptions()));
    }
  };

#define RDB_ERROR_CHECK(...)                   \
  if (auto _tmp_gen_var = (__VA_ARGS__);       \
      iroha::expected::hasError(_tmp_gen_var)) \
  return _tmp_gen_var.assumeError()

#define RDB_ERROR_CHECK_TO_STR(...)            \
  if (auto _tmp_gen_var = (__VA_ARGS__);       \
      iroha::expected::hasError(_tmp_gen_var)) \
  return _tmp_gen_var.assumeError().description

#define RDB_TRY_GET_VALUE(name, ...)                   \
  typename decltype(__VA_ARGS__)::ValueInnerType name; \
  if (auto _tmp_gen_var = (__VA_ARGS__);               \
      iroha::expected::hasError(_tmp_gen_var))         \
    return _tmp_gen_var.assumeError();                 \
  else                                                 \
    name = std::move(_tmp_gen_var.assumeValue())

#define RDB_TRY_GET_VALUE_OR_STR_ERR(name, ...)        \
  typename decltype(__VA_ARGS__)::ValueInnerType name; \
  if (auto _tmp_gen_var = (__VA_ARGS__);               \
      iroha::expected::hasError(_tmp_gen_var))         \
    return _tmp_gen_var.assumeError().description;     \
  else                                                 \
    name = std::move(_tmp_gen_var.assumeValue())

  class RocksDbCommon {
   public:
    explicit RocksDbCommon(std::shared_ptr<RocksDBContext> tx_context)
        : tx_context_(std::move(tx_context)),
          context_guard_(tx_context_->this_context_cs) {
      assert(tx_context_);
      assert(tx_context_->db_port);
    }

    auto &valueBuffer() {
      return tx_context_->value_buffer;
    }

    auto &keyBuffer() {
      return tx_context_->key_buffer;
    }

   private:
    auto &transaction() {
      if (!tx_context_->transaction)
        tx_context_->db_port->prepareTransaction(*tx_context_);
      return tx_context_->transaction;
    }

    [[nodiscard]] bool isTransaction() const {
      return tx_context_->transaction != nullptr;
    }

    template <typename F>
    auto enumerate(std::unique_ptr<rocksdb::Iterator> &it, F &&func) {
      if (!it->status().ok())
        return it->status();

      rocksdb::Slice const key(keyBuffer().data(), keyBuffer().size());
      for (; it->Valid() && it->key().starts_with(key); it->Next())
        if (!std::forward<F>(func)(it, key.size()))
          break;

      return it->status();
    }

   public:
    auto commit() {
      rocksdb::Status status;
      if (isTransaction())
        status = transaction()->Commit();

      transaction().reset();
      return status;
    }

    auto rollback() {
      rocksdb::Status status;
      if (isTransaction())
        status = transaction()->Rollback();

      transaction().reset();
      return status;
    }

    auto release() {
      rocksdb::Status status;
      if (isTransaction())
        status = transaction()->PopSavePoint();
      return status;
    }

    auto prepare() {
      rocksdb::Status status;
      if (isTransaction())
        status = transaction()->Prepare();
      return status;
    }

    void skip() {
      if (isTransaction())
        transaction().reset();
    }

    void savepoint() {
      if (isTransaction())
        transaction()->SetSavePoint();
    }

    auto rollbackToSavepoint() {
      rocksdb::Status status;
      if (isTransaction())
        status = transaction()->RollbackToSavePoint();
      return status;
    }

    auto encode(uint64_t number) {
      valueBuffer().clear();
      fmt::format_to(std::back_inserter(valueBuffer()), kValue, number);
    }

    auto decode(uint64_t &number) {
      return std::from_chars(valueBuffer().data(),
                             valueBuffer().data() + valueBuffer().size(),
                             number);
    }

    template <typename S, typename... Args>
    auto get(S const &fmtstring, Args &&... args) {
      keyBuffer().clear();
      fmt::format_to(keyBuffer(), fmtstring, std::forward<Args>(args)...);

      valueBuffer().clear();
      return transaction()->Get(
          rocksdb::ReadOptions(),
          rocksdb::Slice(keyBuffer().data(), keyBuffer().size()),
          &valueBuffer());
    }

    template <typename S, typename... Args>
    auto put(S const &fmtstring, Args &&... args) {
      keyBuffer().clear();
      fmt::format_to(keyBuffer(), fmtstring, std::forward<Args>(args)...);

      return transaction()->Put(
          rocksdb::Slice(keyBuffer().data(), keyBuffer().size()),
          valueBuffer());
    }

    template <typename S, typename... Args>
    auto del(S const &fmtstring, Args &&... args) {
      keyBuffer().clear();
      fmt::format_to(keyBuffer(), fmtstring, std::forward<Args>(args)...);

      return transaction()->Delete(
          rocksdb::Slice(keyBuffer().data(), keyBuffer().size()));
    }

    template <typename S, typename... Args>
    auto seek(S const &fmtstring, Args &&... args) {
      keyBuffer().clear();
      fmt::format_to(keyBuffer(), fmtstring, std::forward<Args>(args)...);

      std::unique_ptr<rocksdb::Iterator> it(
          transaction()->GetIterator(rocksdb::ReadOptions()));
      it->Seek(rocksdb::Slice(keyBuffer().data(), keyBuffer().size()));

      return it;
    }

    template <typename F, typename S, typename... Args>
    auto enumerate(std::unique_ptr<rocksdb::Iterator> &it,
                   F &&func,
                   S const &fmtstring,
                   Args &&... args) {
      keyBuffer().clear();
      fmt::format_to(keyBuffer(), fmtstring, std::forward<Args>(args)...);
      return enumerate(it, std::forward<F>(func));
    }

    template <typename F, typename S, typename... Args>
    auto enumerate(F &&func, S const &fmtstring, Args &&... args) {
      auto it = seek(fmtstring, std::forward<Args>(args)...);
      return enumerate(it, std::forward<F>(func));
    }

    template <typename S, typename... Args>
    auto filterDelete(S const &fmtstring, Args &&... args) {
      auto it = seek(fmtstring, std::forward<Args>(args)...);
      if (!it->status().ok())
        return it->status();

      rocksdb::Slice const key(keyBuffer().data(), keyBuffer().size());
      for (; it->Valid() && it->key().starts_with(key); it->Next())
        if (auto status = transaction()->Delete(it->key()); !status.ok())
          return status;

      return it->status();
    }

   private:
    std::shared_ptr<RocksDBContext> tx_context_;
    std::lock_guard<std::mutex> context_guard_;
  };

  enum struct kDbOperation {
    kGet,    
    kCheck,  
    kPut,    
    kDel     
  };

  enum struct kDbEntry {
    kMustExist,     
    kMustNotExist,  
    kCanExist  
  };

  template <typename F, typename S, typename... Args>
  inline auto enumerateKeys(RocksDbCommon &rdb,
                            F &&func,
                            S const &strformat,
                            Args &&... args) {
    return rdb.enumerate(
        [func{std::forward<F>(func)}](auto const &it,
                                      auto const prefix_size) mutable {
          assert(it->Valid());
          auto const key = it->key();
          return std::forward<F>(func)(rocksdb::Slice(
              key.data() + prefix_size + fmtstrings::kDelimiterSize,
              key.size() - prefix_size
                  - fmtstrings::kDelimiterCountForAField
                      * fmtstrings::kDelimiterSize));
        },
        strformat,
        std::forward<Args>(args)...);
  }

  template <typename F>
  inline auto makeKVLambda(F &&func) {
    return [func{std::forward<F>(func)}](auto const &it,
                                         auto const prefix_size) mutable {
      assert(it->Valid());
      auto const key = it->key();
      return std::forward<F>(func)(
          rocksdb::Slice(key.data() + prefix_size + fmtstrings::kDelimiterSize,
                         key.size() - prefix_size
                             - fmtstrings::kDelimiterCountForAField
                                 * fmtstrings::kDelimiterSize),
          it->value());
    };
  }

  template <typename F, typename S, typename... Args>
  inline auto enumerateKeysAndValues(RocksDbCommon &rdb,
                                     F &&func,
                                     S const &strformat,
                                     Args &&... args) {
    return rdb.enumerate(makeKVLambda(std::forward<F>(func)),
                         strformat,
                         std::forward<Args>(args)...);
  }

  template <typename F, typename S, typename... Args>
  inline auto enumerateKeysAndValues(RocksDbCommon &rdb,
                                     F &&func,
                                     std::unique_ptr<rocksdb::Iterator> &it,
                                     S const &strformat,
                                     Args &&... args) {
    return rdb.enumerate(it,
                         makeKVLambda(std::forward<F>(func)),
                         strformat,
                         std::forward<Args>(args)...);
  }

  template <typename F>
  inline expected::Result<void, DbError> mustNotExist(
      rocksdb::Status const &status, F &&op_formatter) {
    if (status.IsNotFound())
      return {};

    if (!status.ok())
      return makeError<void>(DbErrorCode::kInvalidStatus,
                             "{}. Failed with status: {}.",
                             std::forward<F>(op_formatter)(),
                             status.ToString());

    return makeError<void>(DbErrorCode::kMustNotExist,
                           "{}. Must not exist.",
                           std::forward<F>(op_formatter)());
  }

  template <typename F>
  inline expected::Result<void, DbError> mustExist(
      rocksdb::Status const &status, F &&op_formatter) {
    if (status.IsNotFound())
      return makeError<void>(DbErrorCode::kNotFound,
                             "{}. Was not found.",
                             std::forward<F>(op_formatter)());

    if (!status.ok())
      return makeError<void>(DbErrorCode::kInvalidStatus,
                             "{}. Failed with status: {}.",
                             std::forward<F>(op_formatter)(),
                             status.ToString());

    return {};
  }

  template <typename F>
  inline expected::Result<void, DbError> canExist(rocksdb::Status const &status,
                                                  F &&op_formatter) {
    if (status.IsNotFound() || status.ok())
      return {};

    return makeError<void>(DbErrorCode::kInvalidStatus,
                           "{}. Failed with status: {}.",
                           std::forward<F>(op_formatter)(),
                           status.ToString());
  }

  template <kDbEntry kSc, typename F>
  inline expected::Result<void, DbError> checkStatus(rocksdb::Status status,
                                                     F &&op_formatter) {
    if constexpr (kSc == kDbEntry::kMustExist)
      return mustExist(status, std::forward<F>(op_formatter));
    else if constexpr (kSc == kDbEntry::kMustNotExist)
      return mustNotExist(status, std::forward<F>(op_formatter));
    else if constexpr (kSc == kDbEntry::kCanExist)
      return canExist(status, std::forward<F>(op_formatter));

    static_assert(kSc == kDbEntry::kMustExist || kSc == kDbEntry::kMustNotExist
                      || kSc == kDbEntry::kCanExist,
                  "Unexpected status check value");
  }

  template <kDbOperation kOp,
            kDbEntry kSc,
            typename OperationDescribtionF,
            typename... Args>
  inline expected::Result<rocksdb::Status, DbError> executeOperation(
      RocksDbCommon &common,
      OperationDescribtionF &&op_formatter,
      Args &&... args) {
    rocksdb::Status status;
    if constexpr (kOp == kDbOperation::kGet || kOp == kDbOperation::kCheck)
      status = common.get(std::forward<Args>(args)...);
    else if constexpr (kOp == kDbOperation::kPut)
      status = common.put(std::forward<Args>(args)...);
    else if constexpr (kOp == kDbOperation::kDel)
      status = common.del(std::forward<Args>(args)...);

    static_assert(kOp == kDbOperation::kGet || kOp == kDbOperation::kCheck
                      || kOp == kDbOperation::kPut || kOp == kDbOperation::kDel,
                  "Unexpected operation value!");

    static_assert(
        kOp != kDbOperation::kDel || kSc != kDbEntry::kMustExist,
        "Delete operation does not report if key existed before deletion!");

    RDB_ERROR_CHECK(checkStatus<kSc>(
        status, std::forward<OperationDescribtionF>(op_formatter)));
    return status;
  }

  template <kDbOperation kOp,
            typename T,
            typename = std::enable_if_t<std::is_same<T, uint64_t>::value>>
  inline std::optional<uint64_t> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<uint64_t> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok()) {
        uint64_t _;
        common.decode(_);
        value = _;
      }
    }
    return value;
  }

  template <
      kDbOperation kOp,
      typename T,
      typename = std::enable_if_t<std::is_same<T, std::string_view>::value>>
  inline std::optional<std::string_view> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<std::string_view> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok())
        value = common.valueBuffer();
    }
    return value;
  }

  template <
      kDbOperation kOp,
      typename T,
      typename = std::enable_if_t<
          std::is_same<T, shared_model::interface::RolePermissionSet>::value>>
  inline std::optional<shared_model::interface::RolePermissionSet> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<shared_model::interface::RolePermissionSet> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok())
        value =
            shared_model::interface::RolePermissionSet{common.valueBuffer()};
    }
    return value;
  }

  template <kDbOperation kOp,
            typename T,
            typename = std::enable_if_t<std::is_same<T, IrohadVersion>::value>>
  inline std::optional<IrohadVersion> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<IrohadVersion> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok()) {
        auto const &[major, minor, patch] =
            staticSplitId<3ull>(common.valueBuffer(), "#");
        IrohadVersion version{0ul, 0ul, 0ul};
        std::from_chars(
            major.data(), major.data() + major.size(), version.major);
        std::from_chars(
            minor.data(), minor.data() + minor.size(), version.minor);
        std::from_chars(
            patch.data(), patch.data() + patch.size(), version.patch);
        value = version;
      }
    }
    return value;
  }

  template <kDbOperation kOp,
            typename T,
            typename = std::enable_if_t<
                std::is_same<T, shared_model::interface::Amount>::value>>
  inline std::optional<shared_model::interface::Amount> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<shared_model::interface::Amount> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok())
        value.emplace(common.valueBuffer());
    }
    return value;
  }

  template <kDbOperation kOp,
            typename T,
            typename = std::enable_if_t<std::is_same<
                T,
                shared_model::interface::GrantablePermissionSet>::value>>
  inline std::optional<shared_model::interface::GrantablePermissionSet>
  loadValue(RocksDbCommon &common,
            expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<shared_model::interface::GrantablePermissionSet> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok())
        value = shared_model::interface::GrantablePermissionSet{
            common.valueBuffer()};
    }
    return value;
  }

  template <kDbOperation kOp,
            typename T,
            typename = std::enable_if_t<std::is_same<T, bool>::value>>
  inline std::optional<bool> loadValue(
      RocksDbCommon &common,
      expected::Result<rocksdb::Status, DbError> const &status) {
    std::optional<bool> value;
    if constexpr (kOp == kDbOperation::kGet) {
      assert(expected::hasValue(status));
      if (status.assumeValue().ok())
        value = true;
    }
    return value;
  }

  template <typename RetT, kDbOperation kOp, kDbEntry kSc, typename... Args>
  inline expected::Result<std::optional<RetT>, DbError> dbCall(
      RocksDbCommon &common, Args &&... args) {
    auto status = executeOperation<kOp, kSc>(
        common,
        [&] { return fmt::format(std::forward<Args>(args)...); },
        std::forward<Args>(args)...);
    RDB_ERROR_CHECK(status);
    return loadValue<kOp, RetT>(common, status);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError>
  forAccountDetailsCount(RocksDbCommon &common,
                         std::string_view account,
                         std::string_view domain) {
    return dbCall<uint64_t, kOp, kSc>(
        common, fmtstrings::kAccountDetailsCount, domain, account);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<IrohadVersion>, DbError>
  forStoreVersion(RocksDbCommon &common) {
    return dbCall<IrohadVersion, kOp, kSc>(common, fmtstrings::kStoreVersion);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<IrohadVersion>, DbError> forWSVVersion(
      RocksDbCommon &common) {
    return dbCall<IrohadVersion, kOp, kSc>(common, fmtstrings::kWsvVersion);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError> forBlock(
      RocksDbCommon &common, uint64_t height) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kBlockDataInStore, height);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forBlocksTotalCount(
      RocksDbCommon &common) {
    return dbCall<uint64_t, kOp, kSc>(common, fmtstrings::kBlocksTotalCount);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forQuorum(
      RocksDbCommon &common,
      std::string_view account,
      std::string_view domain) {
    return dbCall<uint64_t, kOp, kSc>(
        common, fmtstrings::kQuorum, domain, account);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forTxsTotalCount(
      RocksDbCommon &common, std::string_view account_id) {
    return dbCall<uint64_t, kOp, kSc>(
        common, fmtstrings::kTxsTotalCount, account_id);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forTxsTotalCount(
      RocksDbCommon &common) {
    return dbCall<uint64_t, kOp, kSc>(common, fmtstrings::kAllTxsTotalCount);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError>
  forDomainsTotalCount(RocksDbCommon &common) {
    return dbCall<uint64_t, kOp, kSc>(common, fmtstrings::kDomainsTotalCount);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline auto forAccount(RocksDbCommon &common,
                         std::string_view account,
                         std::string_view domain) {
    return forQuorum<kOp, kSc>(common, account, domain);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::
      Result<std::optional<shared_model::interface::RolePermissionSet>, DbError>
      forRole(RocksDbCommon &common, std::string_view role) {
    return dbCall<shared_model::interface::RolePermissionSet, kOp, kSc>(
        common, fmtstrings::kRole, role);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forPeersCount(
      RocksDbCommon &common) {
    return dbCall<uint64_t, kOp, kSc>(common, fmtstrings::kPeersCount);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError>
  forTransactionStatus(RocksDbCommon &common, std::string_view tx_hash) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kTransactionStatus, tx_hash);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError>
  forTransactionByPosition(RocksDbCommon &common,
                           std::string_view account,
                           uint64_t ts,
                           uint64_t height,
                           uint64_t index) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kTransactionByPosition, account, height, index, ts);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError>
  forTransactionByTimestamp(RocksDbCommon &common,
                            std::string_view account,
                            uint64_t ts,
                            uint64_t height,
                            uint64_t index) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kTransactionByTs, account, ts, height, index);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError> forSettings(
      RocksDbCommon &common, std::string_view key) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kSetting, key);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError>
  forPeerAddress(RocksDbCommon &common, std::string_view pubkey) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kPeerAddress, pubkey);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError> forPeerTLS(
      RocksDbCommon &common, std::string_view pubkey) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kPeerTLS, pubkey);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forAsset(
      RocksDbCommon &common, std::string_view asset, std::string_view domain) {
    return dbCall<uint64_t, kOp, kSc>(
        common, fmtstrings::kAsset, domain, asset);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  expected::Result<std::optional<std::string_view>, DbError> forTopBlockInfo(
      RocksDbCommon &common) {
    return dbCall<std::string_view, kOp, kSc>(common, fmtstrings::kTopBlock);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<bool>, DbError> forAccountRole(
      RocksDbCommon &common,
      std::string_view account,
      std::string_view domain,
      std::string_view role) {
    return dbCall<bool, kOp, kSc>(
        common, fmtstrings::kAccountRole, domain, account, role);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError>
  forAccountDetail(RocksDbCommon &common,
                   std::string_view account,
                   std::string_view domain,
                   std::string_view creator_id,
                   std::string_view key) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kAccountDetail, domain, account, creator_id, key);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<bool>, DbError> forSignatory(
      RocksDbCommon &common,
      std::string_view account,
      std::string_view domain,
      std::string_view pubkey) {
    return dbCall<bool, kOp, kSc>(
        common, fmtstrings::kSignatory, domain, account, pubkey);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kMustExist>
  inline expected::Result<std::optional<std::string_view>, DbError> forDomain(
      RocksDbCommon &common, std::string_view domain) {
    return dbCall<std::string_view, kOp, kSc>(
        common, fmtstrings::kDomain, domain);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kCanExist>
  inline expected::Result<std::optional<uint64_t>, DbError> forAccountAssetSize(
      RocksDbCommon &common,
      std::string_view account,
      std::string_view domain) {
    return dbCall<uint64_t, kOp, kSc>(
        common, fmtstrings::kAccountAssetSize, domain, account);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kCanExist>
  inline expected::Result<std::optional<shared_model::interface::Amount>,
                          DbError>
  forAccountAsset(RocksDbCommon &common,
                  std::string_view account,
                  std::string_view domain,
                  std::string_view asset) {
    return dbCall<shared_model::interface::Amount, kOp, kSc>(
        common, fmtstrings::kAccountAsset, domain, account, asset);
  }

  template <kDbOperation kOp = kDbOperation::kGet,
            kDbEntry kSc = kDbEntry::kCanExist>
  inline expected::Result<
      std::optional<shared_model::interface::GrantablePermissionSet>,
      DbError>
  forGrantablePermissions(RocksDbCommon &common,
                          std::string_view account,
                          std::string_view domain,
                          std::string_view grantee_account_id) {
    return dbCall<shared_model::interface::GrantablePermissionSet, kOp, kSc>(
        common, fmtstrings::kGranted, domain, account, grantee_account_id);
  }

  inline expected::Result<shared_model::interface::RolePermissionSet, DbError>
  accountPermissions(RocksDbCommon &common,
                     std::string_view account,
                     std::string_view domain) {
    assert(!domain.empty());
    assert(!account.empty());

    std::vector<std::string> roles;
    auto status = enumerateKeys(common,
                                [&](auto role) {
                                  if (!role.empty())
                                    roles.emplace_back(role.ToStringView());
                                  else {
                                    assert(!"Role can not be empty string!");
                                  }
                                  return true;
                                },
                                fmtstrings::kPathAccountRoles,
                                domain,
                                account);

    if (!status.ok())
      return makeError<shared_model::interface::RolePermissionSet>(
          DbErrorCode::kNoAccount,
          "Enumerate account {}@{} roles failed with status: {}.",
          account,
          domain,
          status.ToString());

    shared_model::interface::RolePermissionSet permissions;
    for (auto &role : roles) {
      auto opt_perm =
          forRole<kDbOperation::kGet, kDbEntry::kMustExist>(common, role);
      RDB_ERROR_CHECK(opt_perm);
      permissions |= *opt_perm.assumeValue();
    }

    return permissions;
  }

  inline expected::Result<void, DbError> checkPermissions(
      shared_model::interface::RolePermissionSet const &permissions,
      shared_model::interface::permissions::Role const to_check) {
    if (permissions.isSet(to_check))
      return {};

    return makeError<void>(DbErrorCode::kErrorNoPermissions, "No permissions.");
  }

  inline expected::Result<void, DbError> checkPermissions(
      std::string_view domain_id,
      std::string_view creator_domain_id,
      shared_model::interface::RolePermissionSet const &permissions,
      shared_model::interface::permissions::Role const all,
      shared_model::interface::permissions::Role const domain) {
    if (permissions.isSet(all))
      return {};

    if (domain_id == creator_domain_id && permissions.isSet(domain))
      return {};

    return makeError<void>(DbErrorCode::kErrorNoPermissions, "No permissions.");
  }

  inline expected::Result<void, DbError> checkGrantablePermissions(
      shared_model::interface::RolePermissionSet const &permissions,
      shared_model::interface::GrantablePermissionSet const
          &grantable_permissions,
      shared_model::interface::permissions::Grantable const granted) {
    if (grantable_permissions.isSet(granted)
        || permissions.isSet(shared_model::interface::permissions::Role::kRoot))
      return {};

    return makeError<void>(DbErrorCode::kErrorNoPermissions, "No permissions.");
  }

  inline expected::Result<void, DbError> checkPermissions(
      shared_model::interface::RolePermissionSet const &permissions,
      shared_model::interface::GrantablePermissionSet const
          &grantable_permissions,
      shared_model::interface::permissions::Role const role,
      shared_model::interface::permissions::Grantable const granted) {
    if (permissions.isSet(role))
      return {};

    if (grantable_permissions.isSet(granted))
      return {};

    return makeError<void>(DbErrorCode::kErrorNoPermissions, "No permissions.");
  }

  inline expected::Result<void, DbError> checkPermissions(
      std::string_view domain_id,
      std::string_view creator_domain_id,
      std::string_view qry_account_id,
      std::string_view creator_id,
      shared_model::interface::RolePermissionSet const &permissions,
      shared_model::interface::permissions::Role const all,
      shared_model::interface::permissions::Role const domain,
      shared_model::interface::permissions::Role const my) {
    if (permissions.isSet(all))
      return {};

    if (domain_id == creator_domain_id && permissions.isSet(domain))
      return {};

    if (qry_account_id == creator_id && permissions.isSet(my))
      return {};

    return makeError<void>(DbErrorCode::kErrorNoPermissions, "No permissions.");
  }

  struct PaginationContext {
    struct FirstEntry {
      std::string writer_from;
      std::string key_from;
    };

    std::optional<FirstEntry> first;
    uint64_t page_size;
  };

  inline expected::Result<std::string, DbError> aggregateAccountDetails(
      RocksDbCommon &common,
      std::string_view account,
      std::string_view domain,
      uint64_t &total,
      std::string_view writer_filter = std::string_view{},
      std::string_view key_filter = std::string_view{},
      std::optional<PaginationContext> pagination = std::nullopt,
      std::string *next_writer = nullptr,
      std::string *next_key = nullptr) {
    std::string result = "{";
    std::string prev_writer;

    auto remains = pagination ? pagination->page_size + 1ull
                              : std::numeric_limits<uint64_t>::max();
    bool found = !pagination || !pagination->first;
    bool have_entries = false;

    // TODO(iceseer): find first entry by log(N)
    total = 0ull;
    auto status = ametsuchi::enumerateKeysAndValues(
        common,
        [&](auto path, auto value) {
          auto const &[cur_writer, _, cur_key] =
              staticSplitId<3>(path.ToStringView(), fmtstrings::kDelimiter);

          have_entries = true;
          if (!writer_filter.empty() && cur_writer != writer_filter)
            return true;
          if (!key_filter.empty() && cur_key != key_filter)
            return true;

          ++total;
          if (!found) {
            if (cur_writer != pagination->first->writer_from
                || cur_key != pagination->first->key_from)
              return true;
            found = true;
          }

          if (remains == 0ull) {
            return true;
          } else if (remains-- == 1ull) {
            if (next_writer != nullptr)
              *next_writer = cur_writer;
            if (next_key != nullptr)
              *next_key = cur_key;
            return true;
          }

          if (prev_writer != cur_writer) {
            if (prev_writer.empty())
              result += '\"';
            else
              result += "},\"";
            result += cur_writer;
            result += "\": {";
            prev_writer = cur_writer;
          } else
            result += ", ";

          result += '\"';
          result += cur_key;
          result += "\": \"";
          result += value.ToStringView();
          result += '\"';

          return true;
        },
        fmtstrings::kPathAccountDetail,
        domain,
        account);
    RDB_ERROR_CHECK(canExist(status, [&]() {
      return fmt::format("Aggregate account {}@{} data", account, domain);
    }));

    if (!found && have_entries)
      return makeError<std::string>(DbErrorCode::kInvalidPagination,
                                    "Invalid pagination.");

    result += result.size() == 1ull ? "}" : "}}";
    return result;
  }

  inline expected::Result<void, DbError> dropWSV(RocksDbCommon &common) {
    if (auto status = common.filterDelete(fmtstrings::kPathWsv); !status.ok())
      return makeError<void>(DbErrorCode::kOperationFailed,
                             "Clear WSV failed.");
    return {};
  }

}  // namespace iroha::ametsuchi

#endif