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

Use span in db_val instead of database specific types

Browse source
This commit is contained in:
Piotr Wójcik 2025-06-06 01:16:43 +02:00
commit e8f8e581c4
13 changed files with 187 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

36
nano/node/wallet.cpp
View file

@ -279,7 +279,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
if (!init_a)
{
MDB_val junk;
debug_assert (mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &junk) == MDB_NOTFOUND);
nano::store::lmdb::db_val version_key (version_special);
debug_assert (mdb_get (env.tx (transaction_a), handle, version_key.mdb_val_ptr (), &junk) == MDB_NOTFOUND);
boost::property_tree::ptree wallet_l;
std::stringstream istream (json_a);
try
@ -312,11 +313,15 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
init_a = true;
}
}
init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (wallet_key_special), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (salt_special), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (check_special), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (representative_special), &junk) != 0;
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);
init_a |= mdb_get (env.tx (transaction_a), handle, version_key.mdb_val_ptr (), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, wallet_key_key.mdb_val_ptr (), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, salt_key.mdb_val_ptr (), &junk) != 0;
init_a |= mdb_get (env.tx (transaction_a), handle, check_key.mdb_val_ptr (), &junk) != 0;
nano::store::lmdb::db_val rep_key (representative_special);
init_a |= mdb_get (env.tx (transaction_a), handle, rep_key.mdb_val_ptr (), &junk) != 0;
nano::raw_key key;
key.clear ();
password.value_set (key);
@ -337,7 +342,8 @@ nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, store::trans
{
int version_status;
MDB_val version_value;
version_status = mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (version_special), &version_value);
nano::store::lmdb::db_val version_lookup_key (version_special);
version_status = mdb_get (env.tx (transaction_a), handle, version_lookup_key.mdb_val_ptr (), &version_value);
if (version_status == MDB_NOTFOUND)
{
version_put (transaction_a, version_current);
@ -439,7 +445,8 @@ bool nano::wallet_store::insert_watch (store::transaction const & transaction_a,
void nano::wallet_store::erase (store::transaction const & transaction_a, nano::account const & pub)
{
auto status (mdb_del (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub), nullptr));
nano::store::lmdb::db_val pub_key (pub);
auto status (mdb_del (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), nullptr));
(void)status;
debug_assert (status == 0);
}
@ -448,7 +455,8 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
{
nano::wallet_value result;
nano::store::lmdb::db_val value;
auto status (mdb_get (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub_a), value));
nano::store::lmdb::db_val pub_key (pub_a);
auto status (mdb_get (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), value.mdb_val_ptr ()));
if (status == 0)
{
result = nano::wallet_value (value);
@ -463,7 +471,9 @@ nano::wallet_value nano::wallet_store::entry_get_raw (store::transaction const &
void nano::wallet_store::entry_put_raw (store::transaction const & transaction_a, nano::account const & pub_a, nano::wallet_value const & entry_a)
{
auto status (mdb_put (env.tx (transaction_a), handle, nano::store::lmdb::db_val (pub_a), nano::store::lmdb::db_val (sizeof (entry_a), const_cast<nano::wallet_value *> (&entry_a)), 0));
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));
auto status (mdb_put (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), entry_val.mdb_val_ptr (), 0));
(void)status;
debug_assert (status == 0);
}
@ -1003,9 +1013,10 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
if (id_mdb_val)
{
nano::store::lmdb::db_val result;
auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, result));
auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, id_mdb_val->mdb_val_ptr (), result.mdb_val_ptr ()));
if (status == 0)
{
result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (result.cached_mdb_val.mv_data), result.cached_mdb_val.mv_size);
nano::block_hash hash (result);
block = wallets.node.ledger.any.block_get (block_transaction, hash);
if (block != nullptr)
@ -1058,7 +1069,8 @@ std::shared_ptr<nano::block> nano::wallet::send_action (nano::account const & so
details.epoch = info->epoch ();
if (id_mdb_val && block != nullptr)
{
auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, nano::store::lmdb::db_val (block->hash ()), 0));
nano::store::lmdb::db_val hash_val (block->hash ());
auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, id_mdb_val->mdb_val_ptr (), hash_val.mdb_val_ptr (), 0));
if (status != 0)
{
block = nullptr;

3
nano/store/CMakeLists.txt
View file

@ -61,13 +61,11 @@ add_library(
block.cpp
component.cpp
confirmation_height.cpp
db_val.cpp
iterator.cpp
final_vote.cpp
lmdb/account.cpp
lmdb/block.cpp
lmdb/confirmation_height.cpp
lmdb/db_val.cpp
lmdb/final_vote.cpp
lmdb/iterator.cpp
lmdb/lmdb.cpp
@ -88,7 +86,6 @@ add_library(
rocksdb/account.cpp
rocksdb/block.cpp
rocksdb/confirmation_height.cpp
rocksdb/db_val.cpp
rocksdb/final_vote.cpp
rocksdb/iterator.cpp
rocksdb/online_weight.cpp

1
nano/store/db_val.cpp
View file

@ -1 +0,0 @@
#include <nano/store/db_val.hpp>

136
nano/store/db_val.hpp
View file

@ -8,6 +8,10 @@
#include <nano/store/versioning.hpp>
#include <cstddef>
#include <span>
#include <lmdb/libraries/liblmdb/lmdb.h>
#include <rocksdb/slice.h>
namespace nano
{
@ -22,44 +26,45 @@ class vote;
namespace nano::store
{
/**
* Encapsulates database specific container
* Encapsulates database values using std::span for type safety and backend independence
*/
template <typename Val>
class db_val
{
public:
db_val (Val const & value_a) :
value (value_a)
db_val () = default;
db_val (std::span<uint8_t const> span) :
span_view (span)
{
}
db_val () :
db_val (0, nullptr)
db_val (size_t size, void const * data) :
span_view (static_cast<uint8_t const *> (data), size)
{
}
db_val (std::nullptr_t) :
db_val (0, this)
span_view ()
{
}
db_val (nano::uint128_union const & val_a) :
db_val (sizeof (val_a), const_cast<nano::uint128_union *> (&val_a))
span_view (val_a.bytes.data (), sizeof (val_a))
{
}
db_val (nano::uint256_union const & val_a) :
db_val (sizeof (val_a), const_cast<nano::uint256_union *> (&val_a))
span_view (val_a.bytes.data (), sizeof (val_a))
{
}
db_val (nano::uint512_union const & val_a) :
db_val (sizeof (val_a), const_cast<nano::uint512_union *> (&val_a))
span_view (val_a.bytes.data (), sizeof (val_a))
{
}
db_val (nano::qualified_root const & val_a) :
db_val (sizeof (val_a), const_cast<nano::qualified_root *> (&val_a))
span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
{
}
@ -82,13 +87,13 @@ public:
}
db_val (nano::block_info const & val_a) :
db_val (sizeof (val_a), const_cast<nano::block_info *> (&val_a))
span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
{
static_assert (std::is_standard_layout<nano::block_info>::value, "Standard layout is required");
}
db_val (nano::endpoint_key const & val_a) :
db_val (sizeof (val_a), const_cast<nano::endpoint_key *> (&val_a))
span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
{
static_assert (std::is_standard_layout<nano::endpoint_key>::value, "Standard layout is required");
}
@ -114,7 +119,7 @@ public:
nano::block_info result;
debug_assert (size () == sizeof (result));
static_assert (sizeof (nano::block_info::account) + sizeof (nano::block_info::balance) == sizeof (result), "Packed class");
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
@ -124,7 +129,7 @@ public:
explicit operator nano::confirmation_height_info () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
nano::bufferstream stream (span_view.data (), span_view.size ());
nano::confirmation_height_info result;
bool error (result.deserialize (stream));
(void)error;
@ -169,7 +174,7 @@ public:
explicit operator std::array<char, 64> () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
nano::bufferstream stream (span_view.data (), span_view.size ());
std::array<char, 64> result;
auto error = nano::try_read (stream, result);
(void)error;
@ -180,7 +185,8 @@ public:
explicit operator nano::endpoint_key () const
{
nano::endpoint_key result;
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
debug_assert (span_view.size () == sizeof (result));
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
@ -199,53 +205,20 @@ public:
explicit operator std::shared_ptr<nano::block> () const;
template <typename Block>
std::shared_ptr<Block> convert_to_block () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
auto error (false);
auto result (std::make_shared<Block> (error, stream));
debug_assert (!error);
return result;
}
std::shared_ptr<Block> convert_to_block () const;
explicit operator std::shared_ptr<nano::send_block> () const
{
return convert_to_block<nano::send_block> ();
}
explicit operator std::shared_ptr<nano::send_block> () const;
explicit operator std::shared_ptr<nano::receive_block> () const;
explicit operator std::shared_ptr<nano::open_block> () const;
explicit operator std::shared_ptr<nano::change_block> () const;
explicit operator std::shared_ptr<nano::state_block> () const;
explicit operator std::shared_ptr<nano::receive_block> () const
{
return convert_to_block<nano::receive_block> ();
}
explicit operator std::shared_ptr<nano::open_block> () const
{
return convert_to_block<nano::open_block> ();
}
explicit operator std::shared_ptr<nano::change_block> () const
{
return convert_to_block<nano::change_block> ();
}
explicit operator std::shared_ptr<nano::state_block> () const
{
return convert_to_block<nano::state_block> ();
}
explicit operator std::shared_ptr<nano::vote> () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
auto error (false);
auto result (nano::make_shared<nano::vote> (error, stream));
debug_assert (!error);
return result;
}
explicit operator std::shared_ptr<nano::vote> () const;
explicit operator uint64_t () const
{
uint64_t result;
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
nano::bufferstream stream (span_view.data (), span_view.size ());
auto error (nano::try_read (stream, result));
(void)error;
debug_assert (!error);
@ -253,33 +226,54 @@ public:
return result;
}
operator Val * () const
void * data () const
{
// Allow passing a temporary to a non-c++ function which doesn't have constness
return const_cast<Val *> (&value);
return const_cast<void *> (static_cast<void const *> (span_view.data ()));
}
operator Val const & () const
size_t size () const
{
return value;
return span_view.size ();
}
// Must be specialized
void * data () const;
size_t size () const;
db_val (size_t size_a, void * data_a);
void convert_buffer_to_value ();
// Conversion to MDB_val for LMDB compatibility
operator MDB_val () const
{
return MDB_val{ span_view.size (), const_cast<void *> (static_cast<void const *> (span_view.data ())) };
}
Val value;
// Conversion to rocksdb::Slice for RocksDB compatibility
operator ::rocksdb::Slice () const
{
return ::rocksdb::Slice{ reinterpret_cast<char const *> (span_view.data ()), span_view.size () };
}
// Get MDB_val* for LMDB functions that need pointers
MDB_val * mdb_val_ptr () const
{
cached_mdb_val = MDB_val{ span_view.size (), const_cast<void *> (static_cast<void const *> (span_view.data ())) };
return &cached_mdb_val;
}
void convert_buffer_to_value ()
{
if (buffer)
{
span_view = std::span<uint8_t const> (buffer->data (), buffer->size ());
}
}
std::span<uint8_t const> span_view;
std::shared_ptr<std::vector<uint8_t>> buffer;
mutable MDB_val cached_mdb_val; // For LMDB compatibility
private:
template <typename T>
T convert () const
{
T result;
debug_assert (size () == sizeof (result));
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), result.bytes.data ());
debug_assert (span_view.size () == sizeof (result));
std::copy (span_view.begin (), span_view.end (), result.bytes.data ());
return result;
}
};

106
nano/store/db_val_impl.hpp
View file

@ -3,22 +3,20 @@
#include <nano/lib/blocks.hpp>
#include <nano/secure/account_info.hpp>
#include <nano/secure/pending_info.hpp>
#include <nano/secure/vote.hpp>
#include <nano/store/db_val.hpp>
template <typename T>
nano::store::db_val<T>::db_val (nano::account_info const & val_a) :
db_val (val_a.db_size (), const_cast<nano::account_info *> (&val_a))
inline nano::store::db_val::db_val (nano::account_info const & val_a) :
span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
{
}
template <typename T>
nano::store::db_val<T>::db_val (nano::account_info_v22 const & val_a) :
db_val (val_a.db_size (), const_cast<nano::account_info_v22 *> (&val_a))
inline nano::store::db_val::db_val (nano::account_info_v22 const & val_a) :
span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
{
}
template <typename T>
nano::store::db_val<T>::db_val (std::shared_ptr<nano::block> const & val_a) :
inline nano::store::db_val::db_val (std::shared_ptr<nano::block> const & val_a) :
buffer (std::make_shared<std::vector<uint8_t>> ())
{
{
@ -28,50 +26,44 @@ nano::store::db_val<T>::db_val (std::shared_ptr<nano::block> const & val_a) :
convert_buffer_to_value ();
}
template <typename T>
nano::store::db_val<T>::db_val (nano::pending_info const & val_a) :
db_val (val_a.db_size (), const_cast<nano::pending_info *> (&val_a))
inline nano::store::db_val::db_val (nano::pending_info const & val_a) :
span_view (reinterpret_cast<uint8_t const *> (&val_a), val_a.db_size ())
{
static_assert (std::is_standard_layout<nano::pending_info>::value, "Standard layout is required");
}
template <typename T>
nano::store::db_val<T>::db_val (nano::pending_key const & val_a) :
db_val (sizeof (val_a), const_cast<nano::pending_key *> (&val_a))
inline nano::store::db_val::db_val (nano::pending_key const & val_a) :
span_view (reinterpret_cast<uint8_t const *> (&val_a), sizeof (val_a))
{
static_assert (std::is_standard_layout<nano::pending_key>::value, "Standard layout is required");
}
template <typename T>
nano::store::db_val<T>::operator nano::account_info () const
inline nano::store::db_val::operator nano::account_info () const
{
nano::account_info result;
debug_assert (size () == result.db_size ());
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
debug_assert (span_view.size () == result.db_size ());
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
template <typename T>
nano::store::db_val<T>::operator nano::account_info_v22 () const
inline nano::store::db_val::operator nano::account_info_v22 () const
{
nano::account_info_v22 result;
debug_assert (size () == result.db_size ());
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
debug_assert (span_view.size () == result.db_size ());
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
template <typename T>
nano::store::db_val<T>::operator std::shared_ptr<nano::block> () const
inline nano::store::db_val::operator std::shared_ptr<nano::block> () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
nano::bufferstream stream (span_view.data (), span_view.size ());
std::shared_ptr<nano::block> result (nano::deserialize_block (stream));
return result;
}
template <typename T>
nano::store::db_val<T>::operator nano::store::block_w_sideband () const
inline nano::store::db_val::operator nano::store::block_w_sideband () const
{
nano::bufferstream stream (reinterpret_cast<uint8_t const *> (data ()), size ());
nano::bufferstream stream (span_view.data (), span_view.size ());
nano::store::block_w_sideband block_w_sideband;
block_w_sideband.block = (nano::deserialize_block (stream));
auto error = block_w_sideband.sideband.deserialize (stream, block_w_sideband.block->type ());
@ -80,21 +72,63 @@ nano::store::db_val<T>::operator nano::store::block_w_sideband () const
return block_w_sideband;
}
template <typename T>
nano::store::db_val<T>::operator nano::pending_info () const
inline nano::store::db_val::operator nano::pending_info () const
{
nano::pending_info result;
debug_assert (size () == result.db_size ());
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + result.db_size (), reinterpret_cast<uint8_t *> (&result));
debug_assert (span_view.size () == result.db_size ());
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
template <typename T>
nano::store::db_val<T>::operator nano::pending_key () const
inline nano::store::db_val::operator nano::pending_key () const
{
nano::pending_key result;
debug_assert (size () == sizeof (result));
debug_assert (span_view.size () == sizeof (result));
static_assert (sizeof (nano::pending_key::account) + sizeof (nano::pending_key::hash) == sizeof (result), "Packed class");
std::copy (reinterpret_cast<uint8_t const *> (data ()), reinterpret_cast<uint8_t const *> (data ()) + sizeof (result), reinterpret_cast<uint8_t *> (&result));
std::copy (span_view.begin (), span_view.end (), reinterpret_cast<uint8_t *> (&result));
return result;
}
inline nano::store::db_val::operator std::shared_ptr<nano::vote> () const
{
nano::bufferstream stream (span_view.data (), span_view.size ());
auto error (false);
auto result (nano::make_shared<nano::vote> (error, stream));
debug_assert (!error);
return result;
}
inline nano::store::db_val::operator std::shared_ptr<nano::send_block> () const
{
return convert_to_block<nano::send_block> ();
}
inline nano::store::db_val::operator std::shared_ptr<nano::receive_block> () const
{
return convert_to_block<nano::receive_block> ();
}
inline nano::store::db_val::operator std::shared_ptr<nano::open_block> () const
{
return convert_to_block<nano::open_block> ();
}
inline nano::store::db_val::operator std::shared_ptr<nano::change_block> () const
{
return convert_to_block<nano::change_block> ();
}
inline nano::store::db_val::operator std::shared_ptr<nano::state_block> () const
{
return convert_to_block<nano::state_block> ();
}
template <typename Block>
inline std::shared_ptr<Block> nano::store::db_val::convert_to_block () const
{
nano::bufferstream stream (span_view.data (), span_view.size ());
auto error (false);
auto result (nano::make_shared<Block> (error, stream));
debug_assert (!error);
return result;
}

25
nano/store/lmdb/db_val.cpp
View file

@ -1,25 +0,0 @@
#include <nano/store/lmdb/db_val.hpp>
template <>
void * nano::store::lmdb::db_val::data () const
{
return value.mv_data;
}
template <>
std::size_t nano::store::lmdb::db_val::size () const
{
return value.mv_size;
}
template <>
nano::store::lmdb::db_val::db_val (std::size_t size_a, void * data_a) :
value ({ size_a, data_a })
{
}
template <>
void nano::store::lmdb::db_val::convert_buffer_to_value ()
{
value = { buffer->size (), const_cast<uint8_t *> (buffer->data ()) };
}

4
nano/store/lmdb/db_val.hpp
View file

@ -2,9 +2,7 @@
#include <nano/store/db_val.hpp>
#include <lmdb/libraries/liblmdb/lmdb.h>
namespace nano::store::lmdb
{
using db_val = store::db_val<MDB_val>;
using db_val = store::db_val;
}

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

@ -405,17 +405,23 @@ 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
{
return mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a);
auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr ());
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 *> (value_a.cached_mdb_val.mv_data), value_a.cached_mdb_val.mv_size);
}
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
{
return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a, 0));
return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr (), 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
{
return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), key_a, nullptr));
return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), nullptr));
}
int nano::store::lmdb::component::drop (store::write_transaction const & transaction_a, tables table_a)
@ -502,7 +508,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
// Copy all values to temporary table
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)
{
auto s = mdb_put (env.tx (transaction_a), temp, nano::store::lmdb::db_val (i->first), i->second, MDB_APPEND);
nano::store::lmdb::db_val key_val (i->first);
auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, table) == count (transaction_a, temp));
@ -511,7 +518,8 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
// Put values from copy
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)
{
auto s = mdb_put (env.tx (transaction_a), table, nano::store::lmdb::db_val (i->first), i->second, MDB_APPEND);
nano::store::lmdb::db_val key_val (i->first);
auto s = mdb_put (env.tx (transaction_a), table, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, table) == count (transaction_a, temp));
@ -525,7 +533,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
// Copy all values to temporary table
for (typed_iterator<nano::pending_key, nano::pending_info> i{ store::iterator{ iterator::begin (env.tx (transaction_a), pending_store.pending_handle) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), pending_store.pending_handle) } }; i != n; ++i)
{
auto s = mdb_put (env.tx (transaction_a), temp, nano::store::lmdb::db_val (i->first), nano::store::lmdb::db_val (i->second), MDB_APPEND);
nano::store::lmdb::db_val key_val (i->first);
nano::store::lmdb::db_val value_val (i->second);
auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
@ -533,7 +543,9 @@ void nano::store::lmdb::component::rebuild_db (store::write_transaction const &
// Put values from copy
for (typed_iterator<nano::pending_key, nano::pending_info> i{ store::iterator{ iterator::begin (env.tx (transaction_a), temp) } }, n{ store::iterator{ iterator::end (env.tx (transaction_a), temp) } }; i != n; ++i)
{
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, nano::store::lmdb::db_val (i->first), nano::store::lmdb::db_val (i->second), MDB_APPEND);
nano::store::lmdb::db_val key_val (i->first);
nano::store::lmdb::db_val value_val (i->second);
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));

