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

Simplify db val conversions

Browse source
This commit is contained in:
Piotr Wójcik 2025-06-06 17:21:49 +02:00
commit b7cde2b1d9
21 changed files with 121 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

45
nano/node/wallet.cpp
View file

@ -12,6 +12,7 @@
#include <nano/secure/ledger_set_any.hpp>
#include <nano/secure/ledger_set_confirmed.hpp>
#include <nano/store/lmdb/iterator.hpp>
#include <nano/store/lmdb/utility.hpp>
#include <nano/store/typed_iterator_templ.hpp>
#include <boost/format.hpp>
@ -280,7 +281,7 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
{
MDB_val junk;
nano::store::lmdb::db_val version_key (version_special);
MDB_val mdb_version_key{ version_key.size (), version_key.data () };
auto mdb_version_key = nano::store::lmdb::to_mdb_val (version_key);
debug_assert (mdb_get (env.tx (transaction_a), handle, &mdb_version_key, &junk) == MDB_NOTFOUND);
boost::property_tree::ptree wallet_l;
std::stringstream istream (json_a);
@ -317,16 +318,16 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
nano::store::lmdb::db_val wallet_key_key (wallet_key_special);
nano::store::lmdb::db_val salt_key (salt_special);
nano::store::lmdb::db_val check_key (check_special);
MDB_val mdb_version_key2{ version_key.size (), version_key.data () };
MDB_val mdb_wallet_key_key{ wallet_key_key.size (), wallet_key_key.data () };
MDB_val mdb_salt_key{ salt_key.size (), salt_key.data () };
MDB_val mdb_check_key{ check_key.size (), check_key.data () };
auto mdb_version_key2 = nano::store::lmdb::to_mdb_val (version_key);
auto mdb_wallet_key_key = nano::store::lmdb::to_mdb_val (wallet_key_key);
auto mdb_salt_key = nano::store::lmdb::to_mdb_val (salt_key);
auto mdb_check_key = nano::store::lmdb::to_mdb_val (check_key);
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_version_key2, &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_wallet_key_key, &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_salt_key, &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_check_key, &junk) != 0;
nano::store::lmdb::db_val rep_key (representative_special);
MDB_val mdb_rep_key{ rep_key.size (), rep_key.data () };
auto mdb_rep_key = nano::store::lmdb::to_mdb_val (rep_key);
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_rep_key, &junk) != 0;
nano::raw_key key;
key.clear ();
@ -349,7 +350,7 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
int version_status;
MDB_val version_value;
nano::store::lmdb::db_val version_lookup_key (version_special);
MDB_val mdb_version_lookup_key{ version_lookup_key.size (), version_lookup_key.data () };
auto mdb_version_lookup_key = nano::store::lmdb::to_mdb_val (version_lookup_key);
version_status = mdb_get (env.tx (transaction_a), handle, &mdb_version_lookup_key, &version_value);
if (version_status == MDB_NOTFOUND)
{
@ -464,12 +465,12 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
nano::wallet_value result;
nano::store::lmdb::db_val value;
nano::store::lmdb::db_val pub_key (pub_a);
MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
auto mdb_pub_key = nano::store::lmdb::to_mdb_val (pub_key);
MDB_val mdb_value{};
auto status (mdb_get (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_value));
if (status == 0)
{
value.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.mv_size);
value = nano::store::lmdb::from_mdb_val (mdb_value);
result = nano::wallet_value (value);
}
else
@ -484,8 +485,8 @@ void nano::wallet_store::entry_put_raw (store::transaction const & transaction_a
{
nano::store::lmdb::db_val pub_key (pub_a);
nano::store::lmdb::db_val entry_val (sizeof (entry_a), const_cast<nano::wallet_value *> (&entry_a));
MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
MDB_val mdb_entry_val{ entry_val.size (), entry_val.data () };
auto mdb_pub_key = nano::store::lmdb::to_mdb_val (pub_key);
auto mdb_entry_val = nano::store::lmdb::to_mdb_val (entry_val);
auto status (mdb_put (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_entry_val, 0));
(void)status;
debug_assert (status == 0);
@ -1031,7 +1032,7 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_result));
if (status == 0)
{
result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_result.mv_data), mdb_result.mv_size);
result = nano::store::lmdb::from_mdb_val (mdb_result);
nano::block_hash hash (result);
block = wallets.node.ledger.any.block_get (block_transaction, hash);
if (block != nullptr)
@ -1085,8 +1086,8 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
if (id_mdb_val && block != nullptr)
{
nano::store::lmdb::db_val hash_val (block->hash ());
MDB_val mdb_id_key{ id_mdb_val->size (), id_mdb_val->data () };
MDB_val mdb_hash_val{ hash_val.size (), hash_val.data () };
auto mdb_id_key = nano::store::lmdb::to_mdb_val (*id_mdb_val);
auto mdb_hash_val = nano::store::lmdb::to_mdb_val (hash_val);
auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_hash_val, 0));
if (status != 0)
{
@ -1473,8 +1474,8 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) :
nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
MDB_val mdb_end_val{ end_val.size (), end_val.data () };
auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
auto mdb_end_val = nano::store::lmdb::to_mdb_val (end_val);
store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
for (; i != n; ++i)
@ -1635,8 +1636,8 @@ void nano::wallets::reload ()
nano::store::lmdb::db_val beginning_val{ beginning.size (), const_cast<char *> (beginning.c_str ()) };
std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ());
nano::store::lmdb::db_val end_val{ end.size (), const_cast<char *> (end.c_str ()) };
MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
MDB_val mdb_end_val{ end_val.size (), end_val.data () };
auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
auto mdb_end_val = nano::store::lmdb::to_mdb_val (end_val);
store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_beginning_val) };
store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, mdb_end_val) };
for (; i != n; ++i)
@ -1882,17 +1883,13 @@ nano::uint128_t const nano::wallets::high_priority = std::numeric_limits<nano::u
auto nano::wallet_store::begin (store::transaction const & transaction_a) -> iterator
{
nano::account account{ special_count };
nano::store::lmdb::db_val val{ account };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, store::lmdb::to_mdb_val (account)) } };
}
auto nano::wallet_store::begin (store::transaction const & transaction_a, nano::account const & key) -> iterator
{
nano::account account (key);
nano::store::lmdb::db_val val{ account };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, store::lmdb::to_mdb_val (account)) } };
}
auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator

