duckdb::DuckTransactionManager Class Reference

Inheritance diagram for duckdb::DuckTransactionManager:

Collaboration diagram for duckdb::DuckTransactionManager:

Classes
struct	CheckpointDecision

Public Member Functions
	DuckTransactionManager (AttachedDatabase &db)
Transaction &	StartTransaction (ClientContext &context) override
	Start a new transaction.
ErrorData	CommitTransaction (ClientContext &context, Transaction &transaction) override
	Commit the given transaction.
void	RollbackTransaction (Transaction &transaction) override
	Rollback the given transaction.
void	Checkpoint (ClientContext &context, bool force=false) override
transaction_t	LowestActiveId () const
transaction_t	LowestActiveStart () const
transaction_t	GetLastCommit () const
transaction_t	GetActiveCheckpoint () const
transaction_t	GetNewCheckpointId ()
void	ResetCheckpointId ()
bool	IsDuckTransactionManager () override
unique_ptr< StorageLockKey >	SharedCheckpointLock ()
	Obtains a shared lock to the checkpoint lock.
unique_ptr< StorageLockKey >	TryGetCheckpointLock ()
	Try to obtain an exclusive checkpoint lock.
unique_ptr< StorageLockKey >	TryUpgradeCheckpointLock (StorageLockKey &lock)
unique_ptr< StorageLockKey >	SharedVacuumLock ()
unique_ptr< StorageLockKey >	TryGetVacuumLock ()
DUCKDB_API idx_t	GetCatalogVersion (Transaction &transaction)
	Returns the current version of the catalog (incremented whenever anything changes, not stored between restarts)
void	PushCatalogEntry (Transaction &transaction_p, CatalogEntry &entry, data_ptr_t extra_data=nullptr, idx_t extra_data_size=0)
void	PushAttach (Transaction &transaction_p, AttachedDatabase &db)
Public Member Functions inherited from duckdb::TransactionManager
	TransactionManager (AttachedDatabase &db)
AttachedDatabase &	GetDB ()
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static DuckTransactionManager &	Get (AttachedDatabase &db)
Static Public Member Functions inherited from duckdb::TransactionManager
static TransactionManager &	Get (AttachedDatabase &db)

Protected Member Functions
virtual void	OnCommitCheckpointDecision (const CheckpointDecision &decision, DuckTransaction &transaction)

Private Member Functions
transaction_t	GetCommitTimestamp ()
	Generates a new commit timestamp.
unique_ptr< DuckCleanupInfo >	RemoveTransaction (DuckTransaction &transaction) noexcept
	Remove the given transaction from the list of active transactions.
unique_ptr< DuckCleanupInfo >	RemoveTransaction (DuckTransaction &transaction, bool store_transaction) noexcept
	Remove the given transaction from the list of active transactions.
CheckpointDecision	CanCheckpoint (DuckTransaction &transaction, unique_ptr< StorageLockKey > &checkpoint_lock, const UndoBufferProperties &properties)
	Whether or not we can checkpoint.
CheckpointDecision	GetCheckpointType (DuckTransaction &transaction, const UndoBufferProperties &undo_properties)
	Get the checkpoint type of an automatic checkpoint.
bool	HasOtherTransactions (DuckTransaction &transaction)
void	CleanupTransactions ()

Private Attributes
transaction_t	current_start_timestamp
	The current start timestamp used by transactions.
transaction_t	current_transaction_id
	The current transaction ID used by transactions.
atomic< transaction_t >	lowest_active_id
	The lowest active transaction id.
atomic< transaction_t >	lowest_active_start
	The lowest active transaction timestamp.
atomic< transaction_t >	last_commit
	The last commit timestamp.
atomic< transaction_t >	active_checkpoint
	The currently active checkpoint.
vector< unique_ptr< DuckTransaction > >	active_transactions
	Set of currently running transactions.
vector< unique_ptr< DuckTransaction > >	recently_committed_transactions
	Set of recently committed transactions.
mutex	transaction_lock
	The lock used for transaction operations.
StorageLock	checkpoint_lock
	The checkpoint lock.
StorageLock	vacuum_lock
	The vacuum lock - necessary to start vacuum operations.
mutex	start_transaction_lock
	Lock necessary to start transactions only - used by FORCE CHECKPOINT to prevent new transactions from starting.
atomic< idx_t >	last_uncommitted_catalog_version = {TRANSACTION_ID_START}
idx_t	last_committed_version = 0
mutex	cleanup_lock
	Only one cleanup can be active at any time.
mutex	cleanup_queue_lock
	Changes to the cleanup queue must be synchronized.
queue< unique_ptr< DuckCleanupInfo > >	cleanup_queue

Additional Inherited Members
Protected Attributes inherited from duckdb::TransactionManager
AttachedDatabase &	db
	The attached database.

Detailed Description

The Transaction Manager is responsible for creating and managing transactions

Member Function Documentation

StartTransaction()

Transaction & duckdb::DuckTransactionManager::StartTransaction ( ClientContext &  context )

overridevirtual

Start a new transaction.

Implements duckdb::TransactionManager.

CommitTransaction()

ErrorData duckdb::DuckTransactionManager::CommitTransaction ( ClientContext &  context, Transaction &  transaction  )

overridevirtual

Commit the given transaction.

Implements duckdb::TransactionManager.

RollbackTransaction()

void duckdb::DuckTransactionManager::RollbackTransaction ( Transaction &  transaction )

overridevirtual

Rollback the given transaction.

Implements duckdb::TransactionManager.

Checkpoint()

void duckdb::DuckTransactionManager::Checkpoint ( ClientContext &  context, bool  force = false  )

overridevirtual

Implements duckdb::TransactionManager.

LowestActiveId()

transaction_t duckdb::DuckTransactionManager::LowestActiveId ( ) const

inline

                                         {
        return lowest_active_id;
    }

LowestActiveStart()

transaction_t duckdb::DuckTransactionManager::LowestActiveStart ( ) const

inline

                                            {
        return lowest_active_start;
    }

GetLastCommit()

transaction_t duckdb::DuckTransactionManager::GetLastCommit ( ) const

inline

                                        {
        return last_commit;
    }

GetActiveCheckpoint()

transaction_t duckdb::DuckTransactionManager::GetActiveCheckpoint ( ) const

inline

                                              {
        return active_checkpoint;
    }

IsDuckTransactionManager()

bool duckdb::DuckTransactionManager::IsDuckTransactionManager ( )

inlineoverridevirtual

Reimplemented from duckdb::TransactionManager.

                                             {
        return true;
    }

OnCommitCheckpointDecision()

virtual void duckdb::DuckTransactionManager::OnCommitCheckpointDecision ( const CheckpointDecision &  decision, DuckTransaction &  transaction  )

inlineprotectedvirtual

                                                                                                              {
    }

Member Data Documentation

last_uncommitted_catalog_version

atomic<idx_t> duckdb::DuckTransactionManager::last_uncommitted_catalog_version = {TRANSACTION_ID_START}

private

{TRANSACTION_ID_START};

cleanup_queue

queue<unique_ptr<DuckCleanupInfo> > duckdb::DuckTransactionManager::cleanup_queue

private

Cleanups have to happen in-order. E.g., if one transaction drops a table, and another creates a table, inverting the cleanup order can result in catalog errors.

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp