datastore: query caches refactoring

* refactor DomainGetLatestQuery and InvertedIndexSeekQuery with raw and caching wrappers
* QueryCaches - a part of DataStore, configured by QueryCachesSchema (a part of snapshots schema) to own and register query caches.
  It is passed through queries along with the repositories.

Author: battlmonstr

silkworm/capi/init.cpp

@@ -83,6 +83,7 @@ SILKWORM_EXPORT int silkworm_init(SilkwormHandle* handle, const struct SilkwormS
         .state_repository_latest = std::move(state_repository_latest),
         .state_repository_historical = std::move(state_repository_historical),
         .chaindata = {},
+        .query_caches = snapshots::QueryCaches{db::state::make_query_caches_schema(), snapshots_dir_path, settings->state_repo_index_salt},
     };
 
     // NOLINTNEXTLINE(bugprone-unhandled-exception-at-new)

silkworm/capi/silkworm.cpp

@@ -500,6 +500,7 @@ SILKWORM_EXPORT int silkworm_execute_txn(SilkwormHandle handle, MDBX_txn* mdbx_t
         db_ref,
         handle->db->blocks_repository,
         handle->db->state_repository_latest,
+        handle->db->query_caches,
     };
     if (!handle->chain_config) {
         handle->chain_config = db::read_chain_config(unmanaged_tx);
@@ -646,6 +647,7 @@ SILKWORM_EXPORT int silkworm_block_exec_end(SilkwormHandle handle, MDBX_txn* mdb
             db_ref,
             handle->db->blocks_repository,
             handle->db->state_repository_latest,
+            handle->db->query_caches,
         };
 
         const auto log_index = handle->executions_in_block[index].log_index;

silkworm/db/blocks/schema_config.cpp

@@ -57,8 +57,6 @@ snapshots::SnapshotRepository make_blocks_repository(
         schema,
         index_salt,
         make_blocks_index_builders_factory(),
-        std::nullopt,  // no domain caches
-        std::nullopt,  // no inverted index caches
     };
 }
 

silkworm/db/capi/component.hpp

@@ -8,6 +8,7 @@
 #include <silkworm/core/common/assert.hpp>
 #include <silkworm/db/access_layer.hpp>
 #include <silkworm/db/datastore/kvdb/database.hpp>
