Add overrides to hashmap, write key in unlinked tx.set.

Author: evoskuil

include/bitcoin/database/impl/primitives/hashmap.ipp

@@ -143,16 +143,28 @@ inline Link CLASS::top(const Link& link) const NOEXCEPT
     return head_.top(link);
 }
 
+TEMPLATE
+inline bool CLASS::exists(const memory_ptr& ptr, const Key& key) const NOEXCEPT
+{
+    return !first(ptr, key).is_terminal();
+}
+
 TEMPLATE
 inline bool CLASS::exists(const Key& key) const NOEXCEPT
 {
     return !first(key).is_terminal();
 }
 
+TEMPLATE
+inline Link CLASS::first(const memory_ptr& ptr, const Key& key) const NOEXCEPT
+{
+    return first(ptr, head_.top(key), key);
+}
+
 TEMPLATE
 inline Link CLASS::first(const Key& key) const NOEXCEPT
 {
-    return first(get_memory(), head_.top(key), key);
+    return first(get_memory(), key);
 }
 
 TEMPLATE
@@ -250,14 +262,32 @@ inline bool CLASS::get(const iterator& it, const Link& link,
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-bool CLASS::set(const Link& link, const Element& element) NOEXCEPT
+bool CLASS::set(const memory_ptr& ptr, const Link& link, const Key& key,
+    const Element& element) NOEXCEPT
 {
     using namespace system;
-    const auto ptr = body_.get(link);
     if (!ptr)
         return false;
 
-    iostream stream{ *ptr };
+    const auto start = body::link_to_position(link);
+    if (is_limited<ptrdiff_t>(start))
+        return false;
+
+    const auto size = ptr->size();
+    const auto position = possible_narrow_and_sign_cast<ptrdiff_t>(start);
+    if (position > size)
+        return false;
+
+    // Stream starts at record and the index is skipped for reader convenience.
+    const auto offset = ptr->offset(start);
+    if (is_null(offset))
+        return false;
+
+    // Set element search key.
+    unsafe_array_cast<uint8_t, key_size>(std::next(offset,
+        Link::size)) = key;
+
+    iostream stream{ offset, size - position };
     finalizer sink{ stream };
     sink.skip_bytes(index_size);
 
@@ -267,21 +297,30 @@ bool CLASS::set(const Link& link, const Element& element) NOEXCEPT
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-inline Link CLASS::set_link(const Element& element) NOEXCEPT
+bool CLASS::set(const Link& link, const Key& key,
+    const Element& element) NOEXCEPT
+{
+    return set(get_memory(), link, key, element);
+}
+
+TEMPLATE
+template <typename Element, if_equal<Element::size, Size>>
+inline Link CLASS::set_link(const Key& key, const Element& element) NOEXCEPT
 {
     Link link{};
-    if (!set_link(link, element))
+    if (!set_link(link, key, element))
         return {};
 
     return link;
 }
 
 TEMPLATE
 template <typename Element, if_equal<Element::size, Size>>
-inline bool CLASS::set_link(Link& link, const Element& element) NOEXCEPT
+inline bool CLASS::set_link(Link& link, const Key& key,
+    const Element& element) NOEXCEPT
 {
     link = allocate(element.count());
-    return set(link, element);
+    return set(link, key, element);
 }
 
 TEMPLATE
@@ -329,22 +368,33 @@ inline bool CLASS::put(const memory_ptr& ptr, const Link& link, const Key& key,
 }
 
 TEMPLATE
-bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
+bool CLASS::commit(const memory_ptr& ptr, const Link& link,
+    const Key& key) NOEXCEPT
 {
     using namespace system;
-    const auto ptr = body_.get(link);
     if (!ptr)
         return false;
 
-    // Set element search key.
-    unsafe_array_cast<uint8_t, key_size>(std::next(ptr->begin(),
-        Link::size)) = key;
+    // get element offset (fault)
+    const auto offset = ptr->offset(body::link_to_position(link));
+    if (is_null(offset))
+        return false;
+
+    //// Set element search key.
+    //unsafe_array_cast<uint8_t, key_size>(std::next(offset,
+    //    Link::size)) = key;
 
     // Commit element to search index (terminal is a valid bucket index).
-    auto& next = unsafe_array_cast<uint8_t, Link::size>(ptr->begin());
+    auto& next = unsafe_array_cast<uint8_t, Link::size>(offset);
     return head_.push(link, next, head_.index(key));
 }
 
+TEMPLATE
+bool CLASS::commit(const Link& link, const Key& key) NOEXCEPT
+{
+    return commit(get_memory(), link, key);
+}
+
 TEMPLATE
 inline Link CLASS::commit_link(const Link& link, const Key& key) NOEXCEPT
 {

include/bitcoin/database/impl/query/archive_write.ipp

@@ -127,7 +127,7 @@ code CLASS::set_code(tx_link& tx_fk, const transaction& tx) NOEXCEPT
 
     // Create tx record.
     // Commit is deferred for point/address index consistency.
-    if (!store_.tx.set(tx_fk, table::transaction::record_put_ref
+    if (!store_.tx.set(tx_fk, tx.get_hash(false), table::transaction::put_ref
     {
         {},
         tx,
@@ -232,7 +232,7 @@ code CLASS::set_code(header_link& out_fk, const header& header,
     const auto scope = store_.get_transactor();
 
     // Clean single allocation failure (e.g. disk full).
-    out_fk = store_.header.put_link(key, table::header::record_put_ref
+    out_fk = store_.header.put_link(key, table::header::put_ref
     {
         {},
         ctx,

include/bitcoin/database/primitives/hashmap.hpp

@@ -96,9 +96,11 @@ class hashmap
     inline Link top(const Link& list) const NOEXCEPT;
 
     /// True if an instance of object with key exists.
+    inline bool exists(const memory_ptr& ptr, const Key& key) const NOEXCEPT;
     inline bool exists(const Key& key) const NOEXCEPT;
 
     /// Return first element link or terminal if not found/error.
+    inline Link first(const memory_ptr& ptr, const Key& key) const NOEXCEPT;
     inline Link first(const Key& key) const NOEXCEPT;
 
     /// Iterator holds shared lock on storage remap.
@@ -143,13 +145,19 @@ class hashmap
 
     /// Set element into previously allocated link (follow with commit).
     template <typename Element, if_equal<Element::size, Size> = true>
-    bool set(const Link& link, const Element& element) NOEXCEPT;
+    bool set(const memory_ptr& ptr, const Link& link, const Key& key,
+        const Element& element) NOEXCEPT;
+
+    /// Set element into previously allocated link (follow with commit).
+    template <typename Element, if_equal<Element::size, Size> = true>
+    bool set(const Link& link, const Key& key, const Element& element) NOEXCEPT;
 
     /// Allocate and set element, and return link (follow with commit).
     template <typename Element, if_equal<Element::size, Size> = true>
-    inline Link set_link(const Element& element) NOEXCEPT;
+    inline Link set_link(const Key& key, const Element& element) NOEXCEPT;
     template <typename Element, if_equal<Element::size, Size> = true>
-    inline bool set_link(Link& link, const Element& element) NOEXCEPT;
+    inline bool set_link(Link& link, const Key& key,
+        const Element& element) NOEXCEPT;
 
     /// Allocate, set, commit element to key, and return link.
     template <typename Element, if_equal<Element::size, Size> = true>
@@ -173,6 +181,7 @@ class hashmap
         const Element& element) NOEXCEPT;
 
     /// Commit previously set element at link to key.
+    bool commit(const memory_ptr& ptr, const Link& link, const Key& key) NOEXCEPT;
     bool commit(const Link& link, const Key& key) NOEXCEPT;
     inline Link commit_link(const Link& link, const Key& key) NOEXCEPT;
 

include/bitcoin/database/tables/archives/header.hpp

@@ -116,7 +116,7 @@ struct header
     ////};
 
     // This is redundant with record_put_ptr except this does not capture.
-    struct record_put_ref
+    struct put_ref
       : public schema::header
     {
         // header.previous_block_hash() ignored.

include/bitcoin/database/tables/archives/transaction.hpp

@@ -137,7 +137,7 @@ struct transaction
         outs::integer outs_fk{};
     };
 
-    struct record_put_ref
+    struct put_ref
       : public schema::transaction
     {
         inline bool to_data(finalizer& sink) const NOEXCEPT

test/primitives/hashmap.cpp

@@ -876,15 +876,15 @@ BOOST_AUTO_TEST_CASE(hashmap__set_commit__record__expected)
     hashmap_<link5, key10, flex_record::size> instance{ head_store, body_store, 2 };
     BOOST_REQUIRE(instance.create());
 
+    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     constexpr auto size = link5::size + array_count<key10> + flex_record::size;
-    const auto link = instance.set_link(flex_record{ 0x01020304_u32 });
+    const auto link = instance.set_link(key1, flex_record{ 0x01020304_u32 });
     BOOST_REQUIRE(!link.is_terminal());
     BOOST_REQUIRE_EQUAL(link, 0u);
     BOOST_REQUIRE_EQUAL(body_store.buffer().size(), size);
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffffffffffffffffffffffffffffffffff"));
-    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000000000000000000000004030201"));
+    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000102030405060708090a04030201"));
 
-    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     BOOST_REQUIRE(instance.commit(link, key1));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffff0000000000ffffffffffffffffffff"));
     BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("ffffffffff0102030405060708090a04030201"));
@@ -899,16 +899,16 @@ BOOST_AUTO_TEST_CASE(hashmap__allocate_set_commit__record__expected)
     hashmap_<link5, key10, flex_record::size> instance{ head_store, body_store, 2 };
     BOOST_REQUIRE(instance.create());
 
+    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     constexpr auto size = link5::size + array_count<key10> + flex_record::size;
     const auto link = instance.allocate(1);
     BOOST_REQUIRE_EQUAL(link, 0u);
     BOOST_REQUIRE_EQUAL(body_store.buffer().size(), size);
 
-    BOOST_REQUIRE(instance.set(link, flex_record{ 0x01020304_u32 }));
+    BOOST_REQUIRE(instance.set(link, key1, flex_record{ 0x01020304_u32 }));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffffffffffffffffffffffffffffffffff"));
-    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000000000000000000000004030201"));
+    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000102030405060708090a04030201"));
 
-    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     BOOST_REQUIRE(instance.commit(link, key1));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffff0000000000ffffffffffffffffffff"));
     BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("ffffffffff0102030405060708090a04030201"));
@@ -921,13 +921,13 @@ BOOST_AUTO_TEST_CASE(hashmap__allocate_put1__record__expected)
     test::chunk_storage body_store{};
     hashmap_<link5, key10, flex_record::size> instance{ head_store, body_store, 2 };
     BOOST_REQUIRE(instance.create());
-    
+
+    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     constexpr auto size = link5::size + array_count<key10> + sizeof(uint32_t);
     const auto link = instance.allocate(1);
     BOOST_REQUIRE_EQUAL(link, 0u);
     BOOST_REQUIRE_EQUAL(body_store.buffer().size(), size);
 
-    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     BOOST_REQUIRE(instance.put(link, key1, flex_record{ 0x01020304_u32 }));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffff0000000000ffffffffffffffffffff"));
     BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("ffffffffff0102030405060708090a04030201"));
@@ -955,16 +955,16 @@ BOOST_AUTO_TEST_CASE(hashmap__set_commit_link__slab__expected)
     hashmap_<link5, key10, flex_slab::size> instance{ head_store, body_store, 2 };
     BOOST_REQUIRE(instance.create());
 
+    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     constexpr auto size = link5::size + array_count<key10> + sizeof(uint32_t);
     link5 link{};
-    BOOST_REQUIRE(instance.set_link(link, flex_slab{ 0x01020304_u32 }));
+    BOOST_REQUIRE(instance.set_link(link, key1, flex_slab{ 0x01020304_u32 }));
     BOOST_REQUIRE(!link.is_terminal());
     BOOST_REQUIRE_EQUAL(link, 0u);
     BOOST_REQUIRE_EQUAL(body_store.buffer().size(), size);
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffffffffffffffffffffffffffffffffff"));
-    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000000000000000000000004030201"));
+    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000102030405060708090a04030201"));
 
-    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     BOOST_REQUIRE(!instance.commit_link(link, key1).is_terminal());
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffff0000000000ffffffffffffffffffff"));
     BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("ffffffffff0102030405060708090a04030201"));
@@ -978,16 +978,16 @@ BOOST_AUTO_TEST_CASE(hashmap__allocate_set_commit__slab__expected)
     hashmap_<link5, key10, flex_slab::size> instance{ head_store, body_store, 2 };
     BOOST_REQUIRE(instance.create());
 
+    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     constexpr auto size = link5::size + array_count<key10> + sizeof(uint32_t);
     const auto link = instance.allocate(size);
     BOOST_REQUIRE_EQUAL(link, 0u);
     BOOST_REQUIRE_EQUAL(body_store.buffer().size(), size);
 
-    BOOST_REQUIRE(instance.set(link, flex_slab{ 0x01020304_u32 }));
+    BOOST_REQUIRE(instance.set(link, key1, flex_slab{ 0x01020304_u32 }));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffffffffffffffffffffffffffffffffff"));
-    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000000000000000000000004030201"));
+    BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("00000000000102030405060708090a04030201"));
 
-    constexpr key10 key1{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a };
     BOOST_REQUIRE(instance.commit(link, key1));
     BOOST_REQUIRE_EQUAL(head_store.buffer(), base16_chunk("0000000000ffffffffff0000000000ffffffffffffffffffff"));
     BOOST_REQUIRE_EQUAL(body_store.buffer(), base16_chunk("ffffffffff0102030405060708090a04030201"));

test/tables/archives/header.cpp

@@ -152,7 +152,7 @@ BOOST_AUTO_TEST_CASE(header__put_ref__get__expected)
     BOOST_REQUIRE(instance.create());
     BOOST_REQUIRE(!instance.put_link({}, table::header::record{}).is_terminal());
 
-    const table::header::record_put_ref put_ref
+    const table::header::put_ref put_ref
     {
         {},
         expected.ctx,

test/tables/caches/prevout.cpp

@@ -273,7 +273,7 @@
 ////    BOOST_REQUIRE_EQUAL(element.output_tx_fk(), expected_tx);
 ////}
 ////
-////// record_put_ref
+////// put_ref
 ////
 ////BOOST_AUTO_TEST_CASE(prevout__put_ref__get_non_empty_block_with_default_metadata__inside_spend_terminals)
 ////{
@@ -284,7 +284,7 @@
 ////    table::prevout instance{ head_store, body_store, 5 };
 ////    BOOST_REQUIRE(instance.create());
 ////
-////    const auto record = table::prevout::record_put_ref{ {}, bogus_block };
+////    const auto record = table::prevout::put_ref{ {}, bogus_block };
 ////    BOOST_REQUIRE(instance.put(2, record));
 ////
 ////    table::prevout::record_get element{};
@@ -367,7 +367,7 @@
 ////    table::prevout instance{ head_store, body_store, 5 };
 ////    BOOST_REQUIRE(instance.create());
 ////
-////    const auto record = table::prevout::record_put_ref{ {}, bogus_block };
+////    const auto record = table::prevout::put_ref{ {}, bogus_block };
 ////    BOOST_REQUIRE(instance.put(2, record));
 ////
 ////    table::prevout::record_get element{};