6
nano/store/db_val.hpp
View file

@ -42,6 +42,12 @@ public:
{
}
db_val (std::shared_ptr<std::vector<uint8_t>> buffer_a) :
buffer (buffer_a)
{
convert_buffer_to_value ();
}
db_val (nano::uint128_union const & val_a) :
span_view (val_a.bytes.data (), sizeof (val_a))
{

5
nano/store/lmdb/account.cpp
View file

@ -2,6 +2,7 @@
#include <nano/store/lmdb/account.hpp>
#include <nano/store/lmdb/db_val.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/utility.hpp>
nano::store::lmdb::account::account (nano::store::lmdb::component & store_a) :
store (store_a){};
@ -45,9 +46,7 @@ size_t nano::store::lmdb::account::count (store::transaction const & transaction
auto nano::store::lmdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{
lmdb::db_val val{ account };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, to_mdb_val (account)) } };
}
auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator

5
nano/store/lmdb/block.cpp
View file

@ -2,6 +2,7 @@
#include <nano/store/db_val_impl.hpp>
#include <nano/store/lmdb/block.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/utility.hpp>
namespace nano::store::lmdb
{
@ -129,9 +130,7 @@ auto nano::store::lmdb::block::begin (store::transaction const & transaction) co
auto nano::store::lmdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{
lmdb::db_val val{ hash };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, to_mdb_val (hash)) } };
}
auto nano::store::lmdb::block::end (store::transaction const & transaction_a) const -> iterator

5
nano/store/lmdb/confirmation_height.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/confirmation_height.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/utility.hpp>
nano::store::lmdb::confirmation_height::confirmation_height (nano::store::lmdb::component & store) :
store{ store }
@ -61,9 +62,7 @@ void nano::store::lmdb::confirmation_height::clear (store::write_transaction con
auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{
lmdb::db_val val{ account };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, to_mdb_val (account)) } };
}
auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator

