dn724/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

231
nano/core_test/block_store.cpp
View file

@ -24,7 +24,9 @@
using namespace std::chrono_literals;
namespace
namespace nano
{
namespace lmdb
{
void modify_account_info_to_v14 (nano::lmdb::store & store, nano::transaction const & transaction_a, nano::account const & account_a, uint64_t confirmation_height, nano::block_hash const & rep_block);
void modify_confirmation_height_to_v15 (nano::lmdb::store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height);
@ -32,6 +34,7 @@ void write_sideband_v14 (nano::lmdb::store & store_a, nano::transaction & transa
void write_sideband_v15 (nano::lmdb::store & store_a, nano::transaction & transaction_a, nano::block const & block_a);
void write_block_w_sideband_v18 (nano::lmdb::store & store_a, MDB_dbi database, nano::write_transaction & transaction_a, nano::block const & block_a);
}
}
TEST (block_store, construction)
{
@ -688,6 +691,10 @@ TEST (block_store, latest_find)
ASSERT_EQ (second, find3);
}
namespace nano
{
namespace lmdb
{
TEST (mdb_block_store, supported_version_upgrades)
{
if (nano::rocksdb_config::using_rocksdb_in_tests ())
@ -725,10 +732,12 @@ TEST (mdb_block_store, supported_version_upgrades)
// Lower the database version to the minimum version supported for upgrade.
store.version.put (transaction, store.version_minimum);
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), 1, nano::dev::genesis->hash ());
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE,
&store.account_store.accounts_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle));
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), 1,
nano::dev::genesis->hash ());
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
}
// Upgrade should work
@ -737,6 +746,8 @@ TEST (mdb_block_store, supported_version_upgrades)
ASSERT_FALSE (store.init_error ());
}
}
}
}
TEST (mdb_block_store, bad_path)
{
@ -954,6 +965,10 @@ TEST (block_store, pruned_random)
ASSERT_EQ (hash1, random_hash);
}
namespace nano
{
namespace lmdb
{
// Databases need to be dropped in order to convert to dupsort compatible
TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort table
{
@ -962,23 +977,25 @@ TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort ta
nano::lmdb::store store{ logger, path, nano::dev::constants };
nano::unchecked_map unchecked{ store, false };
auto transaction (store.tx_begin_write ());
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 1));
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked_handle));
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 1));
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked_store.unchecked_handle));
std::shared_ptr<nano::block> send1 = std::make_shared<nano::send_block> (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
std::shared_ptr<nano::block> send2 = std::make_shared<nano::send_block> (1, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
ASSERT_NE (send1->hash (), send2->hash ());
unchecked.put (send1->hash (), send1);
unchecked.put (send1->hash (), send2);
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 0));
mdb_dbi_close (store.env, store.unchecked_handle);
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_handle));
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 0));
mdb_dbi_close (store.env, store.unchecked_store.unchecked_handle);
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_store.unchecked_handle));
unchecked.put (send1->hash (), send1);
unchecked.put (send1->hash (), send2);
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 1));
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_handle));
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_store.unchecked_handle, 1));
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_store.unchecked_handle));
unchecked.put (send1->hash (), send1);
unchecked.put (send1->hash (), send2);
}
}
}
TEST (block_store, state_block)
{
@ -1275,6 +1292,10 @@ TEST (block_store, pruned_blocks)
ASSERT_EQ (store->pruned.count (store->tx_begin_read ()), 0);
}
namespace nano
{
namespace lmdb
{
TEST (mdb_block_store, upgrade_v14_v15)
{
if (nano::rocksdb_config::using_rocksdb_in_tests ())
@ -1285,9 +1306,12 @@ TEST (mdb_block_store, upgrade_v14_v15)
// Extract confirmation height to a separate database
auto path (nano::unique_path ());
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
nano::state_block epoch (nano::dev::genesis_key.pub, send.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub,
nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
nano::state_block epoch (nano::dev::genesis_key.pub, send.hash (), nano::dev::genesis_key.pub,
nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub,
nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
{
nano::logger_mt logger;
nano::lmdb::store store (logger, path, nano::dev::constants);
@ -1298,48 +1322,67 @@ TEST (mdb_block_store, upgrade_v14_v15)
nano::account_info account_info;
ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis->account (), account_info));
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (),
confirmation_height_info));
ASSERT_EQ (confirmation_height_info.height, 1);
ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ());
// These databases get removed after an upgrade, so readd them
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_v1", MDB_CREATE, &store.state_blocks_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "pending_v1", MDB_CREATE, &store.pending_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle));
ASSERT_FALSE (
mdb_dbi_open (store.env.tx (transaction), "state_v1", MDB_CREATE, &store.block_store.state_blocks_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE,
&store.account_store.accounts_v1_handle));
ASSERT_FALSE (
mdb_dbi_open (store.env.tx (transaction), "pending_v1", MDB_CREATE, &store.pending_store.pending_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.block_store.send_blocks_handle));
ASSERT_FALSE (
mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE,
&store.block_store.state_blocks_handle));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code);
// Lower the database to the previous version
store.version.put (transaction, 14);
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), confirmation_height_info.height, state_send.hash ());
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (),
confirmation_height_info.height, state_send.hash ());
store.pending.del (transaction, nano::pending_key (nano::dev::genesis->account (), state_send.hash ()));
write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1_handle);
write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1_handle);
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send);
write_sideband_v14 (store, transaction, state_send, store.block_store.state_blocks_v1_handle);
write_sideband_v14 (store, transaction, epoch, store.block_store.state_blocks_v1_handle);
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send);
// Remove from blocks table
store.block.del (transaction, state_send.hash ());
store.block.del (transaction, epoch.hash ());
// Turn pending into v14
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_0)), 0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_1)), 0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_store.pending_v0_handle,
nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, send.hash ())),
nano::mdb_val (
nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio,
nano::epoch::epoch_0)),
0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_store.pending_v1_handle,
nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())),
nano::mdb_val (
nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio,
nano::epoch::epoch_1)),
0));
// This should fail as sizes are no longer correct for account_info
nano::mdb_val value;
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.account_store.accounts_v1_handle,
nano::mdb_val (nano::dev::genesis->account ()), value));
nano::account_info info;
ASSERT_NE (value.size (), info.db_size ());
store.account.del (transaction, nano::dev::genesis->account ());
// Confirmation height for the account should be deleted
ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_store.confirmation_height_handle,
nano::mdb_val (nano::dev::genesis->account ()), value));
}
// Now do the upgrade
@ -1350,22 +1393,28 @@ TEST (mdb_block_store, upgrade_v14_v15)
// Size of account_info should now equal that set in db
nano::mdb_val value;
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.account_store.accounts_handle,
nano::mdb_val (nano::dev::genesis->account ()), value));
nano::account_info info (value);
ASSERT_EQ (value.size (), info.db_size ());
// Confirmation height should exist
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
ASSERT_FALSE (
store.confirmation_height.get (transaction, nano::dev::genesis->account (),
confirmation_height_info));
ASSERT_EQ (confirmation_height_info.height, 1);
ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ());
// accounts_v1, state_blocks_v1 & pending_v1 tables should be deleted
auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.account_store.accounts_v1_handle,
nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_NE (error_get_accounts_v1, MDB_SUCCESS);
auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), value));
auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), value));
ASSERT_NE (error_get_pending_v1, MDB_SUCCESS);
auto error_get_state_v1 (mdb_get (store.env.tx (transaction), store.state_blocks_v1_handle, nano::mdb_val (state_send.hash ()), value));
auto error_get_state_v1 (
mdb_get (store.env.tx (transaction), store.block_store.state_blocks_v1_handle, nano::mdb_val (state_send.hash ()),
value));
ASSERT_NE (error_get_state_v1, MDB_SUCCESS);
// Check that the epochs are set correctly for the sideband, accounts and pending entries
@ -1379,7 +1428,8 @@ TEST (mdb_block_store, upgrade_v14_v15)
nano::pending_info pending_info;
store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, send.hash ()), pending_info);
ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_0);
store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ()), pending_info);
store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ()),
pending_info);
ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_1);
// Version should be correct
@ -1404,15 +1454,16 @@ TEST (mdb_block_store, upgrade_v15_v16)
store.initialize (transaction, ledger.cache, nano::dev::constants);
// The representation table should get removed after, so readd it so that we can later confirm this actually happens
auto txn = store.env.tx (transaction);
ASSERT_FALSE (mdb_dbi_open (txn, "representation", MDB_CREATE, &store.representation_handle));
ASSERT_FALSE (
mdb_dbi_open (txn, "representation", MDB_CREATE, &store.account_store.representation_handle));
auto weight = ledger.cache.rep_weights.representation_get (nano::dev::genesis->account ());
ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), nano::mdb_val (nano::uint128_union (weight)), 0));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.account_store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), nano::mdb_val (nano::uint128_union (weight)), 0));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle));
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
// Lower the database to the previous version
store.version.put (transaction, 15);
// Confirm the rep weight exists in the database
ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.account_store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
}
@ -1423,9 +1474,10 @@ TEST (mdb_block_store, upgrade_v15_v16)
auto transaction (store.tx_begin_read ());
// The representation table should now be deleted
auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
auto error_get_representation (mdb_get (store.env.tx (transaction), store.account_store.representation_handle,
nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_NE (MDB_SUCCESS, error_get_representation);
ASSERT_EQ (store.representation_handle, 0);
ASSERT_EQ (store.account_store.representation_handle, 0);
// Version should be correct
ASSERT_LT (15, store.version.get (transaction));
@ -1458,12 +1510,12 @@ TEST (mdb_block_store, upgrade_v16_v17)
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code);
modify_confirmation_height_to_v15 (store, transaction, nano::dev::genesis->account (), confirmation_height);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle));
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block1);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block2);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block3);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle));
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.block_store.state_blocks_handle));
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block1);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block2);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, block3);
// Lower the database to the previous version
store.version.put (transaction, 16);
@ -1537,19 +1589,19 @@ TEST (mdb_block_store, upgrade_v17_v18)
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_open).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send_epoch_link).code);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.block_store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.block_store.send_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.block_store.state_blocks_handle));
// Downgrade the store
store.version.put (transaction, 17);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_receive);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, epoch_first);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send2);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send_epoch_link);
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send_zero);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_receive);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, epoch_first);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send2);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send_epoch_link);
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send_zero);
// Replace with the previous sideband version for state blocks
// The upgrade can resume after upgrading some blocks, test this by only downgrading some of them
@ -1578,7 +1630,7 @@ TEST (mdb_block_store, upgrade_v17_v18)
// Size of state block should equal that set in db (no change)
nano::mdb_val value;
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.blocks_handle, nano::mdb_val (state_send.hash ()), value));
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.block_store.blocks_handle, nano::mdb_val (state_send.hash ()), value));
ASSERT_EQ (value.size (), sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state));
// Check that sidebands are correctly populated
@ -1729,20 +1781,20 @@ TEST (mdb_block_store, upgrade_v18_v19)
// These tables need to be re-opened and populated so that an upgrade can be done
auto txn = store.env.tx (transaction);
ASSERT_FALSE (mdb_dbi_open (txn, "open", MDB_CREATE, &store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "receive", MDB_CREATE, &store.receive_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "send", MDB_CREATE, &store.send_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "change", MDB_CREATE, &store.change_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "state_blocks", MDB_CREATE, &store.state_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "open", MDB_CREATE, &store.block_store.open_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "receive", MDB_CREATE, &store.block_store.receive_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "send", MDB_CREATE, &store.block_store.send_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "change", MDB_CREATE, &store.block_store.change_blocks_handle));
ASSERT_FALSE (mdb_dbi_open (txn, "state_blocks", MDB_CREATE, &store.block_store.state_blocks_handle));
// Modify blocks back to the old tables
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send);
write_block_w_sideband_v18 (store, store.receive_blocks_handle, transaction, receive);
write_block_w_sideband_v18 (store, store.change_blocks_handle, transaction, change);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_epoch);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send);
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_open);
write_block_w_sideband_v18 (store, store.block_store.open_blocks_handle, transaction, *nano::dev::genesis);
write_block_w_sideband_v18 (store, store.block_store.send_blocks_handle, transaction, send);
write_block_w_sideband_v18 (store, store.block_store.receive_blocks_handle, transaction, receive);
write_block_w_sideband_v18 (store, store.block_store.change_blocks_handle, transaction, change);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_epoch);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_send);
write_block_w_sideband_v18 (store, store.block_store.state_blocks_handle, transaction, state_open);
store.version.put (transaction, 18);
}
@ -1754,11 +1806,11 @@ TEST (mdb_block_store, upgrade_v18_v19)
auto transaction (store.tx_begin_read ());
// These tables should be deleted
ASSERT_EQ (store.send_blocks_handle, 0);
ASSERT_EQ (store.receive_blocks_handle, 0);
ASSERT_EQ (store.change_blocks_handle, 0);
ASSERT_EQ (store.open_blocks_handle, 0);
ASSERT_EQ (store.state_blocks_handle, 0);
ASSERT_EQ (store.block_store.send_blocks_handle, 0);
ASSERT_EQ (store.block_store.receive_blocks_handle, 0);
ASSERT_EQ (store.block_store.change_blocks_handle, 0);
ASSERT_EQ (store.block_store.open_blocks_handle, 0);
ASSERT_EQ (store.block_store.state_blocks_handle, 0);
// Confirm these blocks all exist after the upgrade
ASSERT_TRUE (store.block.get (transaction, send.hash ()));
@ -1780,7 +1832,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
ASSERT_EQ (nano::epoch::epoch_1, state_open_disk->sideband ().details.epoch);
ASSERT_EQ (nano::epoch::epoch_1, state_open_disk->sideband ().source_epoch);
ASSERT_EQ (7, store.count (transaction, store.blocks_handle));
ASSERT_EQ (7, store.count (transaction, store.block_store.blocks_handle));
// Version should be correct
ASSERT_LT (18, store.version.get (transaction));
@ -1802,13 +1854,13 @@ TEST (mdb_block_store, upgrade_v19_v20)
auto transaction (store.tx_begin_write ());
store.initialize (transaction, ledger.cache, nano::dev::constants);
// Delete pruned table
ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.pruned_handle, 1));
ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.pruned_store.pruned_handle, 1));
store.version.put (transaction, 19);
}
// Upgrading should create the table
nano::lmdb::store store (logger, path, nano::dev::constants);
ASSERT_FALSE (store.init_error ());
ASSERT_NE (store.pruned_handle, 0);
ASSERT_NE (store.pruned_store.pruned_handle, 0);
// Version should be correct
auto transaction (store.tx_begin_read ());
@ -1831,18 +1883,20 @@ TEST (mdb_block_store, upgrade_v20_v21)
auto transaction (store.tx_begin_write ());
store.initialize (transaction, ledger.cache, ledger.constants);
// Delete pruned table
ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.final_votes_handle, 1));
ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.final_vote_store.final_votes_handle, 1));
store.version.put (transaction, 20);
}
// Upgrading should create the table
nano::lmdb::store store (logger, path, nano::dev::constants);
ASSERT_FALSE (store.init_error ());
ASSERT_NE (store.final_votes_handle, 0);
ASSERT_NE (store.final_vote_store.final_votes_handle, 0);
// Version should be correct
auto transaction (store.tx_begin_read ());
ASSERT_LT (19, store.version.get (transaction));
}
}
}
TEST (mdb_block_store, upgrade_backup)
{
@ -2067,7 +2121,9 @@ TEST (rocksdb_block_store, tombstone_count)
}
}
namespace
namespace nano
{
namespace lmdb
{
void write_sideband_v14 (nano::lmdb::store & store_a, nano::transaction & transaction_a, nano::block const & block_a, MDB_dbi db_a)
{
@ -2083,7 +2139,7 @@ void write_sideband_v14 (nano::lmdb::store & store_a, nano::transaction & transa
}
MDB_val val{ data.size (), data.data () };
ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), block->sideband ().details.epoch == nano::epoch::epoch_0 ? store_a.state_blocks_v0_handle : store_a.state_blocks_v1_handle, nano::mdb_val (block_a.hash ()), &val, 0));
ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), block->sideband ().details.epoch == nano::epoch::epoch_0 ? store_a.block_store.state_blocks_v0_handle : store_a.block_store.state_blocks_v1_handle, nano::mdb_val (block_a.hash ()), &val, 0));
}
void write_sideband_v15 (nano::lmdb::store & store_a, nano::transaction & transaction_a, nano::block const & block_a)
@ -2102,7 +2158,7 @@ void write_sideband_v15 (nano::lmdb::store & store_a, nano::transaction & transa
}
MDB_val val{ data.size (), data.data () };
ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), store_a.state_blocks_handle, nano::mdb_val (block_a.hash ()), &val, 0));
ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), store_a.block_store.state_blocks_handle, nano::mdb_val (block_a.hash ()), &val, 0));
}
void write_block_w_sideband_v18 (nano::lmdb::store & store_a, MDB_dbi database, nano::write_transaction & transaction_a, nano::block const & block_a)
@ -2129,13 +2185,14 @@ void modify_account_info_to_v14 (nano::lmdb::store & store, nano::transaction co
nano::account_info info;
ASSERT_FALSE (store.account.get (transaction, account, info));
nano::account_info_v14 account_info_v14 (info.head, rep_block, info.open_block, info.balance, info.modified, info.block_count, confirmation_height, info.epoch ());
auto status (mdb_put (store.env.tx (transaction), info.epoch () == nano::epoch::epoch_0 ? store.accounts_v0_handle : store.accounts_v1_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14), 0));
auto status (mdb_put (store.env.tx (transaction), info.epoch () == nano::epoch::epoch_0 ? store.account_store.accounts_v0_handle : store.account_store.accounts_v1_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14), 0));
ASSERT_EQ (status, 0);
}
void modify_confirmation_height_to_v15 (nano::lmdb::store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height)
{
auto status (mdb_put (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (confirmation_height), 0));
auto status (mdb_put (store.env.tx (transaction), store.confirmation_height_store.confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (confirmation_height), 0));
ASSERT_EQ (status, 0);
}
}
}

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 };
};
}
}