Inheritance diagram for duckdb::DuckTransaction:

Collaboration diagram for duckdb::DuckTransaction:

[legend]

Classes
struct	ActiveTableLock

Public Member Functions
	DuckTransaction (DuckTransactionManager &manager, ClientContext &context, transaction_t start_time, transaction_t transaction_id, idx_t catalog_version)

LocalStorage &	GetLocalStorage ()

void	PushCatalogEntry (CatalogEntry &entry, data_ptr_t extra_data, idx_t extra_data_size)

void	PushAttach (AttachedDatabase &db)

void	SetModifications (DatabaseModificationType type) override
	Sets the database modifications that are planned to be performed in this transaction.

bool	ShouldWriteToWAL (AttachedDatabase &db)

ErrorData	WriteToWAL (ClientContext &context, AttachedDatabase &db, unique_ptr< StorageCommitState > &commit_state) noexcept

ErrorData	Commit (AttachedDatabase &db, CommitInfo &commit_info, unique_ptr< StorageCommitState > commit_state) noexcept

bool	AutomaticCheckpoint (AttachedDatabase &db, const UndoBufferProperties &properties)
	Returns whether or not a commit of this transaction should trigger an automatic checkpoint.

ErrorData	Rollback ()
	Rollback.

void	Cleanup (transaction_t lowest_active_transaction)
	Cleanup the undo buffer.

bool	ChangesMade ()

UndoBufferProperties	GetUndoProperties ()

void	PushDelete (DataTable &table, RowVersionManager &info, idx_t vector_idx, row_t rows[], idx_t count, idx_t base_row)

void	PushSequenceUsage (SequenceCatalogEntry &entry, const SequenceData &data)

void	PushAppend (DataTable &table, idx_t row_start, idx_t row_count)

UndoBufferReference	CreateUpdateInfo (idx_t type_size, DataTable &data_table, idx_t entries, idx_t row_group_start)

DuckTransactionManager &	GetTransactionManager ()

bool	IsDuckTransaction () const override

unique_ptr< StorageLockKey >	TryGetCheckpointLock ()

shared_ptr< CheckpointLock >	SharedLockTable (DataTableInfo &info)
	Get a shared lock on a table.

void	ModifyTable (DataTable &tbl)
	Hold an owning reference of the table, needed to safely reference it inside the transaction commit/undo logic.

Public Member Functions inherited from duckdb::Transaction
DUCKDB_API	Transaction (TransactionManager &manager, ClientContext &context)

DUCKDB_API bool	IsReadOnly ()
	Whether or not the transaction has made any modifications to the database so far.

virtual DUCKDB_API void	SetReadWrite ()
	Promotes the transaction to a read-write transaction.

template<class TARGET >
TARGET &	Cast ()

template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static DuckTransaction &	Get (ClientContext &context, AttachedDatabase &db)

static DuckTransaction &	Get (ClientContext &context, Catalog &catalog)

Static Public Member Functions inherited from duckdb::Transaction
static DUCKDB_API Transaction &	Get (ClientContext &context, AttachedDatabase &db)

static DUCKDB_API Transaction &	Get (ClientContext &context, Catalog &catalog)

static DUCKDB_API optional_ptr< Transaction >	TryGet (ClientContext &context, AttachedDatabase &db)
	Returns the transaction for the given context if it has already been started.

Public Attributes
transaction_t	start_time
	The start timestamp of this transaction.

transaction_t	transaction_id
	The transaction id of this transaction.

transaction_t	commit_id
	The commit id of this transaction, if it has successfully been committed.

atomic< idx_t >	catalog_version

bool	awaiting_cleanup

Public Attributes inherited from duckdb::Transaction
TransactionManager &	manager

weak_ptr< ClientContext >	context

atomic< transaction_t >	active_query

Private Attributes
UndoBuffer	undo_buffer

unique_ptr< LocalStorage >	storage
	The set of uncommitted appends for the transaction.

unique_ptr< StorageLockKey >	checkpoint_lock
	Lock that prevents checkpoints from starting.

unique_ptr< StorageLockKey >	vacuum_lock
	Lock that prevents vacuums from starting.

mutex	sequence_lock
	Lock for accessing sequence_usage.

reference_map_t< SequenceCatalogEntry, reference< SequenceValue > >	sequence_usage
	Map of all sequences that were used during the transaction and the value they had in this transaction.

mutex	modified_tables_lock
	Lock for modified_tables.

reference_map_t< DataTable, shared_ptr< DataTable > >	modified_tables
	Tables that are modified by this transaction.

mutex	active_locks_lock
	Lock for the active_locks map.

reference_map_t< DataTableInfo, unique_ptr< ActiveTableLock > >	active_locks
	Active locks on tables.

Member Function Documentation

◆ SetModifications()

void duckdb::DuckTransaction::SetModifications ( DatabaseModificationType type )

overridevirtual

Sets the database modifications that are planned to be performed in this transaction.

Reimplemented from duckdb::Transaction.

◆ Commit()

ErrorData duckdb::DuckTransaction::Commit	(	AttachedDatabase &	db,
		CommitInfo &	commit_info,
		unique_ptr< StorageCommitState >	commit_state
	)

noexcept

Commit the current transaction with the given commit identifier. Returns an error message if the transaction commit failed, or an empty string if the commit was sucessful

◆ IsDuckTransaction()

bool duckdb::DuckTransaction::IsDuckTransaction ( ) const

inlineoverridevirtual

Reimplemented from duckdb::Transaction.

                                            {
        return true;
    }

Member Data Documentation

◆ awaiting_cleanup

bool duckdb::DuckTransaction::awaiting_cleanup

Transactions undergo Cleanup, after (1) removing them directly in RemoveTransaction, or (2) after they enter cleanup_queue. Some (after rollback) enter cleanup_queue, but do not require Cleanup.

◆ undo_buffer

UndoBuffer duckdb::DuckTransaction::undo_buffer

private

The undo buffer is used to store old versions of rows that are updated or deleted

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

external/duckdb/duckdb.cpp

Classes

Public Member Functions

Static Public Member Functions

Public Attributes