+#include <silkworm/db/datastore/snapshots/query_caches.hpp>
 #include <silkworm/db/datastore/snapshots/snapshot_repository.hpp>
 
 namespace silkworm::db::capi {
@@ -17,6 +18,7 @@ struct Component {
     silkworm::snapshots::SnapshotRepository state_repository_latest;
     silkworm::snapshots::SnapshotRepository state_repository_historical;
     std::unique_ptr<silkworm::datastore::kvdb::DatabaseUnmanaged> chaindata;
+    silkworm::snapshots::QueryCaches query_caches;
 
     DataStoreRef data_store() {
         SILKWORM_ASSERT(chaindata);
@@ -25,6 +27,7 @@ struct Component {
             blocks_repository,
             state_repository_latest,
             state_repository_historical,
+            query_caches,
         };
     }
 

silkworm/db/data_store.cpp

@@ -13,6 +13,7 @@ datastore::Schema DataStore::make_schema() {
     snapshots.repository(blocks::kBlocksRepositoryName) = blocks::make_blocks_repository_schema();
     snapshots.repository(state::kStateRepositoryNameLatest) = state::make_state_repository_schema_latest();
     snapshots.repository(state::kStateRepositoryNameHistorical) = state::make_state_repository_schema_historical();
+    snapshots.query_caches_schema() = state::make_query_caches_schema();
 
     return {
         std::move(kvdb),

silkworm/db/data_store.hpp

@@ -17,6 +17,7 @@ struct DataStoreRef {
     snapshots::SnapshotRepository& blocks_repository;
     snapshots::SnapshotRepository& state_repository_latest;
     snapshots::SnapshotRepository& state_repository_historical;
+    const snapshots::QueryCaches& query_caches;
 };
 
 class DataStore {
@@ -32,6 +33,7 @@ class DataStore {
                   std::move(blocks_repository),
                   std::move(state_repository_latest),
                   std::move(state_repository_historical)),
+              blocks_repository.path(),
           } {}
 
   public:
@@ -61,6 +63,7 @@ class DataStore {
             blocks_repository(),
             state_repository_latest(),
             state_repository_historical(),
+            store_.query_caches(),
         };
     }
 
@@ -75,6 +78,7 @@ class DataStore {
     snapshots::SnapshotRepository& state_repository_historical() const {
         return store_.repository(state::kStateRepositoryNameHistorical);
     }
+    const snapshots::QueryCaches& query_caches() const { return store_.query_caches(); }
 
     static datastore::kvdb::Schema::DatabaseDef make_chaindata_database_schema();
     static datastore::kvdb::Database make_chaindata_database(mdbx::env_managed chaindata_env);

silkworm/db/datastore/data_store.hpp

@@ -8,6 +8,7 @@
 #include "common/entity_name.hpp"
 #include "kvdb/database.hpp"
 #include "schema.hpp"
+#include "snapshots/query_caches.hpp"
 #include "snapshots/snapshot_repository.hpp"
 
 namespace silkworm::datastore {
@@ -17,21 +18,25 @@ class DataStore {
     DataStore(
         Schema schema,
         EntityMap<std::unique_ptr<kvdb::Database>> databases,
-        EntityMap<std::unique_ptr<snapshots::SnapshotRepository>> repositories)
+        EntityMap<std::unique_ptr<snapshots::SnapshotRepository>> repositories,
+        const std::filesystem::path& snapshots_path)
         : schema_{std::move(schema)},
           databases_{std::move(databases)},
-          repositories_{std::move(repositories)} {}
+          repositories_{std::move(repositories)},
+          query_caches_{schema.snapshots.query_caches_schema(), snapshots_path} {}
 
     const Schema& schema() const { return schema_; }
 
     kvdb::Database& default_database() const { return database(kvdb::Schema::kDefaultEntityName); }
     kvdb::Database& database(const EntityName& name) const { return *databases_.at(name); }
     snapshots::SnapshotRepository& repository(const EntityName& name) const { return *repositories_.at(name); }
+    const snapshots::QueryCaches& query_caches() const { return query_caches_; }
 
   private:
     Schema schema_;
     EntityMap<std::unique_ptr<kvdb::Database>> databases_;
     EntityMap<std::unique_ptr<snapshots::SnapshotRepository>> repositories_;
+    snapshots::QueryCaches query_caches_;
 };
 
 }  // namespace silkworm::datastore

silkworm/db/datastore/domain_get_as_of_query.hpp

@@ -17,17 +17,19 @@ struct DomainGetAsOfQuery {
         kvdb::Domain kvdb_entity,
         kvdb::ROTxn& tx,
         const snapshots::SnapshotRepositoryROAccess& repository_latest,
-        const snapshots::SnapshotRepositoryROAccess& repository_historical)
-        : query1_{*kvdb_entity.history, tx, repository_historical},
-          query2_{history_segment_names.front(), kvdb_entity, tx, repository_latest} {}
+        const snapshots::SnapshotRepositoryROAccess& repository_historical,
+        const snapshots::QueryCaches& query_caches)
+        : query1_{*kvdb_entity.history, tx, repository_historical, query_caches},
+          query2_{history_segment_names.front(), kvdb_entity, tx, repository_latest, query_caches} {}
 
     DomainGetAsOfQuery(
         const kvdb::DatabaseRef& database,
         kvdb::ROTxn& tx,
         const snapshots::SnapshotRepositoryROAccess& repository_latest,
-        const snapshots::SnapshotRepositoryROAccess& repository_historical)
-        : query1_{database, tx, repository_historical},
-          query2_{history_segment_names.front(), database, tx, repository_latest} {}
+        const snapshots::SnapshotRepositoryROAccess& repository_historical,
+        const snapshots::QueryCaches& query_caches)
+        : query1_{database, tx, repository_historical, query_caches},
+          query2_{history_segment_names.front(), database, tx, repository_latest, query_caches} {}
 
     using Key = decltype(TKeyEncoder1::value);
     using Value = decltype(TValueDecoder1::value);

silkworm/db/datastore/domain_get_latest_query.hpp

@@ -17,20 +17,23 @@ struct DomainGetLatestQuery {
         datastore::EntityName entity_name,
         kvdb::Domain kvdb_entity,
         kvdb::ROTxn& tx,
-        const snapshots::SnapshotRepositoryROAccess& repository)
+        const snapshots::SnapshotRepositoryROAccess& repository,
+        const snapshots::QueryCaches& query_caches)
         : query1_{tx, kvdb_entity},
-          query2_{repository, entity_name} {}
+          query2_{repository, query_caches, entity_name} {}
 
     DomainGetLatestQuery(
         datastore::EntityName entity_name,
         const kvdb::DatabaseRef& database,
         kvdb::ROTxn& tx,
-        const snapshots::SnapshotRepositoryROAccess& repository)
+        const snapshots::SnapshotRepositoryROAccess& repository,
+        const snapshots::QueryCaches& query_caches)
         : DomainGetLatestQuery{
               entity_name,
               database.domain(entity_name),
               tx,
               repository,
+              query_caches,
           } {}
 
     using Key1 = decltype(TKeyEncoder1::value);

silkworm/db/datastore/history_get_query.hpp

@@ -17,18 +17,21 @@ struct HistoryGetQuery {
     HistoryGetQuery(
         kvdb::History kvdb_entity,
         kvdb::ROTxn& tx,
-        const snapshots::SnapshotRepositoryROAccess& repository)
+        const snapshots::SnapshotRepositoryROAccess& repository,
+        const snapshots::QueryCaches& query_caches)
         : query1_{tx, kvdb_entity},
-          query2_{repository} {}
+          query2_{repository, query_caches} {}
 
     HistoryGetQuery(
         const kvdb::DatabaseRef& database,
         kvdb::ROTxn& tx,
-        const snapshots::SnapshotRepositoryROAccess& repository)
+        const snapshots::SnapshotRepositoryROAccess& repository,
+        const snapshots::QueryCaches& query_caches)
         : HistoryGetQuery{
               database.domain(segment_names.front()).history.value(),
               tx,
               repository,
+              query_caches,
           } {}
 
     using Key1 = decltype(TKeyEncoder1::value);