Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Merge pull request #3787 from nanocurrency/move_lmdb_handles_to_their_respective_store

Browse source 
Moves the LDMB table handles to their respective type of store class
This commit is contained in:
Thiago Silva 2022-04-11 19:15:34 -03:00 • committed by GitHub
commit ce8c9727a7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 977 additions and 886 deletions
Download patch file Download diff file Expand all files Collapse all files

1341
nano/core_test/block_store.cpp
View file

File diff suppressed because it is too large Load diff

26
nano/node/lmdb/account_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -24,6 +26,30 @@ namespace lmdb
nano::store_iterator<nano::account, nano::account_info> rbegin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::account, nano::account_info> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::account_info>, nano::store_iterator<nano::account, nano::account_info>)> const & action_a) const override;
/**
* Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed)
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t
*/
MDB_dbi accounts_v0_handle{ 0 };
/**
* Maps account v0 to account information, head, rep, open, balance, timestamp and block count. (Removed)
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t
*/
MDB_dbi accounts_v1_handle{ 0 };
/**
* Maps account v0 to account information, head, rep, open, balance, timestamp, block count and epoch
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t, nano::epoch
*/
MDB_dbi accounts_handle{ 0 };
/**
* Representative weights. (Removed)
* nano::account -> nano::uint128_t
*/
MDB_dbi representation_handle{ 0 };
};
}
}

56
nano/node/lmdb/block_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
using mdb_val = db_val<MDB_val>;
@ -38,6 +40,60 @@ namespace lmdb
// Converts a block hash to a block height
uint64_t account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override;
/**
* Maps block hash to send block. (Removed)
* nano::block_hash -> nano::send_block
*/
MDB_dbi send_blocks_handle{ 0 };
/**
* Maps block hash to receive block. (Removed)
* nano::block_hash -> nano::receive_block
*/
MDB_dbi receive_blocks_handle{ 0 };
/**
* Maps block hash to open block. (Removed)
* nano::block_hash -> nano::open_block
*/
MDB_dbi open_blocks_handle{ 0 };
/**
* Maps block hash to change block. (Removed)
* nano::block_hash -> nano::change_block
*/
MDB_dbi change_blocks_handle{ 0 };
/**
* Maps block hash to v0 state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_v0_handle{ 0 };
/**
* Maps block hash to v1 state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_v1_handle{ 0 };
/**
* Maps block hash to state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_handle{ 0 };
/**
* Meta information about block store, such as versions.
* nano::uint256_union (arbitrary key) -> blob
*/
MDB_dbi meta_handle{ 0 };
/**
* Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks)
* nano::block_hash -> nano::block_sideband, nano::block
*/
MDB_dbi blocks_handle{ 0 };
protected:
void block_raw_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::mdb_val & value) const;
size_t block_successor_offset (nano::transaction const & transaction_a, size_t entry_size_a, nano::block_type type_a) const;

8
nano/node/lmdb/confirmation_height_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -24,6 +26,12 @@ namespace lmdb
nano::store_iterator<nano::account, nano::confirmation_height_info> begin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::account, nano::confirmation_height_info> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::account, nano::confirmation_height_info>, nano::store_iterator<nano::account, nano::confirmation_height_info>)> const & action_a) const override;
/*
* Confirmation height of an account, and the hash for the block at that height
* nano::account -> uint64_t, nano::block_hash
*/
MDB_dbi confirmation_height_handle{ 0 };
};
}
}

8
nano/node/lmdb/final_vote_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -24,6 +26,12 @@ namespace lmdb
nano::store_iterator<nano::qualified_root, nano::block_hash> begin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::qualified_root, nano::block_hash> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::qualified_root, nano::block_hash>, nano::store_iterator<nano::qualified_root, nano::block_hash>)> const & action_a) const override;
/**
* Maps root to block hash for generated final votes.
* nano::qualified_root -> nano::block_hash
*/
MDB_dbi final_votes_handle{ 0 };
};
}
}

12
nano/node/lmdb/frontier_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -9,6 +11,9 @@ namespace lmdb
class store;
class frontier_store : public nano::frontier_store
{
private:
nano::lmdb::store & store;
public:
frontier_store (nano::lmdb::store & store);
void put (nano::write_transaction const &, nano::block_hash const &, nano::account const &) override;
@ -19,8 +24,11 @@ namespace lmdb
nano::store_iterator<nano::block_hash, nano::account> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, nano::account>, nano::store_iterator<nano::block_hash, nano::account>)> const & action_a) const override;
private:
nano::lmdb::store & store;
/**
* Maps head block to owning account
* nano::block_hash -> nano::account
*/
MDB_dbi frontiers_handle{ 0 };
};
}
}

208
nano/node/lmdb/lmdb.cpp
View file