5
nano/store/lmdb/final_vote.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/final_vote.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/utility.hpp>
nano::store::lmdb::final_vote::final_vote (nano::store::lmdb::component & store) :
store{ store } {};
@ -53,9 +54,7 @@ void nano::store::lmdb::final_vote::clear (store::write_transaction const & tran
auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
{
lmdb::db_val val{ root };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, to_mdb_val (root)) } };
}
auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator

30
nano/store/lmdb/lmdb.cpp
View file

@ -5,6 +5,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/iterator.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/utility.hpp>
#include <nano/store/lmdb/wallet_value.hpp>
#include <nano/store/typed_iterator_templ.hpp>
#include <nano/store/version.hpp>
@ -405,28 +406,27 @@ bool nano::store::lmdb::component::exists (store::transaction const & transactio
int nano::store::lmdb::component::get (store::transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a, nano::store::lmdb::db_val & value_a) const
{
MDB_val mdb_key{ key_a.size (), key_a.data () };
auto mdb_key = to_mdb_val (key_a);
MDB_val mdb_value{};
auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value);
if (result == MDB_SUCCESS)
{
// Update value_a span_view to point to the retrieved data
value_a.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.mv_size);
value_a = from_mdb_val (mdb_value);
}
return result;
}
int nano::store::lmdb::component::put (store::write_transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a, nano::store::lmdb::db_val const & value_a) const
{
MDB_val mdb_key{ key_a.size (), key_a.data () };
MDB_val mdb_value{ value_a.size (), value_a.data () };
auto mdb_key = to_mdb_val (key_a);
auto mdb_value = to_mdb_val (value_a);
return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, &mdb_value, 0));
}
int nano::store::lmdb::component::del (store::write_transaction const & transaction_a, tables table_a, nano::store::lmdb::db_val const & key_a) const
{
MDB_val mdb_key{ key_a.size (), key_a.data () };
auto mdb_key = to_mdb_val (key_a);
return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, nullptr));
}
@ -515,8 +515,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
for (typed_iterator<nano::uint256_union, nano::store::lmdb::db_val> i{ store::iterator{ iterator::begin (env.tx (transaction_a), table) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), table) } }; i != n; ++i)
{
nano::store::lmdb::db_val key_val (i->first);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ i->second.size (), i->second.data () };
auto mdb_key = to_mdb_val (key_val);
auto mdb_value = to_mdb_val (i->second);
auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
@ -527,8 +527,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
for (typed_iterator<nano::uint256_union, nano::store::lmdb::db_val> i{ store::iterator{ iterator::begin (env.tx (transaction_a), temp) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), temp) } }; i != n; ++i)
{
nano::store::lmdb::db_val key_val (i->first);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ i->second.size (), i->second.data () };
auto mdb_key = to_mdb_val (key_val);
auto mdb_value = to_mdb_val (i->second);
auto s = mdb_put (env.tx (transaction_a), table, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
@ -545,8 +545,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
{
nano::store::lmdb::db_val key_val (i->first);
nano::store::lmdb::db_val value_val (i->second);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ value_val.size (), value_val.data () };
auto mdb_key = to_mdb_val (key_val);
auto mdb_value = to_mdb_val (value_val);
auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
@ -557,8 +557,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
{
nano::store::lmdb::db_val key_val (i->first);
nano::store::lmdb::db_val value_val (i->second);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ value_val.size (), value_val.data () };
auto mdb_key = to_mdb_val (key_val);
auto mdb_value = to_mdb_val (value_val);
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}

5
nano/store/lmdb/pending.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/pending.hpp>
#include <nano/store/lmdb/utility.hpp>
nano::store::lmdb::pending::pending (nano::store::lmdb::component & store) :
store{ store } {};
@ -47,9 +48,7 @@ bool nano::store::lmdb::pending::any (store::transaction const & transaction_a,
auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
{
lmdb::db_val val{ key_a };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, to_mdb_val (key_a)) } };
}
auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator

