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

Remove database specific code from db_val

Browse source
This commit is contained in:
Piotr Wójcik 2025-06-06 16:32:31 +02:00
commit 9d6152d08c
22 changed files with 108 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

61
nano/node/wallet.cpp
View file

@ -280,7 +280,8 @@ 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);
debug_assert (mdb_get (env.tx (transaction_a), handle, version_key.mdb_val_ptr (), &junk) == MDB_NOTFOUND);
MDB_val mdb_version_key{ version_key.size (), version_key.data () };
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);
try
@ -316,12 +317,17 @@ 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);
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;
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 () };
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);
init_a |= mdb_get (env.tx (transaction_a), handle, rep_key.mdb_val_ptr (), &junk) != 0;
MDB_val mdb_rep_key{ rep_key.size (), rep_key.data () };
init_a |= mdb_get (env.tx (transaction_a), handle, &mdb_rep_key, &junk) != 0;
nano::raw_key key;
key.clear ();
password.value_set (key);
@ -343,7 +349,8 @@ 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);
version_status = mdb_get (env.tx (transaction_a), handle, version_lookup_key.mdb_val_ptr (), &version_value);
MDB_val mdb_version_lookup_key{ version_lookup_key.size (), version_lookup_key.data () };
version_status = mdb_get (env.tx (transaction_a), handle, &mdb_version_lookup_key, &version_value);
if (version_status == MDB_NOTFOUND)
{
version_put (transaction_a, version_current);
@ -446,7 +453,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)
{
nano::store::lmdb::db_val pub_key (pub);
auto status (mdb_del (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), nullptr));
MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
auto status (mdb_del (env.tx (transaction_a), handle, &mdb_pub_key, nullptr));
(void)status;
debug_assert (status == 0);
}
@ -456,9 +464,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);
auto status (mdb_get (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), value.mdb_val_ptr ()));
MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
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);
result = nano::wallet_value (value);
}
else
@ -473,7 +484,9 @@ 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));
auto status (mdb_put (env.tx (transaction_a), handle, pub_key.mdb_val_ptr (), entry_val.mdb_val_ptr (), 0));
MDB_val mdb_pub_key{ pub_key.size (), pub_key.data () };
MDB_val mdb_entry_val{ entry_val.size (), entry_val.data () };
auto status (mdb_put (env.tx (transaction_a), handle, &mdb_pub_key, &mdb_entry_val, 0));
(void)status;
debug_assert (status == 0);
}
@ -1013,10 +1026,12 @@ 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->mdb_val_ptr (), result.mdb_val_ptr ()));
MDB_val mdb_id_key{ id_mdb_val->size (), id_mdb_val->data () };
MDB_val mdb_result{};
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 *> (result.cached_mdb_val.mv_data), result.cached_mdb_val.mv_size);
result.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_result.mv_data), mdb_result.mv_size);
nano::block_hash hash (result);
block = wallets.node.ledger.any.block_get (block_transaction, hash);
if (block != nullptr)
@ -1070,7 +1085,9 @@ 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 ());
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));
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 status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, &mdb_id_key, &mdb_hash_val, 0));
if (status != 0)
{
block = nullptr;
@ -1456,8 +1473,10 @@ 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 ()) };
store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, beginning_val) };
store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, end_val) };
MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
MDB_val mdb_end_val{ end_val.size (), end_val.data () };
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)
{
nano::wallet_id id;
@ -1616,8 +1635,10 @@ 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 ()) };
store::iterator i{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, beginning_val) };
store::iterator n{ store::lmdb::iterator::lower_bound (env.tx (transaction), handle, end_val) };
MDB_val mdb_beginning_val{ beginning_val.size (), beginning_val.data () };
MDB_val mdb_end_val{ end_val.size (), end_val.data () };
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)
{
nano::wallet_id id;
@ -1862,14 +1883,16 @@ auto nano::wallet_store::begin (store::transaction const & transaction_a) -> ite
{
nano::account account{ special_count };
nano::store::lmdb::db_val val{ account };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, val) } };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
}
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 };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, val) } };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, mdb_val) } };
}
auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator

1
nano/secure/common.hpp
View file

@ -11,6 +11,7 @@
#include <nano/lib/object_stream.hpp>
#include <nano/lib/timer.hpp>
#include <nano/lib/utility.hpp>
#include <nano/store/block_w_sideband.hpp>
#include <array>
#include <unordered_map>

