diff --git a/src/storage/v2/disk/compaction_filter.cpp b/src/storage/v2/disk/compaction_filter.cpp index 874042fc6..b18cd6a7a 100644 --- a/src/storage/v2/disk/compaction_filter.cpp +++ b/src/storage/v2/disk/compaction_filter.cpp @@ -20,8 +20,8 @@ class TimestampCompactionFilter : public rocksdb::CompactionFilter { /// Return true if the key-value pair should be removed from the database during compaction. /// Filters KV entries that are older than the specified timestamp. - bool Filter(int level, const rocksdb::Slice &key, const rocksdb::Slice &existing_value, std::string *new_value, - bool *value_changed) const override { + bool Filter(int /*level*/, const rocksdb::Slice & /*key*/, const rocksdb::Slice & /*existing_value*/, + std::string * /*new_value*/, bool * /*value_changed*/) const override { return true; } }; diff --git a/src/storage/v2/disk/rocksdb_storage.cpp b/src/storage/v2/disk/rocksdb_storage.cpp index 7c4e8e0db..847ae57c1 100644 --- a/src/storage/v2/disk/rocksdb_storage.cpp +++ b/src/storage/v2/disk/rocksdb_storage.cpp @@ -24,7 +24,7 @@ inline rocksdb::Slice StripTimestampFromUserKey(const rocksdb::Slice &user_key, inline rocksdb::Slice ExtractTimestampFromUserKey(const rocksdb::Slice &user_key) { assert(user_key.size() >= sizeof(uint64_t)); - return rocksdb::Slice(user_key.data() + user_key.size() - sizeof(uint64_t), sizeof(uint64_t)); + return {user_key.data() + user_key.size() - sizeof(uint64_t), sizeof(uint64_t)}; } } // namespace diff --git a/src/storage/v2/inmemory/storage.cpp b/src/storage/v2/inmemory/storage.cpp index 01a2b1c7f..48bd69121 100644 --- a/src/storage/v2/inmemory/storage.cpp +++ b/src/storage/v2/inmemory/storage.cpp @@ -271,7 +271,7 @@ VertexAccessor InMemoryStorage::InMemoryAccessor::CreateVertex() { delta->prev.Set(&*it); } - return VertexAccessor(&*it, &transaction_, &storage_->indices_, &storage_->constraints_, config_); + return {&*it, &transaction_, &storage_->indices_, &storage_->constraints_, config_}; } VertexAccessor InMemoryStorage::InMemoryAccessor::CreateVertex(storage::Gid gid) { @@ -407,8 +407,8 @@ Result InMemoryStorage::InMemoryAccessor::CreateEdge(VertexAccesso "VertexAccessors must be from the same transaction in when " "creating an edge!"); - auto from_vertex = from->vertex_; - auto to_vertex = to->vertex_; + auto *from_vertex = from->vertex_; + auto *to_vertex = to->vertex_; // Obtain the locks by `gid` order to avoid lock cycles. std::unique_lock guard_from(from_vertex->lock, std::defer_lock); @@ -470,8 +470,8 @@ Result InMemoryStorage::InMemoryAccessor::CreateEdge(VertexAccesso "VertexAccessors must be from the same transaction in when " "creating an edge!"); - auto from_vertex = from->vertex_; - auto to_vertex = to->vertex_; + auto *from_vertex = from->vertex_; + auto *to_vertex = to->vertex_; // Obtain the locks by `gid` order to avoid lock cycles. std::unique_lock guard_from(from_vertex->lock, std::defer_lock); @@ -540,7 +540,7 @@ Result> InMemoryStorage::InMemoryAccessor::DeleteEdg std::unique_lock guard; if (config_.properties_on_edges) { - auto edge_ptr = edge_ref.ptr; + auto *edge_ptr = edge_ref.ptr; guard = std::unique_lock(edge_ptr->lock); if (!PrepareForWrite(&transaction_, edge_ptr)) return Error::SERIALIZATION_ERROR; @@ -729,7 +729,7 @@ utils::BasicResult InMemoryStorage::InMemory // Take committed_transactions lock while holding the engine lock to // make sure that committed transactions are sorted by the commit // timestamp in the list. - storage_->committed_transactions_.WithLock([&](auto &committed_transactions) { + storage_->committed_transactions_.WithLock([&](auto & /*committed_transactions*/) { // TODO: release lock, and update all deltas to have a local copy // of the commit timestamp MG_ASSERT(transaction_.commit_timestamp != nullptr, "Invalid database state!"); @@ -776,7 +776,7 @@ void InMemoryStorage::InMemoryAccessor::Abort() { auto prev = delta.prev.Get(); switch (prev.type) { case PreviousPtr::Type::VERTEX: { - auto vertex = prev.vertex; + auto *vertex = prev.vertex; std::lock_guard guard(vertex->lock); Delta *current = vertex->delta; while (current != nullptr && current->timestamp->load(std::memory_order_acquire) == @@ -864,7 +864,7 @@ void InMemoryStorage::InMemoryAccessor::Abort() { break; } case PreviousPtr::Type::EDGE: { - auto edge = prev.edge; + auto *edge = prev.edge; std::lock_guard guard(edge->lock); Delta *current = edge->delta; while (current != nullptr && current->timestamp->load(std::memory_order_acquire) == @@ -1152,6 +1152,7 @@ StorageInfo InMemoryStorage::GetInfo() const { auto edge_count = edge_count_.load(std::memory_order_acquire); double average_degree = 0.0; if (vertex_count) { + // NOLINTNEXTLINE(bugprone-narrowing-conversions, cppcoreguidelines-narrowing-conversions) average_degree = 2.0 * static_cast(edge_count) / vertex_count; } return {vertex_count, edge_count, average_degree, utils::GetMemoryUsage(), @@ -1184,8 +1185,8 @@ Transaction InMemoryStorage::CreateTransaction(IsolationLevel isolation_level, S // We acquire the transaction engine lock here because we access (and // modify) the transaction engine variables (`transaction_id` and // `timestamp`) below. - uint64_t transaction_id; - uint64_t start_timestamp; + uint64_t transaction_id = 0; + uint64_t start_timestamp = 0; { std::lock_guard guard(engine_lock_); transaction_id = transaction_id_++; @@ -1263,7 +1264,7 @@ void InMemoryStorage::CollectGarbage() { while (true) { // We don't want to hold the lock on commited transactions for too long, // because that prevents other transactions from committing. - Transaction *transaction; + Transaction *transaction = nullptr; { auto committed_transactions_ptr = committed_transactions_.Lock(); if (committed_transactions_ptr->empty()) { @@ -1512,7 +1513,7 @@ bool InMemoryStorage::AppendToWalDataManipulation(const Transaction &transaction // delta that should be processed and then appends all discovered deltas. auto find_and_apply_deltas = [&](const auto *delta, const auto &parent, auto filter) { while (true) { - auto older = delta->next.load(std::memory_order_acquire); + auto *older = delta->next.load(std::memory_order_acquire); if (older == nullptr || older->timestamp->load(std::memory_order_acquire) != current_commit_timestamp) break; delta = older; } @@ -1784,10 +1785,9 @@ void InMemoryStorage::FreeMemory() { uint64_t InMemoryStorage::CommitTimestamp(const std::optional desired_commit_timestamp) { if (!desired_commit_timestamp) { return timestamp_++; - } else { - timestamp_ = std::max(timestamp_, *desired_commit_timestamp + 1); - return *desired_commit_timestamp; } + timestamp_ = std::max(timestamp_, *desired_commit_timestamp + 1); + return *desired_commit_timestamp; } bool InMemoryStorage::SetReplicaRole(io::network::Endpoint endpoint,