5
nano/store/lmdb/pruned.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/pruned.hpp>
#include <nano/store/lmdb/utility.hpp>
nano::store::lmdb::pruned::pruned (nano::store::lmdb::component & store_a) :
store{ store_a } {};
@ -47,9 +48,7 @@ void nano::store::lmdb::pruned::clear (store::write_transaction const & transact
auto nano::store::lmdb::pruned::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{
lmdb::db_val val{ hash };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, to_mdb_val (hash)) } };
}
auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator

5
nano/store/lmdb/rep_weight.cpp
View file

@ -2,6 +2,7 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/lmdb.hpp>
#include <nano/store/lmdb/rep_weight.hpp>
#include <nano/store/lmdb/utility.hpp>
#include <iostream>
#include <stdexcept>
@ -45,9 +46,7 @@ void nano::store::lmdb::rep_weight::del (store::write_transaction const & txn_a,
auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a, nano::account const & representative_a) const -> iterator
{
lmdb::db_val val{ representative_a };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, mdb_val) } };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, to_mdb_val (representative_a)) } };
}
auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator

25
nano/store/lmdb/utility.hpp Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#include <nano/store/db_val.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano::store::lmdb
{
/**
* Converts a db_val to MDB_val for LMDB operations
*/
inline MDB_val to_mdb_val (nano::store::db_val const & val)
{
return MDB_val{ val.size (), val.data () };
}
/**
* Creates a db_val from MDB_val for read operations
*/
inline nano::store::db_val from_mdb_val (MDB_val const & val)
{
auto span = std::span<uint8_t const>{ static_cast<uint8_t const *> (val.mv_data), val.mv_size };
return nano::store::db_val (span);
}
}

4
nano/store/rocksdb/account.cpp
View file

@ -45,9 +45,7 @@ size_t nano::store::rocksdb::account::count (store::transaction const & transact
auto nano::store::rocksdb::account::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{
rocksdb::db_val val{ account };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), to_slice (account)) } };
}
auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator

4
nano/store/rocksdb/block.cpp
View file

@ -130,9 +130,7 @@ auto nano::store::rocksdb::block::begin (store::transaction const & transaction)
auto nano::store::rocksdb::block::begin (store::transaction const & transaction, nano::block_hash const & hash) const -> iterator
{
rocksdb::db_val val{ hash };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), to_slice (hash)) } };
}
auto nano::store::rocksdb::block::end (store::transaction const & transaction_a) const -> iterator

4
nano/store/rocksdb/confirmation_height.cpp
View file

@ -62,9 +62,7 @@ void nano::store::rocksdb::confirmation_height::clear (store::write_transaction
auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction, nano::account const & account) const -> iterator
{
rocksdb::db_val val{ account };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), to_slice (account)) } };
}
auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator

4
nano/store/rocksdb/final_vote.cpp
View file

@ -54,9 +54,7 @@ void nano::store::rocksdb::final_vote::clear (store::write_transaction const & t
auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction, nano::qualified_root const & root) const -> iterator
{
rocksdb::db_val val{ root };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), to_slice (root)) } };
}
auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator

6
nano/store/rocksdb/pending.cpp
View file

@ -1,5 +1,5 @@
#include <nano/secure/parallel_traversal.hpp>
#include <nano/store/lmdb/pending.hpp>
#include <nano/store/rocksdb/pending.hpp>
#include <nano/store/rocksdb/rocksdb.hpp>
#include <nano/store/rocksdb/utility.hpp>
@ -48,9 +48,7 @@ bool nano::store::rocksdb::pending::any (store::transaction const & transaction_
auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a, nano::pending_key const & key_a) const -> iterator
{
rocksdb::db_val val{ key_a };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), to_slice (key_a)) } };
}
auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator

4
nano/store/rocksdb/pending.hpp
View file