1
nano/secure/ledger_set_any.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/ledger.hpp>
#include <nano/secure/ledger_set_any.hpp>
#include <nano/store/account.hpp>
#include <nano/store/block.hpp>
#include <nano/store/component.hpp>
#include <nano/store/pending.hpp>
#include <nano/store/pruned.hpp>

1
nano/secure/ledger_set_confirmed.cpp
View file

@ -1,6 +1,7 @@
#include <nano/secure/ledger.hpp>
#include <nano/secure/ledger_set_confirmed.hpp>
#include <nano/store/account.hpp>
#include <nano/store/block.hpp>
#include <nano/store/component.hpp>
#include <nano/store/confirmation_height.hpp>
#include <nano/store/pending.hpp>

28
nano/store/db_val.hpp
View file

@ -3,16 +3,10 @@
#include <nano/lib/numbers.hpp>
#include <nano/lib/stream.hpp>
#include <nano/secure/common.hpp>
#include <nano/store/block.hpp>
#include <nano/store/component.hpp>
#include <nano/store/versioning.hpp>
#include <cstddef>
#include <span>
#include <lmdb/libraries/liblmdb/lmdb.h>
#include <rocksdb/slice.h>
namespace nano
{
class account_info;
@ -236,25 +230,6 @@ public:
return span_view.size ();
}
// 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 ())) };
}
// 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)
@ -265,7 +240,6 @@ public:
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>
@ -277,4 +251,4 @@ private:
return result;
}
};
} // namespace nano::store
}

1
nano/store/db_val_impl.hpp
View file

@ -1,6 +1,7 @@
#pragma once
#include <nano/lib/blocks.hpp>
#include <nano/lib/memory.hpp>
#include <nano/secure/account_info.hpp>
#include <nano/secure/pending_info.hpp>
#include <nano/secure/vote.hpp>

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

@ -46,7 +46,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, val) } };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), accounts_handle, mdb_val) } };
}
auto nano::store::lmdb::account::begin (store::transaction const & transaction) const -> iterator

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

@ -130,7 +130,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, val) } };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), blocks_handle, mdb_val) } };
}
auto nano::store::lmdb::block::end (store::transaction const & transaction_a) const -> iterator

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

@ -62,7 +62,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), confirmation_height_handle, val) } };
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) } };
}
auto nano::store::lmdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator

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

@ -54,7 +54,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), final_votes_handle, val) } };
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) } };
}
auto nano::store::lmdb::final_vote::begin (store::transaction const & transaction) const -> iterator

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

@ -405,23 +405,29 @@ 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
{
auto result = mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), value_a.mdb_val_ptr ());
MDB_val mdb_key{ key_a.size (), key_a.data () };
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 *> (value_a.cached_mdb_val.mv_data), value_a.cached_mdb_val.mv_size);
value_a.span_view = std::span<uint8_t const> (static_cast<uint8_t const *> (mdb_value.mv_data), mdb_value.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.mdb_val_ptr (), value_a.mdb_val_ptr (), 0));
MDB_val mdb_key{ key_a.size (), key_a.data () };
MDB_val mdb_value{ value_a.size (), value_a.data () };
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
{
return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), key_a.mdb_val_ptr (), nullptr));
MDB_val mdb_key{ key_a.size (), key_a.data () };
return (mdb_del (env.tx (transaction_a), table_to_dbi (table_a), &mdb_key, nullptr));
}
int nano::store::lmdb::component::drop (store::write_transaction const & transaction_a, tables table_a)
@ -509,7 +515,9 @@ 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);
auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ i->second.size (), i->second.data () };
auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, table) == count (transaction_a, temp));
@ -519,7 +527,9 @@ 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);
auto s = mdb_put (env.tx (transaction_a), table, key_val.mdb_val_ptr (), i->second.mdb_val_ptr (), MDB_APPEND);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ i->second.size (), i->second.data () };
auto s = mdb_put (env.tx (transaction_a), table, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, table) == count (transaction_a, temp));
@ -535,7 +545,9 @@ 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);
auto s = mdb_put (env.tx (transaction_a), temp, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ value_val.size (), value_val.data () };
auto s = mdb_put (env.tx (transaction_a), temp, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));
@ -545,7 +557,9 @@ 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);
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, key_val.mdb_val_ptr (), value_val.mdb_val_ptr (), MDB_APPEND);
MDB_val mdb_key{ key_val.size (), key_val.data () };
MDB_val mdb_value{ value_val.size (), value_val.data () };
auto s = mdb_put (env.tx (transaction_a), pending_store.pending_handle, &mdb_key, &mdb_value, MDB_APPEND);
release_assert_success (s);
}
release_assert (count (transaction_a, pending_store.pending_handle) == count (transaction_a, temp));

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

