From 68440ddd30c60fbf652464014f0140ed2de9e112 Mon Sep 17 00:00:00 2001 From: battlmonstr Date: Fri, 7 Mar 2025 14:55:16 +0100 Subject: [PATCH] db: rename kv Query to Request (#2768) --- cmd/dev/grpc_toolbox.cpp | 52 ++++----- .../db/kv/api/endpoint/temporal_point.hpp | 14 +-- .../db/kv/api/endpoint/temporal_range.hpp | 10 +- silkworm/db/kv/api/local_transaction.cpp | 102 +++++++++--------- silkworm/db/kv/api/local_transaction.hpp | 12 +-- silkworm/db/kv/api/transaction.hpp | 12 +-- .../grpc/client/endpoint/temporal_point.cpp | 46 ++++---- .../grpc/client/endpoint/temporal_point.hpp | 6 +- .../client/endpoint/temporal_point_test.cpp | 44 ++++---- .../grpc/client/endpoint/temporal_range.cpp | 74 ++++++------- .../grpc/client/endpoint/temporal_range.hpp | 6 +- .../client/endpoint/temporal_range_test.cpp | 94 ++++++++-------- .../db/kv/grpc/client/remote_transaction.cpp | 60 +++++------ .../db/kv/grpc/client/remote_transaction.hpp | 12 +-- .../grpc/client/remote_transaction_test.cpp | 48 ++++----- .../db/kv/grpc/test_util/sample_protos.hpp | 12 +-- silkworm/db/kv/state_reader.cpp | 24 ++--- silkworm/db/test_util/mock_transaction.hpp | 12 +-- silkworm/rpc/commands/debug_api.cpp | 6 +- silkworm/rpc/commands/debug_api_test.cpp | 4 +- silkworm/rpc/commands/ots_api.cpp | 16 +-- silkworm/rpc/commands/parity_api.cpp | 2 +- silkworm/rpc/core/account_dumper.cpp | 6 +- silkworm/rpc/core/account_dumper_test.cpp | 12 +-- silkworm/rpc/core/block_reader.cpp | 2 +- silkworm/rpc/core/evm_debug_test.cpp | 54 +++++----- silkworm/rpc/core/evm_trace_test.cpp | 102 +++++++++--------- silkworm/rpc/core/logs_walker.cpp | 4 +- silkworm/rpc/core/receipts.cpp | 4 +- silkworm/rpc/core/storage_walker.cpp | 2 +- silkworm/rpc/core/storage_walker_test.cpp | 12 +-- silkworm/rpc/test_util/dummy_transaction.hpp | 12 +-- 32 files changed, 439 insertions(+), 439 deletions(-) diff --git a/cmd/dev/grpc_toolbox.cpp b/cmd/dev/grpc_toolbox.cpp index 24a722b62a..a2224b40ce 100644 --- a/cmd/dev/grpc_toolbox.cpp +++ b/cmd/dev/grpc_toolbox.cpp @@ -849,12 +849,12 @@ int kv_seek() { } Task kv_get_latest_query(const std::shared_ptr& kv_service, - GetLatestQuery&& query, + GetLatestRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV GetLatest -> " << query.table << " key=" << to_hex(query.key) << " latest=true\n"; - const auto result = co_await tx->get_latest(std::move(query)); + std::cout << "KV GetLatest -> " << request.table << " key=" << to_hex(request.key) << " latest=true\n"; + const auto result = co_await tx->get_latest(std::move(request)); std::cout << "KV GetLatest <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { @@ -863,13 +863,13 @@ Task kv_get_latest_query(const std::shared_ptr& kv_service, } Task kv_get_as_of_query(const std::shared_ptr& kv_service, - GetAsOfQuery&& query, + GetAsOfRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV GetLatest -> " << query.table << " key=" << to_hex(query.key) - << " ts=" << query.timestamp << " latest=false\n"; - const auto result = co_await tx->get_as_of(std::move(query)); + std::cout << "KV GetLatest -> " << request.table << " key=" << to_hex(request.key) + << " ts=" << request.timestamp << " latest=false\n"; + const auto result = co_await tx->get_as_of(std::move(request)); std::cout << "KV GetLatest <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { @@ -878,12 +878,12 @@ Task kv_get_as_of_query(const std::shared_ptr& kv_service, } Task kv_history_seek_query(const std::shared_ptr& kv_service, - HistoryPointQuery&& query, + HistoryPointRequest request, const bool /*verbose*/) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV HistorySeek -> " << query.table << " key=" << to_hex(query.key) << " ts=" << query.timestamp << "\n"; - const auto result = co_await tx->history_seek(std::move(query)); + std::cout << "KV HistorySeek -> " << request.table << " key=" << to_hex(request.key) << " ts=" << request.timestamp << "\n"; + const auto result = co_await tx->history_seek(std::move(request)); std::cout << "KV HistorySeek <- success: " << result.success << " value=" << to_hex(result.value) << "\n"; co_await tx->close(); } catch (const std::exception& e) { @@ -892,12 +892,12 @@ Task kv_history_seek_query(const std::shared_ptr& kv_service, } Task kv_index_range_query(const std::shared_ptr& kv_service, - IndexRangeQuery&& query, + IndexRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV IndexRange -> " << query.table << "\n"; - auto paginated_result = co_await tx->index_range(std::move(query)); + std::cout << "KV IndexRange -> " << request.table << "\n"; + auto paginated_result = co_await tx->index_range(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV IndexRange <- #timestamps: "; int count{0}; @@ -919,12 +919,12 @@ Task kv_index_range_query(const std::shared_ptr& kv_service, } Task kv_history_range_query(const std::shared_ptr& kv_service, - HistoryRangeQuery&& query, + HistoryRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV HistoryRange -> " << query.table << " limit=" << query.limit << "\n"; - auto paginated_result = co_await tx->history_range(std::move(query)); + std::cout << "KV HistoryRange -> " << request.table << " limit=" << request.limit << "\n"; + auto paginated_result = co_await tx->history_range(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV HistoryRange <- #keys and #values: "; int count{0}; @@ -946,12 +946,12 @@ Task kv_history_range_query(const std::shared_ptr& kv_service, } Task kv_range_as_of_query(const std::shared_ptr& kv_service, - DomainRangeQuery&& query, + DomainRangeRequest request, const bool verbose) { try { auto tx = co_await kv_service->begin_transaction(); - std::cout << "KV RangeAsOf -> " << query.table << " limit=" << query.limit << "\n"; - auto paginated_result = co_await tx->range_as_of(std::move(query)); + std::cout << "KV RangeAsOf -> " << request.table << " limit=" << request.limit << "\n"; + auto paginated_result = co_await tx->range_as_of(std::move(request)); auto it = co_await paginated_result.begin(); std::cout << "KV RangeAsOf <- #keys and #values: "; int count{0}; @@ -973,7 +973,7 @@ Task kv_range_as_of_query(const std::shared_ptr& kv_service, } template -using KVQueryFunc = Task (*)(const std::shared_ptr&, Q&&, bool); +using KVQueryFunc = Task (*)(const std::shared_ptr&, Q, bool); template int execute_temporal_kv_query(const std::string& target, KVQueryFunc query_func, Q&& query, const bool verbose) { @@ -1050,14 +1050,14 @@ int kv_get_latest() { const auto verbose{absl::GetFlag(FLAGS_verbose)}; if (timestamp > -1) { - GetAsOfQuery query{ + GetAsOfRequest query{ .table = table_name, .key = *key_bytes, .timestamp = timestamp, }; return execute_temporal_kv_query(target, kv_get_as_of_query, std::move(query), verbose); } - GetLatestQuery query{ + GetLatestRequest query{ .table = table_name, .key = *key_bytes, }; @@ -1096,7 +1096,7 @@ int kv_history_seek() { const auto verbose{absl::GetFlag(FLAGS_verbose)}; - HistoryPointQuery query{ + HistoryPointRequest query{ .table = table_name, .key = *key_bytes, .timestamp = timestamp, @@ -1136,7 +1136,7 @@ int kv_index_range() { const auto verbose{absl::GetFlag(FLAGS_verbose)}; - IndexRangeQuery query{ + IndexRangeRequest query{ .table = table_name, .key = *key_bytes, .from_timestamp = 0, @@ -1171,7 +1171,7 @@ int kv_history_range() { const auto verbose{absl::GetFlag(FLAGS_verbose)}; - HistoryRangeQuery query{ + HistoryRangeRequest query{ .table = table_name, .from_timestamp = 0, .to_timestamp = -1, @@ -1228,7 +1228,7 @@ int kv_get_as_of() { const auto verbose{absl::GetFlag(FLAGS_verbose)}; - DomainRangeQuery query{ + DomainRangeRequest query{ .table = table_name, .from_key = *from_key_bytes, .to_key = *to_key_bytes, diff --git a/silkworm/db/kv/api/endpoint/temporal_point.hpp b/silkworm/db/kv/api/endpoint/temporal_point.hpp index d5d1ea3692..562a1c9404 100644 --- a/silkworm/db/kv/api/endpoint/temporal_point.hpp +++ b/silkworm/db/kv/api/endpoint/temporal_point.hpp @@ -28,7 +28,7 @@ struct PointResult { Bytes value; }; -struct HistoryPointQuery { +struct HistoryPointRequest { TxId tx_id{0}; std::string table; Bytes key; @@ -37,17 +37,17 @@ struct HistoryPointQuery { using HistoryPointResult = PointResult; -struct GetLatestQuery { +struct GetLatestRequest { TxId tx_id{0}; std::string table; Bytes key; Bytes sub_key; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below - // auto operator<=>(const GetLatestQuery&) const = default; + // auto operator<=>(const GetLatestRequest&) const = default; }; -inline bool operator==(const GetLatestQuery& lhs, const GetLatestQuery& rhs) { +inline bool operator==(const GetLatestRequest& lhs, const GetLatestRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.key == rhs.key) && @@ -56,7 +56,7 @@ inline bool operator==(const GetLatestQuery& lhs, const GetLatestQuery& rhs) { using GetLatestResult = PointResult; -struct GetAsOfQuery { +struct GetAsOfRequest { TxId tx_id{0}; std::string table; Bytes key; @@ -64,10 +64,10 @@ struct GetAsOfQuery { Timestamp timestamp; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below - // auto operator<=>(const GetAsOfQuery&) const = default; + // auto operator<=>(const GetAsOfRequest&) const = default; }; -inline bool operator==(const GetAsOfQuery& lhs, const GetAsOfQuery& rhs) { +inline bool operator==(const GetAsOfRequest& lhs, const GetAsOfRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.key == rhs.key) && diff --git a/silkworm/db/kv/api/endpoint/temporal_range.hpp b/silkworm/db/kv/api/endpoint/temporal_range.hpp index b14151be30..6ee360cf1b 100644 --- a/silkworm/db/kv/api/endpoint/temporal_range.hpp +++ b/silkworm/db/kv/api/endpoint/temporal_range.hpp @@ -32,7 +32,7 @@ inline constexpr int64_t kUnlimited{-1}; //! Infinite timestamp value in range queries inline constexpr Timestamp kInfinite{-1}; -struct IndexRangeQuery { +struct IndexRangeRequest { TxId tx_id{0}; std::string table; Bytes key; @@ -55,7 +55,7 @@ struct RangeResult { std::string next_page_token; }; -struct HistoryRangeQuery { +struct HistoryRangeRequest { TxId tx_id{0}; std::string table; Timestamp from_timestamp; @@ -66,10 +66,10 @@ struct HistoryRangeQuery { std::string page_token; // TODO(canepat) we need clang >= 17 to use spaceship operator instead of hand-made operator== below - // auto operator<=>(const HistoryRangeQuery&) const = default; + // auto operator<=>(const HistoryRangeRequest&) const = default; }; -inline bool operator==(const HistoryRangeQuery& lhs, const HistoryRangeQuery& rhs) { +inline bool operator==(const HistoryRangeRequest& lhs, const HistoryRangeRequest& rhs) { return (lhs.tx_id == rhs.tx_id) && (lhs.table == rhs.table) && (lhs.from_timestamp == rhs.from_timestamp) && @@ -82,7 +82,7 @@ inline bool operator==(const HistoryRangeQuery& lhs, const HistoryRangeQuery& rh using HistoryRangeResult = RangeResult; -struct DomainRangeQuery { +struct DomainRangeRequest { TxId tx_id{0}; std::string table; Bytes from_key; diff --git a/silkworm/db/kv/api/local_transaction.cpp b/silkworm/db/kv/api/local_transaction.cpp index 845a2ef7b4..2e3bf24eab 100644 --- a/silkworm/db/kv/api/local_transaction.cpp +++ b/silkworm/db/kv/api/local_transaction.cpp @@ -150,45 +150,45 @@ Task LocalTransaction::first_txn_num_in_block(BlockNum block_num) { co_return min_txn_num + /*txn_index=*/0; } -Task LocalTransaction::get_latest(GetLatestQuery query) { - ensure(query.sub_key.empty(), "LocalTransaction::get_latest sub_key support not implemented"); +Task LocalTransaction::get_latest(GetLatestRequest request) { + ensure(request.sub_key.empty(), "LocalTransaction::get_latest sub_key support not implemented"); - if (!kTable2EntityNames.contains(query.table)) { + if (!kTable2EntityNames.contains(request.table)) { co_return GetAsOfResult{}; } - const EntityName domain_name = kTable2EntityNames.at(query.table); - RawDomainGetLatestQuery store_query( + const EntityName domain_name = kTable2EntityNames.at(request.table); + RawDomainGetLatestQuery query( domain_name, data_store_.chaindata.domain(domain_name), tx_, data_store_.state_repository_latest); - auto result = store_query.exec(query.key); + auto result = query.exec(request.key); if (!result) { co_return GetLatestResult{}; } co_return GetLatestResult{.success = true, .value = std::move(result->value)}; } -Task LocalTransaction::get_as_of(GetAsOfQuery query) { - ensure(query.sub_key.empty(), "LocalTransaction::get_as_of sub_key support not implemented"); +Task LocalTransaction::get_as_of(GetAsOfRequest request) { + ensure(request.sub_key.empty(), "LocalTransaction::get_as_of sub_key support not implemented"); - if (!kTable2EntityNames.contains(query.table)) { + if (!kTable2EntityNames.contains(request.table)) { co_return GetAsOfResult{}; } - const EntityName domain_name = kTable2EntityNames.at(query.table); + const EntityName domain_name = kTable2EntityNames.at(request.table); std::optional value; if (domain_name == state::kDomainNameAccounts) { - value = query_domain_as_of(domain_name, query.key, query.timestamp); + value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameStorage) { - value = query_domain_as_of(domain_name, query.key, query.timestamp); + value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameCode) { - value = query_domain_as_of(domain_name, query.key, query.timestamp); + value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameCommitment) { - value = query_domain_as_of(domain_name, query.key, query.timestamp); + value = query_domain_as_of(domain_name, request.key, request.timestamp); } else if (domain_name == state::kDomainNameReceipts) { - value = query_domain_as_of(domain_name, query.key, query.timestamp); + value = query_domain_as_of(domain_name, request.key, request.timestamp); } if (!value) { co_return GetAsOfResult{}; @@ -196,30 +196,30 @@ Task LocalTransaction::get_as_of(GetAsOfQuery query) { co_return GetAsOfResult{.success = true, .value = std::move(*value)}; } -Task LocalTransaction::history_seek(HistoryPointQuery query) { - if (!kTable2EntityNames.contains(query.table)) { +Task LocalTransaction::history_seek(HistoryPointRequest request) { + if (!kTable2EntityNames.contains(request.table)) { co_return HistoryPointResult{}; } - const EntityName domain_name = kTable2EntityNames.at(query.table); + const EntityName domain_name = kTable2EntityNames.at(request.table); const kvdb::Domain domain = data_store_.chaindata.domain(domain_name); if (!domain.history) { co_return HistoryPointResult{}; } - const auto timestamp = static_cast(query.timestamp); + const auto timestamp = static_cast(request.timestamp); std::optional value; if (domain_name == state::kDomainNameAccounts) { - value = query_history_get(*domain.history, query.key, timestamp); + value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameStorage) { - value = query_history_get(*domain.history, query.key, timestamp); + value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameCode) { - value = query_history_get(*domain.history, query.key, timestamp); + value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameCommitment) { - value = query_history_get(*domain.history, query.key, timestamp); + value = query_history_get(*domain.history, request.key, timestamp); } else if (domain_name == state::kDomainNameReceipts) { - value = query_history_get(*domain.history, query.key, timestamp); + value = query_history_get(*domain.history, request.key, timestamp); } if (!value) { co_return HistoryPointResult{}; @@ -227,32 +227,32 @@ Task LocalTransaction::history_seek(HistoryPointQuery query) co_return HistoryPointResult{.success = true, .value = std::move(*value)}; } -Task LocalTransaction::index_range(IndexRangeQuery query) { - if (!kTable2EntityNames.contains(query.table)) { +Task LocalTransaction::index_range(IndexRangeRequest request) { + if (!kTable2EntityNames.contains(request.table)) { co_return api::PaginatedTimestamps{make_empty_paginator()}; } - auto paginator = [this, query = std::move(query)](api::PaginatedTimestamps::PageToken) mutable -> Task { - const EntityName inverted_index_name = kTable2EntityNames.at(query.table); - RawInvertedIndexRangeByKeyQuery store_query{ + auto paginator = [this, request = std::move(request)](api::PaginatedTimestamps::PageToken) mutable -> Task { + const EntityName inverted_index_name = kTable2EntityNames.at(request.table); + RawInvertedIndexRangeByKeyQuery query{ inverted_index_name, data_store_.chaindata, tx_, data_store_.state_repository_historical, }; - datastore::TimestampRange ts_range = as_datastore_ts_range({query.from_timestamp, query.to_timestamp}, !query.ascending_order); - const size_t limit = (query.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(query.limit); + datastore::TimestampRange ts_range = as_datastore_ts_range({request.from_timestamp, request.to_timestamp}, !request.ascending_order); + const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); api::PaginatedTimestamps::PageResult result; // TODO: support pagination: apply page_size using std::views::chunk, save the range for future requests using page_token and return the first chunk - if (query.ascending_order) { - auto timestamps = store_query.exec(query.key, std::move(ts_range)) | + if (request.ascending_order) { + auto timestamps = query.exec(request.key, std::move(ts_range)) | std::views::transform([](datastore::Timestamp ts) { return static_cast(ts); }) | std::views::take(limit); result.values = vector_from_range(std::move(timestamps)); } else { - auto timestamps = store_query.exec(query.key, std::move(ts_range)) | + auto timestamps = query.exec(request.key, std::move(ts_range)) | std::views::transform([](datastore::Timestamp ts) { return static_cast(ts); }) | std::views::take(limit); result.values = vector_from_range(std::move(timestamps)); @@ -263,26 +263,26 @@ Task LocalTransaction::index_range(IndexRangeQuery query) { co_return api::PaginatedTimestamps{std::move(paginator)}; } -Task LocalTransaction::history_range(HistoryRangeQuery query) { - if (!kTable2EntityNames.contains(query.table)) { +Task LocalTransaction::history_range(HistoryRangeRequest request) { + if (!kTable2EntityNames.contains(request.table)) { co_return api::PaginatedKeysValues{make_empty_paginator()}; } - auto paginator = [this, query = std::move(query)](api::PaginatedKeysValues::PageToken) mutable -> Task { - const EntityName entity_name = kTable2EntityNames.at(query.table); - RawHistoryRangeInPeriodQuery store_query{ + auto paginator = [this, request = std::move(request)](api::PaginatedKeysValues::PageToken) mutable -> Task { + const EntityName entity_name = kTable2EntityNames.at(request.table); + RawHistoryRangeInPeriodQuery query{ entity_name, data_store_.chaindata, tx_, data_store_.state_repository_historical, }; - datastore::TimestampRange ts_range = as_datastore_ts_range({query.from_timestamp, query.to_timestamp}, !query.ascending_order); - const size_t limit = (query.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(query.limit); + datastore::TimestampRange ts_range = as_datastore_ts_range({request.from_timestamp, request.to_timestamp}, !request.ascending_order); + const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); // TODO: support pagination: apply page_size using std::views::chunk, save the range for future requests using page_token and return the first chunk api::PaginatedKeysValues::PageResult result; - for (auto&& kv_pair : store_query.exec(ts_range, query.ascending_order) | std::views::take(limit)) { + for (auto&& kv_pair : query.exec(ts_range, request.ascending_order) | std::views::take(limit)) { result.keys.emplace_back(std::move(kv_pair.first)); result.values.emplace_back(std::move(kv_pair.second)); } @@ -292,19 +292,19 @@ Task LocalTransaction::history_range(HistoryRangeQuery quer co_return api::PaginatedKeysValues{std::move(paginator)}; } -Task LocalTransaction::range_as_of(DomainRangeQuery query) { - if (!kTable2EntityNames.contains(query.table)) { +Task LocalTransaction::range_as_of(DomainRangeRequest request) { + if (!kTable2EntityNames.contains(request.table)) { co_return api::PaginatedKeysValues{make_empty_paginator()}; } - auto paginator = [this, query = std::move(query)](api::PaginatedKeysValues::PageToken) mutable -> Task { - const EntityName entity_name = kTable2EntityNames.at(query.table); + auto paginator = [this, request = std::move(request)](api::PaginatedKeysValues::PageToken) mutable -> Task { + const EntityName entity_name = kTable2EntityNames.at(request.table); using DomainRangeAsOfQuery = DomainRangeAsOfQuery< kvdb::RawEncoder, snapshots::RawEncoder, kvdb::RawDecoder, snapshots::RawDecoder, kvdb::RawDecoder, snapshots::RawDecoder>; - DomainRangeAsOfQuery store_query{ + DomainRangeAsOfQuery query{ entity_name, data_store_.chaindata, tx_, @@ -313,14 +313,14 @@ Task LocalTransaction::range_as_of(DomainRangeQuery query) }; std::optional timestamp; - if (query.timestamp && (*query.timestamp >= 0)) { - timestamp = static_cast(*query.timestamp); + if (request.timestamp && (*request.timestamp >= 0)) { + timestamp = static_cast(*request.timestamp); } - const size_t limit = (query.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(query.limit); + const size_t limit = (request.limit == kUnlimited) ? std::numeric_limits::max() : static_cast(request.limit); // TODO: support pagination: apply page_size using std::views::chunk, save the range for future requests using page_token and return the first chunk api::PaginatedKeysValues::PageResult result; - for (auto&& kv_pair : store_query.exec(query.from_key, query.to_key, timestamp, query.ascending_order) | std::views::take(limit)) { + for (auto&& kv_pair : query.exec(request.from_key, request.to_key, timestamp, request.ascending_order) | std::views::take(limit)) { result.keys.emplace_back(std::move(kv_pair.first)); result.values.emplace_back(std::move(kv_pair.second)); } diff --git a/silkworm/db/kv/api/local_transaction.hpp b/silkworm/db/kv/api/local_transaction.hpp index acfb93513d..081690754b 100644 --- a/silkworm/db/kv/api/local_transaction.hpp +++ b/silkworm/db/kv/api/local_transaction.hpp @@ -63,22 +63,22 @@ class LocalTransaction : public BaseTransaction { Task close() override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) - Task get_latest(GetLatestQuery query) override; + Task get_latest(GetLatestRequest request) override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) - Task get_as_of(GetAsOfQuery query) override; + Task get_as_of(GetAsOfRequest request) override; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); - Task history_seek(HistoryPointQuery query) override; + Task history_seek(HistoryPointRequest request) override; // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); - Task index_range(IndexRangeQuery query) override; + Task index_range(IndexRangeRequest request) override; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); - Task history_range(HistoryRangeQuery query) override; + Task history_range(HistoryRangeRequest request) override; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); - Task range_as_of(DomainRangeQuery query) override; + Task range_as_of(DomainRangeRequest request) override; private: template diff --git a/silkworm/db/kv/api/transaction.hpp b/silkworm/db/kv/api/transaction.hpp index 6122768d83..aca1ec6249 100644 --- a/silkworm/db/kv/api/transaction.hpp +++ b/silkworm/db/kv/api/transaction.hpp @@ -77,24 +77,24 @@ class Transaction { /** Temporal Point Queries **/ // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) - virtual Task get_latest(GetLatestQuery query) = 0; + virtual Task get_latest(GetLatestRequest request) = 0; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) - virtual Task get_as_of(GetAsOfQuery query) = 0; + virtual Task get_as_of(GetAsOfRequest request) = 0; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); - virtual Task history_seek(HistoryPointQuery query) = 0; + virtual Task history_seek(HistoryPointRequest request) = 0; /** Temporal Range Queries **/ // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); - virtual Task index_range(IndexRangeQuery query) = 0; + virtual Task index_range(IndexRangeRequest request) = 0; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); - virtual Task history_range(HistoryRangeQuery query) = 0; + virtual Task history_range(HistoryRangeRequest request) = 0; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); - virtual Task range_as_of(DomainRangeQuery query) = 0; + virtual Task range_as_of(DomainRangeRequest request) = 0; }; } // namespace silkworm::db::kv::api diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp b/silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp index ad7aa11ed2..0977492d78 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_point.cpp @@ -22,13 +22,13 @@ namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; -proto::HistorySeekReq history_seek_request_from_query(const api::HistoryPointQuery& query) { - proto::HistorySeekReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_k(query.key.data(), query.key.size()); - request.set_ts(static_cast(query.timestamp)); - return request; +proto::HistorySeekReq make_history_seek_req(const api::HistoryPointRequest& request) { + proto::HistorySeekReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_k(request.key.data(), request.key.size()); + req.set_ts(static_cast(request.timestamp)); + return req; } api::HistoryPointResult history_seek_result_from_response(const proto::HistorySeekReply& response) { @@ -38,14 +38,14 @@ api::HistoryPointResult history_seek_result_from_response(const proto::HistorySe return result; } -proto::GetLatestReq get_latest_request_from_query(const api::GetLatestQuery& query) { - proto::GetLatestReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_k(query.key.data(), query.key.size()); - request.set_latest(true); - request.set_k2(query.sub_key.data(), query.sub_key.size()); - return request; +proto::GetLatestReq make_get_latest_req(const api::GetLatestRequest& request) { + proto::GetLatestReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_k(request.key.data(), request.key.size()); + req.set_latest(true); + req.set_k2(request.sub_key.data(), request.sub_key.size()); + return req; } api::GetLatestResult get_latest_result_from_response(const proto::GetLatestReply& response) { @@ -55,14 +55,14 @@ api::GetLatestResult get_latest_result_from_response(const proto::GetLatestReply return result; } -::remote::GetLatestReq get_as_of_request_from_query(const api::GetAsOfQuery& query) { - proto::GetLatestReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_k(query.key.data(), query.key.size()); - request.set_ts(static_cast(query.timestamp)); - request.set_k2(query.sub_key.data(), query.sub_key.size()); - return request; +::remote::GetLatestReq make_get_as_of_req(const api::GetAsOfRequest& request) { + proto::GetLatestReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_k(request.key.data(), request.key.size()); + req.set_ts(static_cast(request.timestamp)); + req.set_k2(request.sub_key.data(), request.sub_key.size()); + return req; } api::GetAsOfResult get_as_of_result_from_response(const ::remote::GetLatestReply& response) { diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp b/silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp index 7d5b2ae27c..e6d1511ec2 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_point.hpp @@ -22,13 +22,13 @@ namespace silkworm::db::kv::grpc::client { -::remote::HistorySeekReq history_seek_request_from_query(const api::HistoryPointQuery&); +::remote::HistorySeekReq make_history_seek_req(const api::HistoryPointRequest&); api::HistoryPointResult history_seek_result_from_response(const ::remote::HistorySeekReply&); -::remote::GetLatestReq get_latest_request_from_query(const api::GetLatestQuery&); +::remote::GetLatestReq make_get_latest_req(const api::GetLatestRequest&); api::GetLatestResult get_latest_result_from_response(const ::remote::GetLatestReply&); -::remote::GetLatestReq get_as_of_request_from_query(const api::GetAsOfQuery&); +::remote::GetLatestReq make_get_as_of_req(const api::GetAsOfRequest&); api::GetAsOfResult get_as_of_result_from_response(const ::remote::GetLatestReply&); } // namespace silkworm::db::kv::grpc::client diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp b/silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp index cbf18fb197..debcd6a62c 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_point_test.cpp @@ -29,19 +29,19 @@ using namespace silkworm::db::kv::test_util; using namespace silkworm::test_util; namespace proto = ::remote; -TEST_CASE("history_get_request_from_query", "[node][remote][kv][grpc]") { - const Fixtures fixtures{ +TEST_CASE("make_history_seek_req", "[node][remote][kv][grpc]") { + const Fixtures fixtures{ {{}, {}}, - {sample_history_point_query(), sample_proto_history_seek_request()}, + {sample_history_point_request(), sample_proto_history_seek_request()}, }; - for (const auto& [query, expected_point_request] : fixtures) { - SECTION("query: " + std::to_string(query.tx_id)) { - const auto& point_request{history_seek_request_from_query(query)}; + for (const auto& [request, expected_req] : fixtures) { + SECTION("request: " + std::to_string(request.tx_id)) { + const auto& point_request{make_history_seek_req(request)}; // CHECK(point_request == expected_point_request); // requires operator== in gRPC - CHECK(point_request.tx_id() == expected_point_request.tx_id()); - CHECK(point_request.table() == expected_point_request.table()); - CHECK(point_request.k() == expected_point_request.k()); - CHECK(point_request.ts() == expected_point_request.ts()); + CHECK(point_request.tx_id() == expected_req.tx_id()); + CHECK(point_request.table() == expected_req.table()); + CHECK(point_request.k() == expected_req.k()); + CHECK(point_request.ts() == expected_req.ts()); } } } @@ -61,20 +61,20 @@ TEST_CASE("history_get_result_from_response", "[node][remote][kv][grpc]") { } } -TEST_CASE("get_as_of_request_from_query", "[node][remote][kv][grpc]") { - const Fixtures fixtures{ - {sample_get_as_of_query(), sample_proto_get_as_of_request()}, +TEST_CASE("make_get_as_of_req", "[node][remote][kv][grpc]") { + const Fixtures fixtures{ + {sample_get_as_of_request(), sample_proto_get_as_of_request()}, }; - for (const auto& [query, expected_point_request] : fixtures) { - SECTION("query: " + std::to_string(query.tx_id)) { - const auto& point_request{get_as_of_request_from_query(query)}; + for (const auto& [request, expected_req] : fixtures) { + SECTION("request: " + std::to_string(request.tx_id)) { + const auto& point_request{make_get_as_of_req(request)}; // CHECK(point_request == expected_point_request); // requires operator== in gRPC - CHECK(point_request.tx_id() == expected_point_request.tx_id()); - CHECK(point_request.table() == expected_point_request.table()); - CHECK(point_request.k() == expected_point_request.k()); - CHECK(point_request.ts() == expected_point_request.ts()); - CHECK(point_request.latest() == expected_point_request.latest()); - CHECK(point_request.k2() == expected_point_request.k2()); + CHECK(point_request.tx_id() == expected_req.tx_id()); + CHECK(point_request.table() == expected_req.table()); + CHECK(point_request.k() == expected_req.k()); + CHECK(point_request.ts() == expected_req.ts()); + CHECK(point_request.latest() == expected_req.latest()); + CHECK(point_request.k2() == expected_req.k2()); } } } diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp b/silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp index faf7db2b86..a1ec9769fc 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_range.cpp @@ -23,18 +23,18 @@ namespace silkworm::db::kv::grpc::client { namespace proto = ::remote; -proto::IndexRangeReq index_range_request_from_query(const api::IndexRangeQuery& query) { - proto::IndexRangeReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_k(query.key.data(), query.key.size()); - request.set_from_ts(query.from_timestamp); - request.set_to_ts(query.to_timestamp); - request.set_order_ascend(query.ascending_order); - request.set_limit(query.limit); - request.set_page_size(static_cast(query.page_size)); - request.set_page_token(query.page_token); - return request; +proto::IndexRangeReq make_index_range_req(const api::IndexRangeRequest& request) { + proto::IndexRangeReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_k(request.key.data(), request.key.size()); + req.set_from_ts(request.from_timestamp); + req.set_to_ts(request.to_timestamp); + req.set_order_ascend(request.ascending_order); + req.set_limit(request.limit); + req.set_page_size(static_cast(request.page_size)); + req.set_page_token(request.page_token); + return req; } api::IndexRangeResult index_range_result_from_response(const proto::IndexRangeReply& response) { @@ -46,17 +46,17 @@ api::IndexRangeResult index_range_result_from_response(const proto::IndexRangeRe return result; } -proto::HistoryRangeReq history_range_request_from_query(const api::HistoryRangeQuery& query) { - proto::HistoryRangeReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_from_ts(query.from_timestamp); - request.set_to_ts(query.to_timestamp); - request.set_order_ascend(query.ascending_order); - request.set_limit(static_cast(query.limit)); - request.set_page_size(static_cast(query.page_size)); - request.set_page_token(query.page_token); - return request; +proto::HistoryRangeReq make_history_range_req(const api::HistoryRangeRequest& request) { + proto::HistoryRangeReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_from_ts(request.from_timestamp); + req.set_to_ts(request.to_timestamp); + req.set_order_ascend(request.ascending_order); + req.set_limit(static_cast(request.limit)); + req.set_page_size(static_cast(request.page_size)); + req.set_page_token(request.page_token); + return req; } api::HistoryRangeResult history_range_result_from_response(const proto::Pairs& response) { @@ -71,22 +71,22 @@ api::HistoryRangeResult history_range_result_from_response(const proto::Pairs& r return result; } -::remote::RangeAsOfReq domain_range_request_from_query(const api::DomainRangeQuery& query) { - ::remote::RangeAsOfReq request; - request.set_tx_id(query.tx_id); - request.set_table(query.table); - request.set_from_key(query.from_key.data(), query.from_key.size()); - request.set_to_key(query.to_key.data(), query.to_key.size()); - if (query.timestamp) { - request.set_ts(static_cast(*query.timestamp)); +::remote::RangeAsOfReq make_domain_range_req(const api::DomainRangeRequest& request) { + ::remote::RangeAsOfReq req; + req.set_tx_id(request.tx_id); + req.set_table(request.table); + req.set_from_key(request.from_key.data(), request.from_key.size()); + req.set_to_key(request.to_key.data(), request.to_key.size()); + if (request.timestamp) { + req.set_ts(static_cast(*request.timestamp)); } else { - request.set_latest(true); + req.set_latest(true); } - request.set_order_ascend(query.ascending_order); - request.set_limit(static_cast(query.limit)); - request.set_page_size(static_cast(query.page_size)); - request.set_page_token(query.page_token); - return request; + req.set_order_ascend(request.ascending_order); + req.set_limit(static_cast(request.limit)); + req.set_page_size(static_cast(request.page_size)); + req.set_page_token(request.page_token); + return req; } api::DomainRangeResult domain_range_result_from_response(const ::remote::Pairs& response) { diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp b/silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp index e61cde214b..5747294509 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_range.hpp @@ -22,13 +22,13 @@ namespace silkworm::db::kv::grpc::client { -::remote::IndexRangeReq index_range_request_from_query(const api::IndexRangeQuery&); +::remote::IndexRangeReq make_index_range_req(const api::IndexRangeRequest&); api::IndexRangeResult index_range_result_from_response(const ::remote::IndexRangeReply&); -::remote::HistoryRangeReq history_range_request_from_query(const api::HistoryRangeQuery&); +::remote::HistoryRangeReq make_history_range_req(const api::HistoryRangeRequest&); api::HistoryRangeResult history_range_result_from_response(const ::remote::Pairs&); -::remote::RangeAsOfReq domain_range_request_from_query(const api::DomainRangeQuery&); +::remote::RangeAsOfReq make_domain_range_req(const api::DomainRangeRequest&); api::DomainRangeResult domain_range_result_from_response(const ::remote::Pairs&); } // namespace silkworm::db::kv::grpc::client diff --git a/silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp b/silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp index ee12ba693d..d5539abfe7 100644 --- a/silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp +++ b/silkworm/db/kv/grpc/client/endpoint/temporal_range_test.cpp @@ -29,24 +29,24 @@ using namespace silkworm::db::kv::test_util; using namespace silkworm::test_util; namespace proto = ::remote; -TEST_CASE("index_range_request_from_query", "[node][remote][kv][grpc]") { - const Fixtures fixtures{ +TEST_CASE("make_index_range_req", "[node][remote][kv][grpc]") { + const Fixtures fixtures{ {{}, default_proto_index_range_request()}, - {sample_index_range_query(), sample_proto_index_range_request()}, + {sample_index_range_request(), sample_proto_index_range_request()}, }; - for (const auto& [query, expected_range_request] : fixtures) { - SECTION("query: " + std::to_string(query.tx_id)) { - const auto& range_request{index_range_request_from_query(query)}; + for (const auto& [request, expected_req] : fixtures) { + SECTION("request: " + std::to_string(request.tx_id)) { + const auto& range_request{make_index_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC - CHECK(range_request.tx_id() == expected_range_request.tx_id()); - CHECK(range_request.table() == expected_range_request.table()); - CHECK(range_request.k() == expected_range_request.k()); - CHECK(range_request.from_ts() == expected_range_request.from_ts()); - CHECK(range_request.to_ts() == expected_range_request.to_ts()); - CHECK(range_request.order_ascend() == expected_range_request.order_ascend()); - CHECK(range_request.limit() == expected_range_request.limit()); - CHECK(range_request.page_size() == expected_range_request.page_size()); - CHECK(range_request.page_token() == expected_range_request.page_token()); + CHECK(range_request.tx_id() == expected_req.tx_id()); + CHECK(range_request.table() == expected_req.table()); + CHECK(range_request.k() == expected_req.k()); + CHECK(range_request.from_ts() == expected_req.from_ts()); + CHECK(range_request.to_ts() == expected_req.to_ts()); + CHECK(range_request.order_ascend() == expected_req.order_ascend()); + CHECK(range_request.limit() == expected_req.limit()); + CHECK(range_request.page_size() == expected_req.page_size()); + CHECK(range_request.page_token() == expected_req.page_token()); } } } @@ -57,7 +57,7 @@ TEST_CASE("index_range_result_from_response", "[node][remote][kv][grpc]") { {sample_proto_index_range_response(), sample_index_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { - SECTION("query: " + response.next_page_token()) { + SECTION("response: " + response.next_page_token()) { const auto& range_result{index_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.timestamps == expected_range_result.timestamps); @@ -66,23 +66,23 @@ TEST_CASE("index_range_result_from_response", "[node][remote][kv][grpc]") { } } -TEST_CASE("history_range_request_from_query", "[node][remote][kv][grpc]") { - const Fixtures fixtures{ +TEST_CASE("make_history_range_req", "[node][remote][kv][grpc]") { + const Fixtures fixtures{ {{}, default_proto_history_range_request()}, - {sample_history_range_query(), sample_proto_history_range_request()}, + {sample_history_range_request(), sample_proto_history_range_request()}, }; - for (const auto& [query, expected_range_request] : fixtures) { - SECTION("query: " + std::to_string(query.tx_id)) { - const auto& range_request{history_range_request_from_query(query)}; + for (const auto& [request, expected_req] : fixtures) { + SECTION("request: " + std::to_string(request.tx_id)) { + const auto& range_request{make_history_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC - CHECK(range_request.tx_id() == expected_range_request.tx_id()); - CHECK(range_request.table() == expected_range_request.table()); - CHECK(range_request.from_ts() == expected_range_request.from_ts()); - CHECK(range_request.to_ts() == expected_range_request.to_ts()); - CHECK(range_request.order_ascend() == expected_range_request.order_ascend()); - CHECK(range_request.limit() == expected_range_request.limit()); - CHECK(range_request.page_size() == expected_range_request.page_size()); - CHECK(range_request.page_token() == expected_range_request.page_token()); + CHECK(range_request.tx_id() == expected_req.tx_id()); + CHECK(range_request.table() == expected_req.table()); + CHECK(range_request.from_ts() == expected_req.from_ts()); + CHECK(range_request.to_ts() == expected_req.to_ts()); + CHECK(range_request.order_ascend() == expected_req.order_ascend()); + CHECK(range_request.limit() == expected_req.limit()); + CHECK(range_request.page_size() == expected_req.page_size()); + CHECK(range_request.page_token() == expected_req.page_token()); } } } @@ -93,7 +93,7 @@ TEST_CASE("history_range_result_from_response", "[node][remote][kv][grpc]") { {sample_proto_history_range_response(), sample_history_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { - SECTION("query: " + response.next_page_token()) { + SECTION("response: " + response.next_page_token()) { const auto& range_result{history_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.keys == expected_range_result.keys); @@ -103,24 +103,24 @@ TEST_CASE("history_range_result_from_response", "[node][remote][kv][grpc]") { } } -TEST_CASE("domain_range_request_from_query", "[node][remote][kv][grpc]") { - const Fixtures fixtures{ +TEST_CASE("make_domain_range_req", "[node][remote][kv][grpc]") { + const Fixtures fixtures{ {{}, default_proto_domain_range_request()}, - {sample_domain_range_query(), sample_proto_domain_range_request()}, + {sample_domain_range_request(), sample_proto_domain_range_request()}, }; - for (const auto& [query, expected_range_request] : fixtures) { - SECTION("query: " + std::to_string(query.tx_id)) { - const auto& range_request{domain_range_request_from_query(query)}; + for (const auto& [request, expected_req] : fixtures) { + SECTION("request: " + std::to_string(request.tx_id)) { + const auto& range_request{make_domain_range_req(request)}; // CHECK(range_request == expected_range_request); // requires operator== in gRPC - CHECK(range_request.tx_id() == expected_range_request.tx_id()); - CHECK(range_request.table() == expected_range_request.table()); - CHECK(range_request.from_key() == expected_range_request.from_key()); - CHECK(range_request.to_key() == expected_range_request.to_key()); - CHECK(range_request.ts() == expected_range_request.ts()); - CHECK(range_request.order_ascend() == expected_range_request.order_ascend()); - CHECK(range_request.limit() == expected_range_request.limit()); - CHECK(range_request.page_size() == expected_range_request.page_size()); - CHECK(range_request.page_token() == expected_range_request.page_token()); + CHECK(range_request.tx_id() == expected_req.tx_id()); + CHECK(range_request.table() == expected_req.table()); + CHECK(range_request.from_key() == expected_req.from_key()); + CHECK(range_request.to_key() == expected_req.to_key()); + CHECK(range_request.ts() == expected_req.ts()); + CHECK(range_request.order_ascend() == expected_req.order_ascend()); + CHECK(range_request.limit() == expected_req.limit()); + CHECK(range_request.page_size() == expected_req.page_size()); + CHECK(range_request.page_token() == expected_req.page_token()); } } } @@ -131,7 +131,7 @@ TEST_CASE("domain_range_result_from_response", "[node][remote][kv][grpc]") { {sample_proto_domain_range_response(), sample_domain_range_result()}, }; for (const auto& [response, expected_range_result] : fixtures) { - SECTION("query: " + response.next_page_token()) { + SECTION("response: " + response.next_page_token()) { const auto& range_result{domain_range_result_from_response(response)}; // CHECK(range_result == expected_range_result); // requires operator== in gRPC CHECK(range_result.keys == expected_range_result.keys); diff --git a/silkworm/db/kv/grpc/client/remote_transaction.cpp b/silkworm/db/kv/grpc/client/remote_transaction.cpp index e4b5f4da14..64c1edb1fa 100644 --- a/silkworm/db/kv/grpc/client/remote_transaction.cpp +++ b/silkworm/db/kv/grpc/client/remote_transaction.cpp @@ -117,11 +117,11 @@ Task RemoteTransaction::first_txn_num_in_block(BlockNum block_num) { co_return min_txn_num + /*txn_index*/ 0; } -Task RemoteTransaction::get_latest(api::GetLatestQuery query) { +Task RemoteTransaction::get_latest(api::GetLatestRequest request) { try { - query.tx_id = tx_id_; - auto request = get_latest_request_from_query(query); - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(request), grpc_context_); + request.tx_id = tx_id_; + auto req = make_get_latest_req(request); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(req), grpc_context_); auto result = get_latest_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { @@ -130,11 +130,11 @@ Task RemoteTransaction::get_latest(api::GetLatestQuery que } } -Task RemoteTransaction::get_as_of(api::GetAsOfQuery query) { +Task RemoteTransaction::get_as_of(api::GetAsOfRequest request) { try { - query.tx_id = tx_id_; - auto request = get_as_of_request_from_query(query); - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(request), grpc_context_); + request.tx_id = tx_id_; + auto req = make_get_as_of_req(request); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncGetLatest, stub_, std::move(req), grpc_context_); auto result = get_as_of_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { @@ -143,11 +143,11 @@ Task RemoteTransaction::get_as_of(api::GetAsOfQuery query) { } } -Task RemoteTransaction::history_seek(api::HistoryPointQuery query) { +Task RemoteTransaction::history_seek(api::HistoryPointRequest request) { try { - query.tx_id = tx_id_; - auto request = history_seek_request_from_query(query); - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistorySeek, stub_, std::move(request), grpc_context_); + request.tx_id = tx_id_; + auto req = make_history_seek_req(request); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistorySeek, stub_, std::move(req), grpc_context_); auto result = history_seek_result_from_response(reply); co_return result; } catch (rpc::GrpcStatusError& gse) { @@ -156,13 +156,13 @@ Task RemoteTransaction::history_seek(api::HistoryPointQ } } -Task RemoteTransaction::index_range(api::IndexRangeQuery query) { - auto paginator = [&, query = std::move(query)](api::PaginatedTimestamps::PageToken page_token) mutable -> Task { - query.tx_id = tx_id_; - query.page_token = std::move(page_token); - auto request = index_range_request_from_query(query); +Task RemoteTransaction::index_range(api::IndexRangeRequest request) { + auto paginator = [&, request = std::move(request)](api::PaginatedTimestamps::PageToken page_token) mutable -> Task { + request.tx_id = tx_id_; + request.page_token = std::move(page_token); + auto req = make_index_range_req(request); try { - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncIndexRange, stub_, std::move(request), grpc_context_); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncIndexRange, stub_, std::move(req), grpc_context_); auto result = index_range_result_from_response(reply); co_return api::PaginatedTimestamps::PageResult{std::move(result.timestamps), std::move(result.next_page_token)}; @@ -174,13 +174,13 @@ Task RemoteTransaction::index_range(api::IndexRangeQue co_return api::PaginatedTimestamps{std::move(paginator)}; } -Task RemoteTransaction::history_range(api::HistoryRangeQuery query) { - auto paginator = [&, query = std::move(query)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { - query.tx_id = tx_id_; - query.page_token = std::move(page_token); - auto request = history_range_request_from_query(query); +Task RemoteTransaction::history_range(api::HistoryRangeRequest request) { + auto paginator = [&, request = std::move(request)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { + request.tx_id = tx_id_; + request.page_token = std::move(page_token); + auto req = make_history_range_req(request); try { - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistoryRange, stub_, std::move(request), grpc_context_); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncHistoryRange, stub_, std::move(req), grpc_context_); auto result = history_range_result_from_response(reply); co_return api::PaginatedKeysValues::PageResult{std::move(result.keys), std::move(result.values), std::move(result.next_page_token)}; @@ -192,13 +192,13 @@ Task RemoteTransaction::history_range(api::HistoryRang co_return api::PaginatedKeysValues{std::move(paginator)}; } -Task RemoteTransaction::range_as_of(api::DomainRangeQuery query) { - auto paginator = [&, query = std::move(query)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { - query.tx_id = tx_id_; - query.page_token = std::move(page_token); - auto request = domain_range_request_from_query(query); +Task RemoteTransaction::range_as_of(api::DomainRangeRequest request) { + auto paginator = [&, request = std::move(request)](api::PaginatedKeysValues::PageToken page_token) mutable -> Task { + request.tx_id = tx_id_; + request.page_token = std::move(page_token); + auto req = make_domain_range_req(request); try { - const auto reply = co_await rpc::unary_rpc(&Stub::AsyncRangeAsOf, stub_, std::move(request), grpc_context_); + const auto reply = co_await rpc::unary_rpc(&Stub::AsyncRangeAsOf, stub_, std::move(req), grpc_context_); auto result = history_range_result_from_response(reply); co_return api::PaginatedKeysValues::PageResult{std::move(result.keys), std::move(result.values), std::move(result.next_page_token)}; diff --git a/silkworm/db/kv/grpc/client/remote_transaction.hpp b/silkworm/db/kv/grpc/client/remote_transaction.hpp index dcd9bbc897..6f7947937e 100644 --- a/silkworm/db/kv/grpc/client/remote_transaction.hpp +++ b/silkworm/db/kv/grpc/client/remote_transaction.hpp @@ -61,22 +61,22 @@ class RemoteTransaction : public api::BaseTransaction { Task close() override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=true (ts ignored) - Task get_latest(api::GetLatestQuery query) override; + Task get_latest(api::GetLatestRequest request) override; // rpc GetLatest(GetLatestReq) returns (GetLatestReply); w/ latest=false (ts used) - Task get_as_of(api::GetAsOfQuery query) override; + Task get_as_of(api::GetAsOfRequest request) override; // rpc HistorySeek(HistorySeekReq) returns (HistorySeekReply); - Task history_seek(api::HistoryPointQuery query) override; + Task history_seek(api::HistoryPointRequest request) override; // rpc IndexRange(IndexRangeReq) returns (IndexRangeReply); - Task index_range(api::IndexRangeQuery query) override; + Task index_range(api::IndexRangeRequest request) override; // rpc HistoryRange(HistoryRangeReq) returns (Pairs); - Task history_range(api::HistoryRangeQuery query) override; + Task history_range(api::HistoryRangeRequest request) override; // rpc RangeAsOf(RangeAsOfReq) returns (Pairs); - Task range_as_of(api::DomainRangeQuery query) override; + Task range_as_of(api::DomainRangeRequest request) override; private: Task> get_cursor(const std::string& table, bool is_cursor_dup_sort); diff --git a/silkworm/db/kv/grpc/client/remote_transaction_test.cpp b/silkworm/db/kv/grpc/client/remote_transaction_test.cpp index d1c0d53603..423f2ef06b 100644 --- a/silkworm/db/kv/grpc/client/remote_transaction_test.cpp +++ b/silkworm/db/kv/grpc/client/remote_transaction_test.cpp @@ -433,13 +433,13 @@ TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::get_latest", "[db][k auto get_latest = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::GetLatestQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::GetLatestRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::GetLatestQuery query; - const api::GetLatestResult result = co_await remote_tx_.get_latest(std::move(query)); + api::GetLatestRequest request; + const api::GetLatestResult result = co_await remote_tx_.get_latest(std::move(request)); #else - const api::GetLatestResult result = co_await remote_tx_.get_latest(api::GetLatestQuery{}); + const api::GetLatestResult result = co_await remote_tx_.get_latest(api::GetLatestRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; @@ -476,13 +476,13 @@ TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::get_as_of", "[db][kv auto get_as_of = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::GetLatestQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::GetAsOfRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::GetAsOfQuery query; - const api::GetAsOfResult result = co_await remote_tx_.get_as_of(std::move(query)); + api::GetAsOfRequest request; + const api::GetAsOfResult result = co_await remote_tx_.get_as_of(std::move(request)); #else - const api::GetAsOfResult result = co_await remote_tx_.get_as_of(api::GetAsOfQuery{}); + const api::GetAsOfResult result = co_await remote_tx_.get_as_of(api::GetAsOfRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; @@ -519,13 +519,13 @@ TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::history_seek", "[db] auto history_seek = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::HistoryPointQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::HistoryPointRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::HistoryPointQuery query; - const api::HistoryPointResult result = co_await remote_tx_.history_seek(std::move(query)); + api::HistoryPointRequest request; + const api::HistoryPointResult result = co_await remote_tx_.history_seek(std::move(request)); #else - const api::HistoryPointResult result = co_await remote_tx_.history_seek(api::HistoryPointQuery{}); + const api::HistoryPointResult result = co_await remote_tx_.history_seek(api::HistoryPointRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return result; }; @@ -569,13 +569,13 @@ static ::remote::IndexRangeReply make_index_range_reply(const api::ListOfTimesta TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::index_range", "[db][kv][grpc][client][remote_transaction]") { auto flatten_index_range = [&]() -> Task { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::IndexRangeQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::IndexRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::IndexRangeQuery query; - auto paginated_timestamps = co_await remote_tx_.index_range(std::move(query)); + api::IndexRangeRequest request; + auto paginated_timestamps = co_await remote_tx_.index_range(std::move(request)); #else - auto paginated_timestamps = co_await remote_tx_.index_range(api::IndexRangeQuery{}); + auto paginated_timestamps = co_await remote_tx_.index_range(api::IndexRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await paginated_to_vector(paginated_timestamps); }; @@ -663,13 +663,13 @@ TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::history_range", "[db auto flatten_history_range = [&]() -> Task> { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::HistoryRangeQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::HistoryRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::HistoryRangeQuery query; - auto paginated_keys_and_values = co_await remote_tx_.history_range(std::move(query)); + api::HistoryRangeRequest request; + auto paginated_keys_and_values = co_await remote_tx_.history_range(std::move(request)); #else - auto paginated_keys_and_values = co_await remote_tx_.history_range(api::HistoryRangeQuery{}); + auto paginated_keys_and_values = co_await remote_tx_.history_range(api::HistoryRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await paginated_to_vector(paginated_keys_and_values); }; @@ -747,13 +747,13 @@ TEST_CASE_METHOD(RemoteTransactionTest, "RemoteTransaction::range_as_of", "[db][ auto flatten_domain_range = [&]() -> Task> { #if __GNUC__ < 13 && !defined(__clang__) // Clang compiler defines __GNUC__ as well - // Before GCC 13, we must avoid passing api::DomainRangeQuery as temporary because co_await-ing expressions + // Before GCC 13, we must avoid passing api::DomainRangeRequest as temporary because co_await-ing expressions // that involve compiler-generated constructors binding references to pr-values seems to trigger this bug: // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100611 - api::DomainRangeQuery query; - auto paginated_keys_and_values = co_await remote_tx_.range_as_of(std::move(query)); + api::DomainRangeRequest request; + auto paginated_keys_and_values = co_await remote_tx_.range_as_of(std::move(request)); #else - auto paginated_keys_and_values = co_await remote_tx_.range_as_of(api::DomainRangeQuery{}); + auto paginated_keys_and_values = co_await remote_tx_.range_as_of(api::DomainRangeRequest{}); #endif // #if __GNUC__ < 13 && !defined(__clang__) co_return co_await paginated_to_vector(paginated_keys_and_values); }; diff --git a/silkworm/db/kv/grpc/test_util/sample_protos.hpp b/silkworm/db/kv/grpc/test_util/sample_protos.hpp index 2c764c26f5..0f96561df3 100644 --- a/silkworm/db/kv/grpc/test_util/sample_protos.hpp +++ b/silkworm/db/kv/grpc/test_util/sample_protos.hpp @@ -33,7 +33,7 @@ namespace silkworm::db::kv::test_util { namespace proto = ::remote; using silkworm::test_util::ascii_from_hex; -inline api::HistoryPointQuery sample_history_point_query() { +inline api::HistoryPointRequest sample_history_point_request() { return { .tx_id = 1, .table = "AAA", @@ -65,7 +65,7 @@ inline api::HistoryPointResult sample_history_point_result() { }; } -inline api::GetAsOfQuery sample_get_latest_query() { +inline api::GetAsOfRequest sample_get_latest_request() { return { .tx_id = 1, .table = "AAA", @@ -74,7 +74,7 @@ inline api::GetAsOfQuery sample_get_latest_query() { }; } -inline api::GetAsOfQuery sample_get_as_of_query() { +inline api::GetAsOfRequest sample_get_as_of_request() { return { .tx_id = 1, .table = "AAA", @@ -132,7 +132,7 @@ inline api::GetAsOfResult sample_get_as_of_result() { }; } -inline api::IndexRangeQuery sample_index_range_query() { +inline api::IndexRangeRequest sample_index_range_request() { return { .tx_id = 1, .table = "AAA", @@ -181,7 +181,7 @@ inline api::IndexRangeResult sample_index_range_result() { }; } -inline api::HistoryRangeQuery sample_history_range_query() { +inline api::HistoryRangeRequest sample_history_range_request() { return { .tx_id = 1, .table = "AAA", @@ -231,7 +231,7 @@ inline api::HistoryRangeResult sample_history_range_result() { }; } -inline api::DomainRangeQuery sample_domain_range_query() { +inline api::DomainRangeRequest sample_domain_range_request() { return { .tx_id = 1, .table = "AAA", diff --git a/silkworm/db/kv/state_reader.cpp b/silkworm/db/kv/state_reader.cpp index d1eed5d929..e4c0fdd935 100644 --- a/silkworm/db/kv/state_reader.cpp +++ b/silkworm/db/kv/state_reader.cpp @@ -35,17 +35,17 @@ Task> StateReader::read_account(const evmc::address& addr api::PointResult result; if (!txn_number_) { - db::kv::api::GetLatestQuery query{ + db::kv::api::GetLatestRequest request{ .table = table::kAccountDomain, .key = db::account_domain_key(address)}; - result = co_await tx_.get_latest(std::move(query)); + result = co_await tx_.get_latest(std::move(request)); } else { - db::kv::api::GetAsOfQuery query{ + db::kv::api::GetAsOfRequest request{ .table = table::kAccountDomain, .key = db::account_domain_key(address), .timestamp = static_cast(*txn_number_), }; - result = co_await tx_.get_as_of(std::move(query)); + result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { @@ -68,17 +68,17 @@ Task StateReader::read_storage(const evmc::address& address, api::PointResult result; if (!txn_number_) { - db::kv::api::GetLatestQuery query{ + db::kv::api::GetLatestRequest request{ .table = table::kStorageDomain, .key = db::storage_domain_key(address, location_hash)}; - result = co_await tx_.get_latest(std::move(query)); + result = co_await tx_.get_latest(std::move(request)); } else { - db::kv::api::GetAsOfQuery query{ + db::kv::api::GetAsOfRequest request{ .table = table::kStorageDomain, .key = db::storage_domain_key(address, location_hash), .timestamp = static_cast(*txn_number_), }; - result = co_await tx_.get_as_of(std::move(query)); + result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { @@ -95,17 +95,17 @@ Task> StateReader::read_code(const evmc::address& address, api::PointResult result; if (!txn_number_) { - db::kv::api::GetLatestQuery query{ + db::kv::api::GetLatestRequest request{ .table = table::kCodeDomain, .key = db::code_domain_key(address)}; - result = co_await tx_.get_latest(std::move(query)); + result = co_await tx_.get_latest(std::move(request)); } else { - db::kv::api::GetAsOfQuery query{ + db::kv::api::GetAsOfRequest request{ .table = table::kCodeDomain, .key = db::code_domain_key(address), .timestamp = static_cast(*txn_number_), }; - result = co_await tx_.get_as_of(std::move(query)); + result = co_await tx_.get_as_of(std::move(request)); } if (!result.success) { diff --git a/silkworm/db/test_util/mock_transaction.hpp b/silkworm/db/test_util/mock_transaction.hpp index ffbcf93c54..2cfb57f9a4 100644 --- a/silkworm/db/test_util/mock_transaction.hpp +++ b/silkworm/db/test_util/mock_transaction.hpp @@ -46,12 +46,12 @@ class MockTransaction : public kv::api::Transaction { MOCK_METHOD((Task), get_one, (const std::string&, ByteView), (override)); MOCK_METHOD((Task>), get_both_range, (const std::string&, ByteView, ByteView), (override)); - MOCK_METHOD((Task), get_latest, (kv::api::GetLatestQuery), (override)); - MOCK_METHOD((Task), get_as_of, (kv::api::GetAsOfQuery), (override)); - MOCK_METHOD((Task), history_seek, (kv::api::HistoryPointQuery), (override)); - MOCK_METHOD((Task), index_range, (kv::api::IndexRangeQuery), (override)); - MOCK_METHOD((Task), history_range, (kv::api::HistoryRangeQuery), (override)); - MOCK_METHOD((Task), range_as_of, (kv::api::DomainRangeQuery), (override)); + MOCK_METHOD((Task), get_latest, (kv::api::GetLatestRequest), (override)); + MOCK_METHOD((Task), get_as_of, (kv::api::GetAsOfRequest), (override)); + MOCK_METHOD((Task), history_seek, (kv::api::HistoryPointRequest), (override)); + MOCK_METHOD((Task), index_range, (kv::api::IndexRangeRequest), (override)); + MOCK_METHOD((Task), history_range, (kv::api::HistoryRangeRequest), (override)); + MOCK_METHOD((Task), range_as_of, (kv::api::DomainRangeRequest), (override)); }; } // namespace silkworm::db::test_util diff --git a/silkworm/rpc/commands/debug_api.cpp b/silkworm/rpc/commands/debug_api.cpp index 227d610e54..4167926cd8 100644 --- a/silkworm/rpc/commands/debug_api.cpp +++ b/silkworm/rpc/commands/debug_api.cpp @@ -323,7 +323,7 @@ Task DebugRpcApi::handle_debug_account_at(const nlohmann::json& request, n SILK_TRACE << "Block number: " << block_num << " #tnx: " << transactions.size(); const auto min_tx_num = co_await tx->first_txn_num_in_block(block_with_hash->block.header.number); - db::kv::api::GetAsOfQuery query_account{ + db::kv::api::GetAsOfRequest query_account{ .table = db::table::kAccountDomain, .key = db::account_domain_key(address), .timestamp = static_cast(min_tx_num + tx_index + 1), @@ -348,7 +348,7 @@ Task DebugRpcApi::handle_debug_account_at(const nlohmann::json& request, n json_result["balance"] = "0x" + intx::to_string(account->balance, 16); json_result["codeHash"] = account->code_hash; - db::kv::api::GetAsOfQuery query_code{ + db::kv::api::GetAsOfRequest query_code{ .table = db::table::kCodeDomain, .key = db::account_domain_key(address), .timestamp = static_cast(min_tx_num + tx_index), @@ -658,7 +658,7 @@ Task> get_modified_accounts(db::kv::api::Transaction& tx const auto start_txn_number = co_await tx.first_txn_num_in_block(start_block_num); const auto end_txn_number = co_await tx.first_txn_num_in_block(end_block_num == start_block_num ? end_block_num + 1 : end_block_num) - 1; - db::kv::api::HistoryRangeQuery query{ + db::kv::api::HistoryRangeRequest query{ .table = db::table::kAccountDomain, .from_timestamp = static_cast(start_txn_number), .to_timestamp = static_cast(end_txn_number), diff --git a/silkworm/rpc/commands/debug_api_test.cpp b/silkworm/rpc/commands/debug_api_test.cpp index da6c1a34f7..11de949c41 100644 --- a/silkworm/rpc/commands/debug_api_test.cpp +++ b/silkworm/rpc/commands/debug_api_test.cpp @@ -163,12 +163,12 @@ TEST_CASE("get_modified_accounts") { .WillOnce(InvokeWithoutArgs([]() -> Task { co_return 20; })); - db::kv::api::HistoryRangeQuery query{ + db::kv::api::HistoryRangeRequest request{ .table = db::table::kAccountDomain, .from_timestamp = static_cast(0), .to_timestamp = static_cast(19), .ascending_order = true}; - EXPECT_CALL(transaction, history_range(std::move(query))).WillOnce(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, history_range(std::move(request))).WillOnce(Invoke([=](Unused) -> Task { PaginatorKV paginator = [](auto next_page_token) -> Task { co_return PageResultKV{ .keys = {*from_hex("07aaec0b237ccf56b03a7c43c1c7a783da5606420501010101")}, diff --git a/silkworm/rpc/commands/ots_api.cpp b/silkworm/rpc/commands/ots_api.cpp index dc4f9f0d91..cc2e1f2eaa 100644 --- a/silkworm/rpc/commands/ots_api.cpp +++ b/silkworm/rpc/commands/ots_api.cpp @@ -295,7 +295,7 @@ Task OtsRpcApi::handle_ots_get_transaction_by_sender_and_nonce(const nlohm try { auto key = db::code_domain_key(sender); - db::kv::api::IndexRangeQuery query{ + db::kv::api::IndexRangeRequest query{ .table = db::table::kAccountsHistoryIdx, .key = key, .from_timestamp = -1, @@ -315,7 +315,7 @@ Task OtsRpcApi::handle_ots_get_transaction_by_sender_and_nonce(const nlohm continue; } SILK_DEBUG << "count: " << count << ", txnId: " << txn_id; - db::kv::api::HistoryPointQuery hpq{ + db::kv::api::HistoryPointRequest hpq{ .table = db::table::kAccountDomain, .key = key, .timestamp = *value}; @@ -350,7 +350,7 @@ Task OtsRpcApi::handle_ots_get_transaction_by_sender_and_nonce(const nlohm auto txn_id = i + prev_txn_id; SILK_DEBUG << "searching for txnId: " << txn_id << ", i: " << i; - db::kv::api::HistoryPointQuery hpq{ + db::kv::api::HistoryPointRequest hpq{ .table = db::table::kAccountDomain, .key = key, .timestamp = static_cast(txn_id)}; @@ -457,7 +457,7 @@ Task OtsRpcApi::handle_ots_get_contract_creator(const nlohmann::json& requ // Navigate forward on history index of accounts and probe history periodically (cheaper than traversing history) // so as a result we'll have small range of blocks for binary search or full scan. const auto key = db::code_domain_key(contract_address); - db::kv::api::IndexRangeQuery query{ + db::kv::api::IndexRangeRequest query{ .table = db::table::kAccountsHistoryIdx, .key = key, .from_timestamp = 0, @@ -477,7 +477,7 @@ Task OtsRpcApi::handle_ots_get_contract_creator(const nlohmann::json& requ } SILK_DEBUG << "txn_id:" << txn_id << ", count: " << count; - db::kv::api::HistoryPointQuery hpq{ + db::kv::api::HistoryPointRequest hpq{ .table = db::table::kAccountDomain, .key = key, .timestamp = *value}; @@ -510,7 +510,7 @@ Task OtsRpcApi::handle_ots_get_contract_creator(const nlohmann::json& requ auto index = co_await async_binary_search(static_cast(next_txn_id - prev_txn_id), [&](size_t i) -> Task { auto txn_id = i + prev_txn_id; - db::kv::api::HistoryPointQuery hpq{ + db::kv::api::HistoryPointRequest hpq{ .table = db::table::kAccountDomain, .key = key, .timestamp = static_cast(txn_id)}; @@ -845,7 +845,7 @@ Task OtsRpcApi::collect_transactions_with_receipts( db::kv::api::Timestamp from_timestamp, bool ascending, uint64_t page_size) { const auto key = db::code_domain_key(address); - db::kv::api::IndexRangeQuery query_to{ + db::kv::api::IndexRangeRequest query_to{ .table = db::table::kTracesToIdx, .key = key, .from_timestamp = from_timestamp, @@ -853,7 +853,7 @@ Task OtsRpcApi::collect_transactions_with_receipts( .ascending_order = ascending}; auto paginated_result_to = co_await tx.index_range(std::move(query_to)); - db::kv::api::IndexRangeQuery query_from{ + db::kv::api::IndexRangeRequest query_from{ .table = db::table::kTracesFromIdx, .key = key, .from_timestamp = from_timestamp, diff --git a/silkworm/rpc/commands/parity_api.cpp b/silkworm/rpc/commands/parity_api.cpp index cf0719e3a6..aff8aee9e0 100644 --- a/silkworm/rpc/commands/parity_api.cpp +++ b/silkworm/rpc/commands/parity_api.cpp @@ -86,7 +86,7 @@ Task ParityRpcApi::handle_parity_list_storage_keys(const nlohmann::json& r increment(to); SILK_DEBUG << "handle_parity_list_storage_keys: from " << from << ", to " << to; - db::kv::api::DomainRangeQuery query{ + db::kv::api::DomainRangeRequest query{ .table = db::table::kStorageDomain, .from_key = from, .to_key = to, diff --git a/silkworm/rpc/core/account_dumper.cpp b/silkworm/rpc/core/account_dumper.cpp index 022220d52e..23176d9658 100644 --- a/silkworm/rpc/core/account_dumper.cpp +++ b/silkworm/rpc/core/account_dumper.cpp @@ -57,7 +57,7 @@ Task AccountDumper::dump_accounts( const auto block_num = block_with_hash->block.header.number + 1; const auto start_txn_number = co_await transaction_.first_txn_num_in_block(block_num); - db::kv::api::DomainRangeQuery query{ + db::kv::api::DomainRangeRequest query{ .table = db::table::kAccountDomain, .from_key = key, .timestamp = start_txn_number, @@ -89,7 +89,7 @@ Task AccountDumper::dump_accounts( dump_account.root = kZeroHash; if (account->code_hash != kZeroHash && !exclude_code) { - db::kv::api::GetLatestQuery query_code{ + db::kv::api::GetLatestRequest query_code{ .table = db::table::kCodeDomain, .key = db::account_domain_key(address)}; @@ -116,7 +116,7 @@ Task AccountDumper::load_storage(BlockNum block_num, DumpAccounts& dump_ac auto to = db::code_domain_key(address); increment(to); - db::kv::api::DomainRangeQuery query{ + db::kv::api::DomainRangeRequest query{ .table = db::table::kStorageDomain, .from_key = db::code_domain_key(address), .to_key = to, diff --git a/silkworm/rpc/core/account_dumper_test.cpp b/silkworm/rpc/core/account_dumper_test.cpp index eac68fb15f..1b1b1c5a38 100644 --- a/silkworm/rpc/core/account_dumper_test.cpp +++ b/silkworm/rpc/core/account_dumper_test.cpp @@ -206,27 +206,27 @@ class DummyTransaction : public BaseTransaction { co_return; } - Task get_latest(db::kv::api::GetLatestQuery /*query*/) override { + Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } - Task get_as_of(db::kv::api::GetAsOfQuery /*query*/) override { + Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } - Task history_seek(db::kv::api::HistoryPointQuery /*query*/) override { + Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } - Task index_range(db::kv::api::IndexRangeQuery /*query*/) override { + Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return test::empty_paginated_timestamps(); } - Task history_range(db::kv::api::HistoryRangeQuery /*query*/) override { + Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return test::empty_paginated_keys_and_values(); } - Task range_as_of(db::kv::api::DomainRangeQuery /*query*/) override { + Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return test::empty_paginated_keys_and_values(); } diff --git a/silkworm/rpc/core/block_reader.cpp b/silkworm/rpc/core/block_reader.cpp index 13d75a3cc8..59ab2742a1 100644 --- a/silkworm/rpc/core/block_reader.cpp +++ b/silkworm/rpc/core/block_reader.cpp @@ -65,7 +65,7 @@ Task BlockReader::read_balance_changes(BlockCache& cache, const BlockNumOr } StateReader state_reader{transaction_, txn_id}; - db::kv::api::HistoryRangeQuery query{ + db::kv::api::HistoryRangeRequest query{ .table = db::table::kAccountDomain, .from_timestamp = static_cast(start_txn_number), .to_timestamp = static_cast(end_txn_number), diff --git a/silkworm/rpc/core/evm_debug_test.cpp b/silkworm/rpc/core/evm_debug_test.cpp index 8ffb28f989..57ea8813f1 100644 --- a/silkworm/rpc/core/evm_debug_test.cpp +++ b/silkworm/rpc/core/evm_debug_test.cpp @@ -85,17 +85,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute precompiled") { static Bytes account_history_value1{*silkworm::from_hex("010203ed03e820f1885eda54b7a053318cd41e2093220dab15d65381b1157a3633a83bfd5c92390105")}; SECTION("precompiled contract failure") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -216,17 +216,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call: full output") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -348,17 +348,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call: no stack") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -467,17 +467,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call: no memory") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -591,17 +591,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call: no storage") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -719,17 +719,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call: no stack, memory and storage") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -826,17 +826,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 1") { } SECTION("Call with stream") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -944,17 +944,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call 2") { static Bytes account_history_value3{*silkworm::from_hex("00094165832d46fa1082db0000")}; SECTION("Call: TO present") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -1032,17 +1032,17 @@ TEST_CASE_METHOD(DebugExecutorTest, "DebugExecutor::execute call with error") { static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, diff --git a/silkworm/rpc/core/evm_trace_test.cpp b/silkworm/rpc/core/evm_trace_test.cpp index 15ec94d909..583b2e19fe 100644 --- a/silkworm/rpc/core/evm_trace_test.cpp +++ b/silkworm/rpc/core/evm_trace_test.cpp @@ -68,17 +68,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call precompil static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; SECTION("precompiled contract failure") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -207,17 +207,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { } SECTION("Call: full output") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -396,17 +396,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { } SECTION("Call: no vmTrace") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -522,17 +522,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { } SECTION("Call: no trace") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -694,17 +694,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { } SECTION("Call: no stateDiff") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -844,17 +844,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 1") { } SECTION("Call: no vmTrace, trace and stateDiff") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -924,17 +924,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call 2") { static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; SECTION("Call: TO present") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -1067,17 +1067,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_call with erro static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("000944ed67f28fd50bb8e90000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -1256,17 +1256,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_calls") { } SECTION("Call: full output") { - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -1459,17 +1459,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_block_transact static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("0008028ded68c33d14010000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -1909,17 +1909,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_block") { static Bytes account_history_key3{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value3{*silkworm::from_hex("0127080334e1d62a9e34400000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -2016,17 +2016,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransact static Bytes account_history_key3{*silkworm::from_hex("0000000000000000000000000000000000000000")}; static Bytes account_history_value3{*silkworm::from_hex("0008028ded68c33d14010000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, @@ -2070,19 +2070,19 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransact EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).WillOnce(Invoke([]() -> Task { co_return 244087591818873; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; @@ -2408,19 +2408,19 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransact EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; @@ -2460,19 +2460,19 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransact EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; @@ -2535,19 +2535,19 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_replayTransact EXPECT_CALL(transaction, first_txn_num_in_block(1'024'165)).Times(1).WillRepeatedly(Invoke([]() -> Task { co_return 244087591818873; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query1})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value1}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query2})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = false, .value = Bytes{}}; co_return response; })); - EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfQuery{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { + EXPECT_CALL(transaction, get_as_of(silkworm::db::kv::api::GetAsOfRequest{query3})).WillRepeatedly(Invoke([=](Unused) -> Task { db::kv::api::GetAsOfResult response{ .success = true, .value = account_history_value3}; @@ -2936,17 +2936,17 @@ TEST_CASE_METHOD(TraceCallExecutorTest, "TraceCallExecutor::trace_transaction") static Bytes account_history_key3{*silkworm::from_hex("daae090d53f9ed9e2e1fd25258c01bac4dd6d1c5")}; static Bytes account_history_value3{*silkworm::from_hex("0127080334e1d62a9e34400000")}; - db::kv::api::GetAsOfQuery query1{ + db::kv::api::GetAsOfRequest query1{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key1)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query2{ + db::kv::api::GetAsOfRequest query2{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key2)), .timestamp = 244087591818874, }; - db::kv::api::GetAsOfQuery query3{ + db::kv::api::GetAsOfRequest query3{ .table = table::kAccountDomain, .key = db::account_domain_key(bytes_to_address(account_history_key3)), .timestamp = 244087591818874, diff --git a/silkworm/rpc/core/logs_walker.cpp b/silkworm/rpc/core/logs_walker.cpp index e3c70d3ea0..57c539782e 100644 --- a/silkworm/rpc/core/logs_walker.cpp +++ b/silkworm/rpc/core/logs_walker.cpp @@ -98,7 +98,7 @@ Task LogsWalker::get_logs(BlockNum start, SILK_DEBUG << "topic: " << to_hex(*it) << ", from_timestamp: " << from_timestamp << ", to_timestamp: " << to_timestamp; - db::kv::api::IndexRangeQuery query = { + db::kv::api::IndexRangeRequest query = { .table = db::table::kLogTopicIdx, .key = db::topic_domain_key(*it), .from_timestamp = from_timestamp, @@ -119,7 +119,7 @@ Task LogsWalker::get_logs(BlockNum start, for (auto it = addresses.begin(); it < addresses.end(); ++it) { SILK_DEBUG << "address: " << *it << ", from_timestamp: " << from_timestamp << ", to_timestamp: " << to_timestamp; - db::kv::api::IndexRangeQuery query = { + db::kv::api::IndexRangeRequest query = { .table = db::table::kLogAddrIdx, .key = db::account_domain_key(*it), .from_timestamp = from_timestamp, diff --git a/silkworm/rpc/core/receipts.cpp b/silkworm/rpc/core/receipts.cpp index 0074cff8c7..ac2754d6eb 100644 --- a/silkworm/rpc/core/receipts.cpp +++ b/silkworm/rpc/core/receipts.cpp @@ -227,7 +227,7 @@ Task> get_receipt(db::kv::api::Transaction& tx, txn_id++; // query db on next txn - db::kv::api::GetAsOfQuery query_cumulative_gas{ + db::kv::api::GetAsOfRequest query_cumulative_gas{ .table = db::table::kReceiptDomain, .key = kCumulativeGasUsedKey, .timestamp = static_cast(txn_id), @@ -242,7 +242,7 @@ Task> get_receipt(db::kv::api::Transaction& tx, varint.decode_word(value1); auto first_cumulative_gas_used_in_tx = varint.value; - db::kv::api::GetAsOfQuery query_first_log_index{ + db::kv::api::GetAsOfRequest query_first_log_index{ .table = db::table::kReceiptDomain, .key = kFirstLogIndexKey, .timestamp = static_cast(txn_id), diff --git a/silkworm/rpc/core/storage_walker.cpp b/silkworm/rpc/core/storage_walker.cpp index e721dc31d0..66b3eabb8b 100644 --- a/silkworm/rpc/core/storage_walker.cpp +++ b/silkworm/rpc/core/storage_walker.cpp @@ -41,7 +41,7 @@ Task StorageWalker::storage_range_at( auto to = db::code_domain_key(address); increment(to); - db::kv::api::DomainRangeQuery query{ + db::kv::api::DomainRangeRequest query{ .table = db::table::kStorageDomain, .from_key = from, .to_key = to, diff --git a/silkworm/rpc/core/storage_walker_test.cpp b/silkworm/rpc/core/storage_walker_test.cpp index aed7d2a1b7..99b95dade6 100644 --- a/silkworm/rpc/core/storage_walker_test.cpp +++ b/silkworm/rpc/core/storage_walker_test.cpp @@ -206,27 +206,27 @@ class DummyTransaction : public BaseTransaction { co_return; } - Task get_latest(db::kv::api::GetLatestQuery /*query*/) override { + Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } - Task get_as_of(db::kv::api::GetAsOfQuery /*query*/) override { + Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } - Task history_seek(db::kv::api::HistoryPointQuery /*query*/) override { + Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } - Task index_range(db::kv::api::IndexRangeQuery /*query*/) override { + Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return test::empty_paginated_timestamps(); } - Task history_range(db::kv::api::HistoryRangeQuery /*query*/) override { + Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return test::empty_paginated_keys_and_values(); } - Task range_as_of(db::kv::api::DomainRangeQuery /*query*/) override { + Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return test::empty_paginated_keys_and_values(); } diff --git a/silkworm/rpc/test_util/dummy_transaction.hpp b/silkworm/rpc/test_util/dummy_transaction.hpp index a5746f1d91..5b5ccb79bf 100644 --- a/silkworm/rpc/test_util/dummy_transaction.hpp +++ b/silkworm/rpc/test_util/dummy_transaction.hpp @@ -79,27 +79,27 @@ class DummyTransaction : public db::kv::api::BaseTransaction { Task close() override { co_return; } - Task get_latest(db::kv::api::GetLatestQuery /*query*/) override { + Task get_latest(db::kv::api::GetLatestRequest /*query*/) override { co_return db::kv::api::GetLatestResult{}; } - Task get_as_of(db::kv::api::GetAsOfQuery /*query*/) override { + Task get_as_of(db::kv::api::GetAsOfRequest /*query*/) override { co_return db::kv::api::GetAsOfResult{}; } - Task history_seek(db::kv::api::HistoryPointQuery /*query*/) override { + Task history_seek(db::kv::api::HistoryPointRequest /*query*/) override { co_return db::kv::api::HistoryPointResult{}; } - Task index_range(db::kv::api::IndexRangeQuery /*query*/) override { + Task index_range(db::kv::api::IndexRangeRequest /*query*/) override { co_return empty_paginated_timestamps(); } - Task history_range(db::kv::api::HistoryRangeQuery /*query*/) override { + Task history_range(db::kv::api::HistoryRangeRequest /*query*/) override { co_return empty_paginated_keys_and_values(); } - Task range_as_of(db::kv::api::DomainRangeQuery /*query*/) override { + Task range_as_of(db::kv::api::DomainRangeRequest /*query*/) override { co_return test::empty_paginated_keys_and_values(); }