@ -2,6 +2,10 @@
#include <nano/store/pending.hpp>
namespace nano::store::rocksdb
{
class component;
}
namespace nano::store::rocksdb
{
class pending : public nano::store::pending

4
nano/store/rocksdb/pruned.cpp
View file

@ -48,9 +48,7 @@ void nano::store::rocksdb::pruned::clear (store::write_transaction const & trans
auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a, nano::block_hash const & hash_a) const -> iterator
{
rocksdb::db_val val{ hash_a };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), to_slice (hash_a)) } };
}
auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator

4
nano/store/rocksdb/rep_weight.cpp
View file

@ -45,9 +45,7 @@ void nano::store::rocksdb::rep_weight::del (store::write_transaction const & txn
auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a, nano::account const & representative_a) const -> iterator
{
rocksdb::db_val val{ representative_a };
::rocksdb::Slice slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), slice) } };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), to_slice (representative_a)) } };
}
auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator

14
nano/store/rocksdb/rocksdb.cpp
View file

@ -533,7 +533,7 @@ rocksdb::ColumnFamilyHandle * nano::store::rocksdb::component::table_to_column_f
bool nano::store::rocksdb::component::exists (store::transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a) const
{
::rocksdb::PinnableSlice slice;
::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
auto key_slice = to_slice (key_a);
auto internals = rocksdb::tx (transaction_a);
auto status = std::visit ([&] (auto && ptr) {
using V = std::remove_cvref_t<decltype (ptr)>;
@ -563,7 +563,7 @@ int nano::store::rocksdb::component::del (store::write_transaction const & trans
// RocksDB does not report not_found status, it is a pre-condition that the key exists
debug_assert (exists (transaction_a, table_a, key_a));
flush_tombstones_check (table_a);
::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
auto key_slice = to_slice (key_a);
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_slice).code ();
}
@ -591,7 +591,7 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
{
::rocksdb::ReadOptions options;
::rocksdb::PinnableSlice slice;
::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
auto key_slice = to_slice (key_a);
auto handle = table_to_column_family (table_a);
auto internals = rocksdb::tx (transaction_a);
auto status = std::visit ([&] (auto && ptr) {
@ -613,9 +613,7 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
if (status.ok ())
{
value_a.buffer = std::make_shared<std::vector<uint8_t>> (slice.size ());
std::memcpy (value_a.buffer->data (), slice.data (), slice.size ());
value_a.convert_buffer_to_value ();
value_a = from_slice (slice);
}
return status.code ();
}
@ -623,8 +621,8 @@ int nano::store::rocksdb::component::get (store::transaction const & transaction
int nano::store::rocksdb::component::put (store::write_transaction const & transaction_a, tables table_a, nano::store::rocksdb::db_val const & key_a, nano::store::rocksdb::db_val const & value_a)
{
debug_assert (transaction_a.contains (table_a));
::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
::rocksdb::Slice value_slice{ reinterpret_cast<char const *> (value_a.data ()), value_a.size () };
auto key_slice = to_slice (key_a);
auto value_slice = to_slice (value_a);
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_slice, value_slice).code ();
}

22
nano/store/rocksdb/utility.hpp
View file

@ -1,7 +1,10 @@
#pragma once
#include <nano/store/rocksdb/db_val.hpp>
#include <variant>
#include <rocksdb/slice.h>
#include <rocksdb/utilities/transaction_db.h>
namespace nano::store
@ -12,4 +15,23 @@ class transaction;
namespace nano::store::rocksdb
{
auto tx (store::transaction const & transaction_a) -> std::variant<::rocksdb::Transaction *, ::rocksdb::ReadOptions *>;
/**
* Converts a db_val to rocksdb::Slice for RocksDB operations
*/
inline ::rocksdb::Slice to_slice (nano::store::db_val const & val)
{
return ::rocksdb::Slice{ reinterpret_cast<char const *> (val.data ()), val.size () };
}
/**
* Creates a db_val from rocksdb::Slice for read operations
*/
inline nano::store::db_val from_slice (::rocksdb::Slice const & slice)
{
auto buffer = std::make_shared<std::vector<uint8_t>> (
reinterpret_cast<uint8_t const *> (slice.data ()),
reinterpret_cast<uint8_t const *> (slice.data ()) + slice.size ());
return nano::store::db_val (buffer);
}
}