@ -78,12 +78,12 @@ nano::lmdb::store::store (nano::logger_mt & logger_a, boost::filesystem::path co
auto is_fresh_db (false);
{
auto transaction (tx_begin_read ());
auto err = mdb_dbi_open (env.tx (transaction), "meta", 0, &meta_handle);
auto err = mdb_dbi_open (env.tx (transaction), "meta", 0, &block_store.meta_handle);
is_fresh_db = err != MDB_SUCCESS;
if (err == MDB_SUCCESS)
{
is_fully_upgraded = (version.get (transaction) == version_current);
mdb_dbi_close (env, meta_handle);
mdb_dbi_close (env, block_store.meta_handle);
}
}
@ -210,52 +210,52 @@ nano::mdb_txn_callbacks nano::lmdb::store::create_txn_callbacks () const
void nano::lmdb::store::open_databases (bool & error_a, nano::transaction const & transaction_a, unsigned flags)
{
error_a |= mdb_dbi_open (env.tx (transaction_a), "frontiers", flags, &frontiers_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "meta", flags, &meta_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peers_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pruned", flags, &pruned_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "confirmation_height", flags, &confirmation_height_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts", flags, &accounts_v0_handle) != 0;
accounts_handle = accounts_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pending", flags, &pending_v0_handle) != 0;
pending_handle = pending_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "final_votes", flags, &final_votes_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "frontiers", flags, &frontier_store.frontiers_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked_store.unchecked_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight_store.online_weight_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "meta", flags, &block_store.meta_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peer_store.peers_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pruned", flags, &pruned_store.pruned_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "confirmation_height", flags, &confirmation_height_store.confirmation_height_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts", flags, &account_store.accounts_v0_handle) != 0;
account_store.accounts_handle = account_store.accounts_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pending", flags, &pending_store.pending_v0_handle) != 0;
pending_store.pending_handle = pending_store.pending_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "final_votes", flags, &final_vote_store.final_votes_handle) != 0;
auto version_l = version.get (transaction_a);
if (version_l < 19)
{
// These legacy (and state) block databases are no longer used, but need opening so they can be deleted during an upgrade
error_a |= mdb_dbi_open (env.tx (transaction_a), "send", flags, &send_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "receive", flags, &receive_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "open", flags, &open_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "change", flags, &change_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "send", flags, &block_store.send_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "receive", flags, &block_store.receive_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "open", flags, &block_store.open_blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "change", flags, &block_store.change_blocks_handle) != 0;
if (version_l >= 15)
{
error_a |= mdb_dbi_open (env.tx (transaction_a), "state_blocks", flags, &state_blocks_handle) != 0;
state_blocks_v0_handle = state_blocks_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "state_blocks", flags, &block_store.state_blocks_handle) != 0;
block_store.state_blocks_v0_handle = block_store.state_blocks_handle;
}
}
else
{
error_a |= mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &block_store.blocks_handle) != 0;
}
if (version_l < 16)
{
// The representation database is no longer used, but needs opening so that it can be deleted during an upgrade
error_a |= mdb_dbi_open (env.tx (transaction_a), "representation", flags, &representation_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "representation", flags, &account_store.representation_handle) != 0;
}
if (version_l < 15)
{
// These databases are no longer used, but need opening so they can be deleted during an upgrade
error_a |= mdb_dbi_open (env.tx (transaction_a), "state", flags, &state_blocks_v0_handle) != 0;
state_blocks_handle = state_blocks_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts_v1", flags, &accounts_v1_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pending_v1", flags, &pending_v1_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "state_v1", flags, &state_blocks_v1_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "state", flags, &block_store.state_blocks_v0_handle) != 0;
block_store.state_blocks_handle = block_store.state_blocks_v0_handle;
error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts_v1", flags, &account_store.accounts_v1_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "pending_v1", flags, &pending_store.pending_v1_handle) != 0;
error_a |= mdb_dbi_open (env.tx (transaction_a), "state_v1", flags, &block_store.state_blocks_v1_handle) != 0;
}
}
@ -320,10 +320,10 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
logger.always_log ("Preparing v14 to v15 database upgrade...");
std::vector<std::pair<nano::account, nano::account_info>> account_infos;
upgrade_counters account_counters (count (transaction_a, accounts_v0_handle), count (transaction_a, accounts_v1_handle));
upgrade_counters account_counters (count (transaction_a, account_store.accounts_v0_handle), count (transaction_a, account_store.accounts_v1_handle));
account_infos.reserve (account_counters.before_v0 + account_counters.before_v1);
nano::mdb_merge_iterator<nano::account, nano::account_info_v14> i_account (transaction_a, accounts_v0_handle, accounts_v1_handle);
nano::mdb_merge_iterator<nano::account, nano::account_info_v14> i_account (transaction_a, account_store.accounts_v0_handle, account_store.accounts_v1_handle);
nano::mdb_merge_iterator<nano::account, nano::account_info_v14> n_account{};
for (; i_account != n_account; ++i_account)
{
@ -335,7 +335,7 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
release_assert (rep_block != nullptr);
account_infos.emplace_back (account, nano::account_info{ account_info_v14.head, rep_block->representative (), account_info_v14.open_block, account_info_v14.balance, account_info_v14.modified, account_info_v14.block_count, i_account.from_first_database ? nano::epoch::epoch_0 : nano::epoch::epoch_1 });
// Move confirmation height from account_info database to its own table
mdb_put (env.tx (transaction_a), confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14.confirmation_height), MDB_APPEND);
mdb_put (env.tx (transaction_a), confirmation_height_store.confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14.confirmation_height), MDB_APPEND);
i_account.from_first_database ? ++account_counters.after_v0 : ++account_counters.after_v1;
}
@ -343,13 +343,13 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
debug_assert (account_counters.are_equal ());
// No longer need accounts_v1, keep v0 but clear it
mdb_drop (env.tx (transaction_a), accounts_v1_handle, 1);
mdb_drop (env.tx (transaction_a), accounts_v0_handle, 0);
mdb_drop (env.tx (transaction_a), account_store.accounts_v1_handle, 1);
mdb_drop (env.tx (transaction_a), account_store.accounts_v0_handle, 0);
for (auto const & account_account_info_pair : account_infos)
{
auto const & account_info (account_account_info_pair.second);
mdb_put (env.tx (transaction_a), accounts_handle, nano::mdb_val (account_account_info_pair.first), nano::mdb_val (account_info), MDB_APPEND);
mdb_put (env.tx (transaction_a), account_store.accounts_handle, nano::mdb_val (account_account_info_pair.first), nano::mdb_val (account_info), MDB_APPEND);
}
logger.always_log ("Epoch merge upgrade: Finished accounts, now doing state blocks");
@ -360,9 +360,9 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
MDB_dbi state_blocks_new;
mdb_dbi_open (env.tx (transaction_a), "state_blocks", MDB_CREATE, &state_blocks_new);
upgrade_counters state_counters (count (transaction_a, state_blocks_v0_handle), count (transaction_a, state_blocks_v1_handle));
upgrade_counters state_counters (count (transaction_a, block_store.state_blocks_v0_handle), count (transaction_a, block_store.state_blocks_v1_handle));
nano::mdb_merge_iterator<nano::block_hash, nano::state_block_w_sideband_v14> i_state (transaction_a, state_blocks_v0_handle, state_blocks_v1_handle);
nano::mdb_merge_iterator<nano::block_hash, nano::state_block_w_sideband_v14> i_state (transaction_a, block_store.state_blocks_v0_handle, block_store.state_blocks_v1_handle);
nano::mdb_merge_iterator<nano::block_hash, nano::state_block_w_sideband_v14> n_state{};
auto num = 0u;
for (; i_state != n_state; ++i_state, ++num)
@ -397,19 +397,19 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
debug_assert (state_counters.are_equal ());
logger.always_log ("Epoch merge upgrade: Finished state blocks, now doing pending blocks");
state_blocks_handle = state_blocks_new;
block_store.state_blocks_handle = state_blocks_new;
// No longer need states v0/v1 databases
mdb_drop (env.tx (transaction_a), state_blocks_v1_handle, 1);
mdb_drop (env.tx (transaction_a), state_blocks_v0_handle, 1);
mdb_drop (env.tx (transaction_a), block_store.state_blocks_v1_handle, 1);
mdb_drop (env.tx (transaction_a), block_store.state_blocks_v0_handle, 1);
state_blocks_v0_handle = state_blocks_handle;
block_store.state_blocks_v0_handle = block_store.state_blocks_handle;
upgrade_counters pending_counters (count (transaction_a, pending_v0_handle), count (transaction_a, pending_v1_handle));
upgrade_counters pending_counters (count (transaction_a, pending_store.pending_v0_handle), count (transaction_a, pending_store.pending_v1_handle));
std::vector<std::pair<nano::pending_key, nano::pending_info>> pending_infos;
pending_infos.reserve (pending_counters.before_v0 + pending_counters.before_v1);
nano::mdb_merge_iterator<nano::pending_key, nano::pending_info_v14> i_pending (transaction_a, pending_v0_handle, pending_v1_handle);
nano::mdb_merge_iterator<nano::pending_key, nano::pending_info_v14> i_pending (transaction_a, pending_store.pending_v0_handle, pending_store.pending_v1_handle);
nano::mdb_merge_iterator<nano::pending_key, nano::pending_info_v14> n_pending{};
for (; i_pending != n_pending; ++i_pending)
{
@ -421,12 +421,12 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
debug_assert (pending_counters.are_equal ());
// No longer need the pending v1 table
mdb_drop (env.tx (transaction_a), pending_v1_handle, 1);
mdb_drop (env.tx (transaction_a), pending_v0_handle, 0);
mdb_drop (env.tx (transaction_a), pending_store.pending_v1_handle, 1);
mdb_drop (env.tx (transaction_a), pending_store.pending_v0_handle, 0);
for (auto const & pending_key_pending_info_pair : pending_infos)
{
mdb_put (env.tx (transaction_a), pending_handle, nano::mdb_val (pending_key_pending_info_pair.first), nano::mdb_val (pending_key_pending_info_pair.second), MDB_APPEND);
mdb_put (env.tx (transaction_a), pending_store.pending_handle, nano::mdb_val (pending_key_pending_info_pair.first), nano::mdb_val (pending_key_pending_info_pair.second), MDB_APPEND);
}
version.put (transaction_a, 15);
@ -436,12 +436,12 @@ void nano::lmdb::store::upgrade_v14_to_v15 (nano::write_transaction & transactio
void nano::lmdb::store::upgrade_v15_to_v16 (nano::write_transaction const & transaction_a)
{
// Representation table is no longer used
debug_assert (representation_handle != 0);
if (representation_handle != 0)
debug_assert (account_store.representation_handle != 0);
if (account_store.representation_handle != 0)
{
auto status (mdb_drop (env.tx (transaction_a), representation_handle, 1));
auto status (mdb_drop (env.tx (transaction_a), account_store.representation_handle, 1));
release_assert (status == MDB_SUCCESS);
representation_handle = 0;
account_store.representation_handle = 0;
}
version.put (transaction_a, 16);
}
@ -456,7 +456,7 @@ void nano::lmdb::store::upgrade_v16_to_v17 (nano::write_transaction const & tran
// Set the confirmed frontier for each account in the confirmation height table
std::vector<std::pair<nano::account, nano::confirmation_height_info>> confirmation_height_infos;
auto num = 0u;
for (nano::mdb_iterator<nano::account, uint64_t> i (transaction_a, confirmation_height_handle), n (nano::mdb_iterator<nano::account, uint64_t>{}); i != n; ++i, ++account_info_i, ++num)
for (nano::mdb_iterator<nano::account, uint64_t> i (transaction_a, confirmation_height_store.confirmation_height_handle), n (nano::mdb_iterator<nano::account, uint64_t>{}); i != n; ++i, ++account_info_i, ++num)
{
nano::account account (i->first);
uint64_t confirmation_height (i->second);
@ -513,12 +513,12 @@ void nano::lmdb::store::upgrade_v16_to_v17 (nano::write_transaction const & tran
}
// Clear it then append
auto status (mdb_drop (env.tx (transaction_a), confirmation_height_handle, 0));
auto status (mdb_drop (env.tx (transaction_a), confirmation_height_store.confirmation_height_handle, 0));
release_assert_success (status);
for (auto const & confirmation_height_info_pair : confirmation_height_infos)
{
mdb_put (env.tx (transaction_a), confirmation_height_handle, nano::mdb_val (confirmation_height_info_pair.first), nano::mdb_val (confirmation_height_info_pair.second), MDB_APPEND);
mdb_put (env.tx (transaction_a), confirmation_height_store.confirmation_height_handle, nano::mdb_val (confirmation_height_info_pair.first), nano::mdb_val (confirmation_height_info_pair.second), MDB_APPEND);
}
version.put (transaction_a, 17);
@ -529,10 +529,10 @@ void nano::lmdb::store::upgrade_v17_to_v18 (nano::write_transaction const & tran
{
logger.always_log ("Preparing v17 to v18 database upgrade...");
auto count_pre (count (transaction_a, state_blocks_handle));
auto count_pre (count (transaction_a, block_store.state_blocks_handle));
auto num = 0u;
for (nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> state_i (transaction_a, state_blocks_handle), state_n{}; state_i != state_n; ++state_i, ++num)
for (nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> state_i (transaction_a, block_store.state_blocks_handle), state_n{}; state_i != state_n; ++state_i, ++num)
{
nano::block_w_sideband_v18<nano::state_block> block_w_sideband (state_i->second);
auto & block (block_w_sideband.block);
@ -580,7 +580,7 @@ void nano::lmdb::store::upgrade_v17_to_v18 (nano::write_transaction const & tran
}
}
auto count_post (count (transaction_a, state_blocks_handle));
auto count_post (count (transaction_a, block_store.state_blocks_handle));
release_assert (count_pre == count_post);
version.put (transaction_a, 18);
@ -590,38 +590,38 @@ void nano::lmdb::store::upgrade_v17_to_v18 (nano::write_transaction const & tran
void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & transaction_a)
{
logger.always_log ("Preparing v18 to v19 database upgrade...");
auto count_pre (count (transaction_a, state_blocks_handle) + count (transaction_a, send_blocks_handle) + count (transaction_a, receive_blocks_handle) + count (transaction_a, change_blocks_handle) + count (transaction_a, open_blocks_handle));
auto count_pre (count (transaction_a, block_store.state_blocks_handle) + count (transaction_a, block_store.send_blocks_handle) + count (transaction_a, block_store.receive_blocks_handle) + count (transaction_a, block_store.change_blocks_handle) + count (transaction_a, block_store.open_blocks_handle));
// Combine in order of likeliness of counts
std::map<nano::block_hash, nano::block_w_sideband> legacy_open_receive_change_blocks;
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>>> (transaction_a, change_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>>> (transaction_a, block_store.change_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::change_block>> (nullptr)); i != n; ++i)
{
nano::block_sideband_v18 const & old_sideband (i->second.sideband);
nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0);
legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } };
}
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>>> (transaction_a, open_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>>> (transaction_a, block_store.open_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::open_block>> (nullptr)); i != n; ++i)
{
nano::block_sideband_v18 const & old_sideband (i->second.sideband);
nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0);
legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } };
}
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>>> (transaction_a, receive_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>>> (transaction_a, block_store.receive_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::receive_block>> (nullptr)); i != n; ++i)
{
nano::block_sideband_v18 const & old_sideband (i->second.sideband);
nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0);
legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } };
}
release_assert (!mdb_drop (env.tx (transaction_a), receive_blocks_handle, 1));
receive_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), open_blocks_handle, 1));
open_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), change_blocks_handle, 1));
change_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), block_store.receive_blocks_handle, 1));
block_store.receive_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), block_store.open_blocks_handle, 1));
block_store.open_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), block_store.change_blocks_handle, 1));
block_store.change_blocks_handle = 0;
logger.always_log ("Write legacy open/receive/change to new format");
@ -651,7 +651,7 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
{
mdb_dbi_open (env.tx (transaction_a), "temp_legacy_send_blocks", MDB_CREATE, &temp_legacy_send_blocks);
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>>> (transaction_a, send_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>>> (transaction_a, block_store.send_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::send_block>> (nullptr)); i != n; ++i)
{
auto const & block_w_sideband_v18 (i->second);
@ -668,8 +668,8 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
}
}
release_assert (!mdb_drop (env.tx (transaction_a), send_blocks_handle, 1));
send_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), block_store.send_blocks_handle, 1));
block_store.send_blocks_handle = 0;
logger.always_log ("Merge legacy open/receive/change with legacy send blocks");
@ -698,7 +698,7 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
auto type_state (nano::block_type::state);
mdb_dbi_open (env.tx (transaction_a), "temp_state_blocks", MDB_CREATE, &temp_state_blocks);
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>>> (transaction_a, state_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> (std::make_unique<nano::mdb_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>>> (transaction_a, block_store.state_blocks_handle))), n (nano::store_iterator<nano::block_hash, nano::block_w_sideband_v18<nano::state_block>> (nullptr)); i != n; ++i)
{
auto const & block_w_sideband_v18 (i->second);
nano::block_sideband_v18 const & old_sideband (block_w_sideband_v18.sideband);
@ -733,18 +733,18 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
}
}
release_assert (!mdb_drop (env.tx (transaction_a), state_blocks_handle, 1));
state_blocks_handle = 0;
release_assert (!mdb_drop (env.tx (transaction_a), block_store.state_blocks_handle, 1));
block_store.state_blocks_handle = 0;
logger.always_log ("Merging all legacy blocks with state blocks");
// Merge all legacy blocks with state blocks into the final table
nano::mdb_merge_iterator<nano::block_hash, nano::block_w_sideband> i (transaction_a, temp_legacy_send_open_receive_change_blocks, temp_state_blocks);
nano::mdb_merge_iterator<nano::block_hash, nano::block_w_sideband> n{};
mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks_handle);
mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &block_store.blocks_handle);
for (; i != n; ++i)
{
auto s = mdb_put (env.tx (transaction_a), blocks_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND);
auto s = mdb_put (env.tx (transaction_a), block_store.blocks_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND);
release_assert_success (s);
}
@ -752,7 +752,7 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
mdb_drop (env.tx (transaction_a), temp_legacy_send_open_receive_change_blocks, 1);
mdb_drop (env.tx (transaction_a), temp_state_blocks, 1);
auto count_post (count (transaction_a, blocks_handle));
auto count_post (count (transaction_a, block_store.blocks_handle));
release_assert (count_pre == count_post);
MDB_dbi vote{ 0 };
@ -766,7 +766,7 @@ void nano::lmdb::store::upgrade_v18_to_v19 (nano::write_transaction const & tran
void nano::lmdb::store::upgrade_v19_to_v20 (nano::write_transaction const & transaction_a)
{
logger.always_log ("Preparing v19 to v20 database upgrade...");
mdb_dbi_open (env.tx (transaction_a), "pruned", MDB_CREATE, &pruned_handle);
mdb_dbi_open (env.tx (transaction_a), "pruned", MDB_CREATE, &pruned_store.pruned_handle);
version.put (transaction_a, 20);
logger.always_log ("Finished creating new pruned table");
}
@ -774,7 +774,7 @@ void nano::lmdb::store::upgrade_v19_to_v20 (nano::write_transaction const & tran
void nano::lmdb::store::upgrade_v20_to_v21 (nano::write_transaction const & transaction_a)
{
logger.always_log ("Preparing v20 to v21 database upgrade...");
mdb_dbi_open (env.tx (transaction_a), "final_votes", MDB_CREATE, &final_votes_handle);
mdb_dbi_open (env.tx (transaction_a), "final_votes", MDB_CREATE, &final_vote_store.final_votes_handle);
version.put (transaction_a, 21);
logger.always_log ("Finished creating new final_vote table");
}
@ -861,30 +861,30 @@ MDB_dbi nano::lmdb::store::table_to_dbi (tables table_a) const
switch (table_a)
{
case tables::frontiers:
return frontiers_handle;
return frontier_store.frontiers_handle;
case tables::accounts:
return accounts_handle;
return account_store.accounts_handle;
case tables::blocks:
return blocks_handle;
return block_store.blocks_handle;
case tables::pending:
return pending_handle;
return pending_store.pending_handle;
case tables::unchecked:
return unchecked_handle;
return unchecked_store.unchecked_handle;
case tables::online_weight:
return online_weight_handle;
return online_weight_store.online_weight_handle;
case tables::meta:
return meta_handle;
return block_store.meta_handle;
case tables::peers:
return peers_handle;
return peer_store.peers_handle;
case tables::pruned:
return pruned_handle;
return pruned_store.pruned_handle;
case tables::confirmation_height:
return confirmation_height_handle;
return confirmation_height_store.confirmation_height_handle;
case tables::final_votes:
return final_votes_handle;
return final_vote_store.final_votes_handle;
default:
release_assert (false);
return peers_handle;
return peer_store.peers_handle;
}
}
@ -916,7 +916,7 @@ bool nano::lmdb::store::copy_db (boost::filesystem::path const & destination_fil
void nano::lmdb::store::rebuild_db (nano::write_transaction const & transaction_a)
{
// Tables with uint256_union key
std::vector<MDB_dbi> tables = { accounts_handle, blocks_handle, pruned_handle, confirmation_height_handle };
std::vector<MDB_dbi> tables = { account_store.accounts_handle, block_store.blocks_handle, pruned_store.pruned_handle, confirmation_height_store.confirmation_height_handle };
for (auto const & table : tables)
{
MDB_dbi temp;
@ -945,20 +945,20 @@ void nano::lmdb::store::rebuild_db (nano::write_transaction const & transaction_
MDB_dbi temp;
mdb_dbi_open (env.tx (transaction_a), "temp_table", MDB_CREATE, &temp);
// Copy all values to temporary table
for (auto i (nano::store_iterator<nano::pending_key, nano::pending_info> (std::make_unique<nano::mdb_iterator<nano::pending_key, nano::pending_info>> (transaction_a, pending_handle))), n (nano::store_iterator<nano::pending_key, nano::pending_info> (nullptr)); i != n; ++i)
for (auto i (nano::store_iterator<nano::pending_key, nano::pending_info> (std::make_unique<nano::mdb_iterator<nano::pending_key, nano::pending_info>> (transaction_a, pending_store.pending_handle))), n (nano::store_iterator<nano::pending_key, nano::pending_info> (nullptr)); i != n; ++i)
{
auto s = mdb_put (env.tx (transaction_a), temp, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_handle) == count (transaction_a, temp));
mdb_drop (env.tx (transaction_a), pending_handle, 0);
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
mdb_drop (env.tx (transaction_a), pending_store.pending_handle, 0);
// Put values from copy
for (auto i (nano::store_iterator<nano::pending_key, nano::pending_info> (std::make_unique<nano::mdb_iterator<nano::pending_key, nano::pending_info>> (transaction_a, temp))), n (nano::store_iterator<nano::pending_key, nano::pending_info> (nullptr)); i != n; ++i)
{
auto s = mdb_put (env.tx (transaction_a), pending_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND);
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_handle) == count (transaction_a, temp));
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
mdb_drop (env.tx (transaction_a), temp, 1);
}
}
@ -1014,27 +1014,27 @@ boost::optional<nano::mdb_val> nano::lmdb::store::block_raw_get_by_type_v18 (nan
{
case nano::block_type::send:
{
status = mdb_get (env.tx (transaction_a), send_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.send_blocks_handle, hash, value);
break;
}
case nano::block_type::receive:
{
status = mdb_get (env.tx (transaction_a), receive_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.receive_blocks_handle, hash, value);
break;
}
case nano::block_type::open:
{
status = mdb_get (env.tx (transaction_a), open_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.open_blocks_handle, hash, value);
break;
}
case nano::block_type::change:
{
status = mdb_get (env.tx (transaction_a), change_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.change_blocks_handle, hash, value);
break;
}
case nano::block_type::state:
{
status = mdb_get (env.tx (transaction_a), state_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.state_blocks_handle, hash, value);
break;
}
case nano::block_type::invalid:
@ -1115,34 +1115,34 @@ boost::optional<nano::mdb_val> nano::lmdb::store::block_raw_get_by_type_v14 (nan
{
case nano::block_type::send:
{
status = mdb_get (env.tx (transaction_a), send_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.send_blocks_handle, hash, value);
break;
}
case nano::block_type::receive:
{
status = mdb_get (env.tx (transaction_a), receive_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.receive_blocks_handle, hash, value);
break;
}
case nano::block_type::open:
{
status = mdb_get (env.tx (transaction_a), open_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.open_blocks_handle, hash, value);
break;
}
case nano::block_type::change:
{
status = mdb_get (env.tx (transaction_a), change_blocks_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.change_blocks_handle, hash, value);
break;
}
case nano::block_type::state:
{
status = mdb_get (env.tx (transaction_a), state_blocks_v1_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.state_blocks_v1_handle, hash, value);
if (is_state_v1 != nullptr)
{
*is_state_v1 = success (status);
}
if (not_found (status))
{
status = mdb_get (env.tx (transaction_a), state_blocks_v0_handle, hash, value);
status = mdb_get (env.tx (transaction_a), block_store.state_blocks_v0_handle, hash, value);
}
break;
}

152
nano/node/lmdb/lmdb.hpp
View file

@ -94,144 +94,6 @@ namespace lmdb
public:
nano::mdb_env env;
/**
* Maps head block to owning account
* nano::block_hash -> nano::account
*/
MDB_dbi frontiers_handle{ 0 };
/**
* Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed)
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t
*/
MDB_dbi accounts_v0_handle{ 0 };
/**
* Maps account v0 to account information, head, rep, open, balance, timestamp and block count. (Removed)
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t
*/
MDB_dbi accounts_v1_handle{ 0 };
/**
* Maps account v0 to account information, head, rep, open, balance, timestamp, block count and epoch
* nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t, nano::epoch
*/
MDB_dbi accounts_handle{ 0 };
/**
* Maps block hash to send block. (Removed)
* nano::block_hash -> nano::send_block
*/
MDB_dbi send_blocks_handle{ 0 };
/**
* Maps block hash to receive block. (Removed)
* nano::block_hash -> nano::receive_block
*/
MDB_dbi receive_blocks_handle{ 0 };
/**
* Maps block hash to open block. (Removed)
* nano::block_hash -> nano::open_block
*/
MDB_dbi open_blocks_handle{ 0 };
/**
* Maps block hash to change block. (Removed)
* nano::block_hash -> nano::change_block
*/
MDB_dbi change_blocks_handle{ 0 };
/**
* Maps block hash to v0 state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_v0_handle{ 0 };
/**
* Maps block hash to v1 state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_v1_handle{ 0 };
/**
* Maps block hash to state block. (Removed)
* nano::block_hash -> nano::state_block
*/
MDB_dbi state_blocks_handle{ 0 };
/**
* Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount
*/
MDB_dbi pending_v0_handle{ 0 };
/**
* Maps min_version 1 (destination account, pending block) to (source account, amount). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount
*/
MDB_dbi pending_v1_handle{ 0 };
/**
* Maps (destination account, pending block) to (source account, amount, version). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount, nano::epoch
*/
MDB_dbi pending_handle{ 0 };
/**
* Representative weights. (Removed)
* nano::account -> nano::uint128_t
*/
MDB_dbi representation_handle{ 0 };
/**
* Unchecked bootstrap blocks info.
* nano::block_hash -> nano::unchecked_info
*/
MDB_dbi unchecked_handle{ 0 };
/**
* Samples of online vote weight
* uint64_t -> nano::amount
*/
MDB_dbi online_weight_handle{ 0 };
/**
* Meta information about block store, such as versions.
* nano::uint256_union (arbitrary key) -> blob
*/
MDB_dbi meta_handle{ 0 };
/**
* Pruned blocks hashes
* nano::block_hash -> none
*/
MDB_dbi pruned_handle{ 0 };
/*
* Endpoints for peers
* nano::endpoint_key -> no_value
*/
MDB_dbi peers_handle{ 0 };
/*
* Confirmation height of an account, and the hash for the block at that height
* nano::account -> uint64_t, nano::block_hash
*/
MDB_dbi confirmation_height_handle{ 0 };
/*
* Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks)
* nano::block_hash -> nano::block_sideband, nano::block
*/
MDB_dbi blocks_handle{ 0 };
/**
* Maps root to block hash for generated final votes.
* nano::qualified_root -> nano::block_hash
*/
MDB_dbi final_votes_handle{ 0 };
bool exists (nano::transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a) const;
int get (nano::transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, nano::mdb_val & value_a) const;
@ -317,6 +179,20 @@ namespace lmdb
uint64_t after_v0{ 0 };
uint64_t after_v1{ 0 };
};
friend class mdb_block_store_supported_version_upgrades_Test;
friend class mdb_block_store_upgrade_v14_v15_Test;
friend class mdb_block_store_upgrade_v15_v16_Test;
friend class mdb_block_store_upgrade_v16_v17_Test;
friend class mdb_block_store_upgrade_v17_v18_Test;
friend class mdb_block_store_upgrade_v18_v19_Test;
friend class mdb_block_store_upgrade_v19_v20_Test;
friend class mdb_block_store_upgrade_v20_v21_Test;
friend class block_store_DISABLED_change_dupsort_Test;
friend void write_sideband_v14 (nano::lmdb::store &, nano::transaction &, nano::block const &, MDB_dbi);
friend void write_sideband_v15 (nano::lmdb::store &, nano::transaction &, nano::block const &);
friend void modify_account_info_to_v14 (nano::lmdb::store &, nano::transaction const &, nano::account const &, uint64_t, nano::block_hash const &);
friend void modify_confirmation_height_to_v15 (nano::lmdb::store &, nano::transaction const &, nano::account const &, uint64_t);
};
}

8
nano/node/lmdb/online_weight_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -20,6 +22,12 @@ namespace lmdb
nano::store_iterator<uint64_t, nano::amount> end () const override;
size_t count (nano::transaction const & transaction_a) const override;
void clear (nano::write_transaction const & transaction_a) override;
/**
* Samples of online vote weight
* uint64_t -> nano::amount
*/
MDB_dbi online_weight_handle{ 0 };
};
}
}

