Simplify db val conversions

nano/node/wallet.cpp

@@ -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 () };
+		auto mdb_version_key2 = nano::store::lmdb::to_mdb_val (version_key);
-		MDB_val mdb_wallet_key_key{ wallet_key_key.size (), wallet_key_key.data () };
+		auto mdb_wallet_key_key = nano::store::lmdb::to_mdb_val (wallet_key_key);
-		MDB_val mdb_salt_key{ salt_key.size (), salt_key.data () };
+		auto mdb_salt_key = nano::store::lmdb::to_mdb_val (salt_key);
-		MDB_val mdb_check_key{ check_key.size (), check_key.data () };
+		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 () };
+	auto mdb_pub_key = nano::store::lmdb::to_mdb_val (pub_key);
-	MDB_val mdb_entry_val{ entry_val.size (), entry_val.data () };
+	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 () };
+							auto mdb_id_key = nano::store::lmdb::to_mdb_val (*id_mdb_val);
-							MDB_val mdb_hash_val{ hash_val.size (), hash_val.data () };
+							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 () };
+		auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
-		MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+		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 () };
+	auto mdb_beginning_val = nano::store::lmdb::to_mdb_val (beginning_val);
-	MDB_val mdb_end_val{ end_val.size (), end_val.data () };
+	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 };
+	return iterator{ store::iterator{ store::lmdb::iterator::lower_bound (env.tx (transaction_a), handle, store::lmdb::to_mdb_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) } };
 }
 
 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, store::lmdb::to_mdb_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) } };
 }
 
 auto nano::wallet_store::find (store::transaction const & transaction_a, nano::account const & key) -> iterator

nano/store/db_val.hpp

@@ -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))
 	{

nano/store/lmdb/account.cpp

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

nano/store/lmdb/block.cpp

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

nano/store/lmdb/confirmation_height.cpp

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

nano/store/lmdb/final_vote.cpp

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

nano/store/lmdb/lmdb.cpp

@@ -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 = from_mdb_val (mdb_value);
-		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
 {
-	MDB_val mdb_key{ key_a.size (), key_a.data () };
+	auto mdb_key = to_mdb_val (key_a);
-	MDB_val mdb_value{ value_a.size (), value_a.data () };
+	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 () };
+			auto mdb_key = to_mdb_val (key_val);
-			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			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 () };
+			auto mdb_key = to_mdb_val (key_val);
-			MDB_val mdb_value{ i->second.size (), i->second.data () };
+			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 () };
+			auto mdb_key = to_mdb_val (key_val);
-			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			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 () };
+			auto mdb_key = to_mdb_val (key_val);
-			MDB_val mdb_value{ value_val.size (), value_val.data () };
+			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);
 		}

nano/store/lmdb/pending.cpp

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

nano/store/lmdb/pruned.cpp

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

nano/store/lmdb/rep_weight.cpp

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

nano/store/lmdb/utility.hpp

@@ -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);
+}
+}

nano/store/rocksdb/account.cpp

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

nano/store/rocksdb/block.cpp

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

nano/store/rocksdb/confirmation_height.cpp

@@ -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 };
+	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)) } };
-	::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

nano/store/rocksdb/final_vote.cpp

@@ -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 };
+	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)) } };
-	::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

nano/store/rocksdb/pending.cpp

@@ -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 };
+	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)) } };
-	::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

nano/store/rocksdb/pending.hpp

@@ -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

nano/store/rocksdb/pruned.cpp

@@ -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 };
+	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)) } };
-	::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

nano/store/rocksdb/rep_weight.cpp

@@ -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 };
+	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)) } };
-	::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

nano/store/rocksdb/rocksdb.cpp

@@ -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 ());
+		value_a = from_slice (slice);
-		std::memcpy (value_a.buffer->data (), slice.data (), slice.size ());
-		value_a.convert_buffer_to_value ();
 	}
 	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 () };
+	auto key_slice = to_slice (key_a);
-	::rocksdb::Slice value_slice{ reinterpret_cast<char const *> (value_a.data ()), value_a.size () };
+	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 ();
 }
 

nano/store/rocksdb/utility.hpp

@@ -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);
+}
 }