6
nano/store/lmdb/wallet_value.cpp
View file

@ -1,6 +1,6 @@
#include <nano/store/lmdb/wallet_value.hpp>
nano::wallet_value::wallet_value (nano::store::db_val<MDB_val> const & val_a)
nano::wallet_value::wallet_value (nano::store::db_val const & val_a)
{
debug_assert (val_a.size () == sizeof (*this));
std::copy (reinterpret_cast<uint8_t const *> (val_a.data ()), reinterpret_cast<uint8_t const *> (val_a.data ()) + sizeof (key), key.chars.begin ());
@ -13,8 +13,8 @@ nano::wallet_value::wallet_value (nano::raw_key const & key_a, uint64_t work_a)
{
}
nano::store::db_val<MDB_val> nano::wallet_value::val () const
nano::store::db_val nano::wallet_value::val () const
{
static_assert (sizeof (*this) == sizeof (key) + sizeof (work), "Class not packed");
return nano::store::db_val<MDB_val> (sizeof (*this), const_cast<nano::wallet_value *> (this));
return nano::store::db_val (sizeof (*this), const_cast<nano::wallet_value *> (this));
}

4
nano/store/lmdb/wallet_value.hpp
View file

@ -11,9 +11,9 @@ class wallet_value
{
public:
wallet_value () = default;
wallet_value (store::db_val<MDB_val> const &);
wallet_value (store::db_val const &);
wallet_value (nano::raw_key const &, uint64_t);
store::db_val<MDB_val> val () const;
store::db_val val () const;
nano::raw_key key;
uint64_t work;
};

25
nano/store/rocksdb/db_val.cpp
View file

@ -1,25 +0,0 @@
#include <nano/store/rocksdb/db_val.hpp>
template <>
void * nano::store::rocksdb::db_val::data () const
{
return (void *)value.data ();
}
template <>
std::size_t nano::store::rocksdb::db_val::size () const
{
return value.size ();
}
template <>
nano::store::rocksdb::db_val::db_val (std::size_t size_a, void * data_a) :
value (static_cast<char const *> (data_a), size_a)
{
}
template <>
void nano::store::rocksdb::db_val::convert_buffer_to_value ()
{
value = ::rocksdb::Slice (reinterpret_cast<char const *> (buffer->data ()), buffer->size ());
}

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

@ -2,9 +2,7 @@
#include <nano/store/db_val.hpp>
#include <rocksdb/slice.h>
namespace nano::store::rocksdb
{
using db_val = store::db_val<::rocksdb::Slice>;
using db_val = store::db_val;
}

6
nano/store/typed_iterator_templ.hpp
View file

@ -1,6 +1,5 @@
#include <nano/lib/utility.hpp>
#include <nano/store/db_val_impl.hpp>
#include <nano/store/lmdb/db_val.hpp>
#include <nano/store/typed_iterator.hpp>
namespace nano::store
@ -10,10 +9,9 @@ void typed_iterator<Key, Value>::update ()
{
if (!iter.is_end ())
{
// FIXME Don't convert via lmdb::db_val, this is just a placeholder
auto const & data = *iter;
lmdb::db_val key_val{ MDB_val{ data.first.size (), const_cast<void *> (reinterpret_cast<void const *> (data.first.data ())) } };
lmdb::db_val value_val{ MDB_val{ data.second.size (), const_cast<void *> (reinterpret_cast<void const *> (data.second.data ())) } };
db_val key_val{ data.first };
db_val value_val{ data.second };
current = std::make_pair (static_cast<Key> (key_val), static_cast<Value> (value_val));
}
else