@ -48,7 +48,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), pending_handle, val) } };
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) } };
}
auto nano::store::lmdb::pending::begin (store::transaction const & transaction_a) const -> iterator

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

@ -48,7 +48,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, val) } };
MDB_val mdb_val{ val.size (), val.data () };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction), pruned_handle, mdb_val) } };
}
auto nano::store::lmdb::pruned::begin (store::transaction const & transaction) const -> iterator

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

@ -46,7 +46,8 @@ 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 };
return iterator{ store::iterator{ lmdb::iterator::lower_bound (store.env.tx (transaction_a), rep_weights_handle, val) } };
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) } };
}
auto nano::store::lmdb::rep_weight::begin (store::transaction const & transaction_a) const -> iterator

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

@ -46,7 +46,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::accounts), val) } };
::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) } };
}
auto nano::store::rocksdb::account::begin (store::transaction const & transaction) const -> iterator

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

@ -131,7 +131,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::blocks), val) } };
::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) } };
}
auto nano::store::rocksdb::block::end (store::transaction const & transaction_a) const -> iterator

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

@ -63,7 +63,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::confirmation_height), val) } };
::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) } };
}
auto nano::store::rocksdb::confirmation_height::begin (store::transaction const & transaction) const -> iterator

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

@ -55,7 +55,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction), store.table_to_column_family (tables::final_votes), val) } };
::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) } };
}
auto nano::store::rocksdb::final_vote::begin (store::transaction const & transaction) const -> iterator

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

@ -49,7 +49,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pending), val) } };
::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) } };
}
auto nano::store::rocksdb::pending::begin (store::transaction const & transaction_a) const -> iterator

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

@ -49,7 +49,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (transaction_a), store.table_to_column_family (tables::pruned), val) } };
::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) } };
}
auto nano::store::rocksdb::pruned::begin (store::transaction const & transaction_a) const -> iterator

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

@ -46,7 +46,8 @@ 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 };
return iterator{ store::iterator{ rocksdb::iterator::lower_bound (store.db.get (), rocksdb::tx (txn_a), store.table_to_column_family (tables::rep_weights), val) } };
::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) } };
}
auto nano::store::rocksdb::rep_weight::begin (store::transaction const & txn_a) const -> iterator

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

@ -533,6 +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 internals = rocksdb::tx (transaction_a);
auto status = std::visit ([&] (auto && ptr) {
using V = std::remove_cvref_t<decltype (ptr)>;
@ -540,11 +541,11 @@ bool nano::store::rocksdb::component::exists (store::transaction const & transac
{
::rocksdb::ReadOptions options;
options.fill_cache = false;
return ptr->Get (options, table_to_column_family (table_a), key_a, &slice);
return ptr->Get (options, table_to_column_family (table_a), key_slice, &slice);
}
else if constexpr (std::is_same_v<V, ::rocksdb::ReadOptions *>)
{
return db->Get (*ptr, table_to_column_family (table_a), key_a, &slice);
return db->Get (*ptr, table_to_column_family (table_a), key_slice, &slice);
}
else
{
@ -562,7 +563,8 @@ 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);
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_a).code ();
::rocksdb::Slice key_slice{ reinterpret_cast<char const *> (key_a.data ()), key_a.size () };
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Delete (table_to_column_family (table_a), key_slice).code ();
}
void nano::store::rocksdb::component::flush_tombstones_check (tables table_a)
@ -589,17 +591,18 @@ 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 handle = table_to_column_family (table_a);
auto internals = rocksdb::tx (transaction_a);
auto status = std::visit ([&] (auto && ptr) {
using V = std::remove_cvref_t<decltype (ptr)>;
if constexpr (std::is_same_v<V, ::rocksdb::Transaction *>)
{
return ptr->Get (options, handle, key_a, &slice);
return ptr->Get (options, handle, key_slice, &slice);
}
else if constexpr (std::is_same_v<V, ::rocksdb::ReadOptions *>)
{
return db->Get (*ptr, handle, key_a, &slice);
return db->Get (*ptr, handle, key_slice, &slice);
}
else
{
@ -620,7 +623,9 @@ 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));
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_a, value_a).code ();
::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 () };
return std::get<::rocksdb::Transaction *> (rocksdb::tx (transaction_a))->Put (table_to_column_family (table_a), key_slice, value_slice).code ();
}
bool nano::store::rocksdb::component::not_found (int status) const