8
nano/node/lmdb/peer_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -21,6 +23,12 @@ namespace lmdb
void clear (nano::write_transaction const & transaction_a) override;
nano::store_iterator<nano::endpoint_key, nano::no_value> begin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::endpoint_key, nano::no_value> end () const override;
/*
* Endpoints for peers
* nano::endpoint_key -> no_value
*/
MDB_dbi peers_handle{ 0 };
};
}
}

20
nano/node/lmdb/pending_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -23,6 +25,24 @@ namespace lmdb
nano::store_iterator<nano::pending_key, nano::pending_info> begin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::pending_key, nano::pending_info> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::pending_key, nano::pending_info>, nano::store_iterator<nano::pending_key, nano::pending_info>)> const & action_a) const override;
/**
* Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount
*/
MDB_dbi pending_v0_handle{ 0 };
/**
* Maps min_version 1 (destination account, pending block) to (source account, amount). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount
*/
MDB_dbi pending_v1_handle{ 0 };
/**
* Maps (destination account, pending block) to (source account, amount, version). (Removed)
* nano::account, nano::block_hash -> nano::account, nano::amount, nano::epoch
*/
MDB_dbi pending_handle{ 0 };
};
}
}

8
nano/node/lmdb/pruned_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -24,6 +26,12 @@ namespace lmdb
nano::store_iterator<nano::block_hash, std::nullptr_t> begin (nano::transaction const & transaction_a) const override;
nano::store_iterator<nano::block_hash, std::nullptr_t> end () const override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::block_hash, std::nullptr_t>, nano::store_iterator<nano::block_hash, std::nullptr_t>)> const & action_a) const override;
/**
* Pruned blocks hashes
* nano::block_hash -> none
*/
MDB_dbi pruned_handle{ 0 };
};
}
}

8
nano/node/lmdb/unchecked_store.hpp
View file

@ -2,6 +2,8 @@
#include <nano/secure/store.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano
{
namespace lmdb
@ -24,6 +26,12 @@ namespace lmdb
nano::store_iterator<nano::unchecked_key, nano::unchecked_info> lower_bound (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) const override;
size_t count (nano::transaction const & transaction_a) override;
void for_each_par (std::function<void (nano::read_transaction const &, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>, nano::store_iterator<nano::unchecked_key, nano::unchecked_info>)> const & action_a) const override;
/**
* Unchecked bootstrap blocks info.
* nano::block_hash -> nano::unchecked_info
*/
MDB_dbi unchecked_handle{ 0 };
};
}
}