7af80ebb8d
Reviewers: buda Reviewed By: buda Subscribers: pullbot Differential Revision: https://phabricator.memgraph.io/D1367
106 lines
4.1 KiB
C++
106 lines
4.1 KiB
C++
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <mutex>
|
|
#include <vector>
|
|
|
|
#include "data_structures/concurrent/concurrent_map.hpp"
|
|
#include "threading/sync/spinlock.hpp"
|
|
#include "transactions/commit_log.hpp"
|
|
#include "transactions/transaction.hpp"
|
|
#include "transactions/type.hpp"
|
|
|
|
namespace tx {
|
|
/**
|
|
* Database transaction engine. Used for managing transactions and the related
|
|
* information such as transaction snapshots and the transaction state info.
|
|
*
|
|
* This is an abstract base class for implementing a single-node transactional
|
|
* engine (MasterEngine), an engine for the master in a distributed system (also
|
|
* MasterEngine), and for the worker in a distributed system (WorkerEngine).
|
|
*
|
|
* Methods in this class are often prefixed with "Global" or "Local", depending
|
|
* on the guarantees that they need to satisfy. These guarantee requirements are
|
|
* determined by the users of a particular method.
|
|
*/
|
|
class Engine {
|
|
public:
|
|
virtual ~Engine() = default;
|
|
|
|
/// Begins a transaction and returns a pointer to it's object.
|
|
virtual Transaction *Begin() = 0;
|
|
|
|
/// Advances the command on the transaction with the given id.
|
|
virtual CommandId Advance(TransactionId id) = 0;
|
|
|
|
/// Updates the command on the workers to the master's value.
|
|
virtual CommandId UpdateCommand(TransactionId id) = 0;
|
|
|
|
/// Comits the given transaction. Deletes the transaction object, it's not
|
|
/// valid after this function executes.
|
|
virtual void Commit(const Transaction &t) = 0;
|
|
|
|
/// Aborts the given transaction. Deletes the transaction object, it's not
|
|
/// valid after this function executes.
|
|
virtual void Abort(const Transaction &t) = 0;
|
|
|
|
/** Returns the commit log Info about the given transaction. */
|
|
virtual CommitLog::Info Info(TransactionId tx) const = 0;
|
|
|
|
/** Returns the snapshot relevant to garbage collection of database records.
|
|
*
|
|
* If there are no active transactions that means a snapshot containing only
|
|
* the next transaction ID. If there are active transactions, that means the
|
|
* oldest active transaction's snapshot, with that transaction's ID appened as
|
|
* last.
|
|
*
|
|
* The idea is that data records can only be deleted if they were expired (and
|
|
* that was committed) by a transaction older than the older currently active.
|
|
* We need the full snapshot to prevent overlaps (see general GC
|
|
* documentation).
|
|
*
|
|
* The returned snapshot must be for the globally oldest active transaction.
|
|
* If we only looked at locally known transactions, it would be possible to
|
|
* delete something that and older active transaction can still see.
|
|
*/
|
|
virtual Snapshot GlobalGcSnapshot() = 0;
|
|
|
|
/** Returns active transactions. */
|
|
virtual Snapshot GlobalActiveTransactions() = 0;
|
|
|
|
/** Returns the ID the last globally known transaction. */
|
|
virtual tx::TransactionId GlobalLast() const = 0;
|
|
|
|
/** Returns the ID of last locally known transaction. */
|
|
virtual tx::TransactionId LocalLast() const = 0;
|
|
|
|
/** Returns the ID of the oldest transaction locally known to be active. It is
|
|
* guaranteed that all the transactions older than the returned are globally
|
|
* not active. */
|
|
virtual TransactionId LocalOldestActive() const = 0;
|
|
|
|
/** Calls function f on each locally active transaction. */
|
|
virtual void LocalForEachActiveTransaction(
|
|
std::function<void(Transaction &)> f) = 0;
|
|
|
|
/** Gets a transaction object for a running transaction. */
|
|
virtual tx::Transaction *RunningTransaction(TransactionId tx_id) = 0;
|
|
|
|
/** Ensures the next transaction that starts will have the ID greater than
|
|
* the given id. */
|
|
virtual void EnsureNextIdGreater(TransactionId tx_id) = 0;
|
|
|
|
/** Garbage collects transactions older than tx_id from commit log. */
|
|
virtual void GarbageCollectCommitLog(TransactionId tx_id) = 0;
|
|
|
|
auto &local_lock_graph() { return local_lock_graph_; }
|
|
const auto &local_lock_graph() const { return local_lock_graph_; }
|
|
|
|
private:
|
|
// Map lock dependencies. Each entry maps (tx_that_wants_lock,
|
|
// tx_that_holds_lock). Used for local deadlock resolution.
|
|
// TODO consider global deadlock resolution.
|
|
ConcurrentMap<TransactionId, TransactionId> local_lock_graph_;
|
|
};
|
|
} // namespace tx
|