transaction API Reference

Interfaces

interface transaction.interfaces.ITransactionManager[source]

An object that manages a sequence of transactions.

Applications use transaction managers to establish transaction boundaries.

explicit

Explicit mode indicator.

This is true if the transaction manager is in explicit mode. In explicit mode, transactions must be begun explicitly, by calling begin() and ended explicitly by calling commit() or abort().

begin()

Explicitly begin and return a new transaction.

If an existing transaction is in progress and the transaction manager not in explicit mode, the previous transaction will be aborted. If an existing transaction is in progress and the transaction manager is in explicit mode, an AlreadyInTransaction exception will be raised..

The newTransaction method of registered synchronizers is called, passing the new transaction object.

Note that when not in explicit mode, transactions may be started implicitly without calling begin. In that case, newTransaction isn’t called because the transaction manager doesn’t know when to call it. The transaction is likely to have begun long before the transaction manager is involved. (Conceivably the commit and abort methods could call begin, but they don’t.)

get()

Get the current transaction.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

commit()

Commit the current transaction.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

abort()

Abort the current transaction.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

doom()

Doom the current transaction.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

isDoomed()

Returns True if the current transaction is doomed, otherwise False.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

savepoint(optimistic=False)

Create a savepoint from the current transaction.

If the optimistic argument is true, then data managers that don’t support savepoints can be used, but an error will be raised if the savepoint is rolled back.

An ISavepoint object is returned.

In explicit mode, if a transaction hasn’t begun, a NoTransaction exception will be raised.

registerSynch(synch)

Register an ISynchronizer.

Synchronizers are notified about some major events in a transaction’s life. See ISynchronizer for details.

If a synchronizer registers while there is an active transaction, its newTransaction method will be called with the active transaction.

unregisterSynch(synch)

Unregister an ISynchronizer.

Synchronizers are notified about some major events in a transaction’s life. See ISynchronizer for details.

clearSynchs()

Unregister all registered ISynchronizers.

This exists to support test cleanup/initialization

registeredSynchs()

Determine if any ISynchronizers are registered.

Return true is any are registered, and return False otherwise.

This exists to support test cleanup/initialization

interface transaction.interfaces.ITransaction[source]

Object representing a running transaction.

Objects with this interface may represent different transactions during their lifetime (.begin() can be called to start a new transaction using the same instance, although that example is deprecated and will go away in ZODB 3.6).

user

A user name associated with the transaction.

The format of the user name is defined by the application. The value is text (unicode). Storages record the user value, as meta-data, when a transaction commits.

A storage may impose a limit on the size of the value; behavior is undefined if such a limit is exceeded (for example, a storage may raise an exception, or truncate the value).

description

A textual description of the transaction.

The value is text (unicode). Method note() is the intended way to set the value. Storages record the description, as meta-data, when a transaction commits.

A storage may impose a limit on the size of the description; behavior is undefined if such a limit is exceeded (for example, a storage may raise an exception, or truncate the value).

extension

A dictionary containing application-defined metadata.

commit()

Finalize the transaction.

This executes the two-phase commit algorithm for all IDataManager objects associated with the transaction.

abort()

Abort the transaction.

This is called from the application. This can only be called before the two-phase commit protocol has been started.

doom()

Doom the transaction.

Dooms the current transaction. This will cause DoomedTransactionException to be raised on any attempt to commit the transaction.

Otherwise the transaction will behave as if it was active.

savepoint(optimistic=False)

Create a savepoint.

If the optimistic argument is true, then data managers that don’t support savepoints can be used, but an error will be raised if the savepoint is rolled back.

An ISavepoint object is returned.

join(datamanager)

Add a data manager to the transaction.

datamanager must provide the transactions.interfaces.IDataManager interface.

note(text)

Add text (unicode) to the transaction description.

This modifies the .description attribute; see its docs for more detail. First surrounding whitespace is stripped from text. If .description is currently an empty string, then the stripped text becomes its value, else two newlines and the stripped text are appended to .description.

setExtendedInfo(name, value)

Add extension data to the transaction.

name
is the text (unicode) name of the extension property to set
value
must be picklable and json serializable (not an instance).

Multiple calls may be made to set multiple extension properties, provided the names are distinct.

Storages record the extension data, as meta-data, when a transaction commits.

A storage may impose a limit on the size of extension data; behavior is undefined if such a limit is exceeded (for example, a storage may raise an exception, or remove <name, value> pairs).

addBeforeCommitHook(hook, args=(), kws=None)

Register a hook to call before the transaction is committed.

The specified hook function will be called after the transaction’s commit method has been called, but before the commit process has been started. The hook will be passed the specified positional (args) and keyword (kws) arguments. args is a sequence of positional arguments to be passed, defaulting to an empty tuple (no positional arguments are passed). kws is a dictionary of keyword argument names and values to be passed, or the default None (no keyword arguments are passed).

Multiple hooks can be registered and will be called in the order they were registered (first registered, first called). This method can also be called from a hook: an executing hook can register more hooks. Applications should take care to avoid creating infinite loops by recursively registering hooks.

Hooks are called only for a top-level commit. A savepoint creation does not call any hooks. If the transaction is aborted, hooks are not called, and are discarded. Calling a hook “consumes” its registration too: hook registrations do not persist across transactions. If it’s desired to call the same hook on every transaction commit, then addBeforeCommitHook() must be called with that hook during every transaction; in such a case consider registering a synchronizer object via a TransactionManager’s registerSynch() method instead.

getBeforeCommitHooks()

Return iterable producing the registered addBeforeCommit hooks.

A triple (hook, args, kws) is produced for each registered hook. The hooks are produced in the order in which they would be invoked by a top-level transaction commit.

addAfterCommitHook(hook, args=(), kws=None)

Register a hook to call after a transaction commit attempt.

The specified hook function will be called after the transaction commit succeeds or aborts. The first argument passed to the hook is a Boolean value, true if the commit succeeded, or false if the commit aborted. args specifies additional positional, and kws keyword, arguments to pass to the hook. args is a sequence of positional arguments to be passed, defaulting to an empty tuple (only the true/false success argument is passed). kws is a dictionary of keyword argument names and values to be passed, or the default None (no keyword arguments are passed).

Multiple hooks can be registered and will be called in the order they were registered (first registered, first called). This method can also be called from a hook: an executing hook can register more hooks. Applications should take care to avoid creating infinite loops by recursively registering hooks.

Hooks are called only for a top-level commit. A savepoint creation does not call any hooks. Calling a hook “consumes” its registration: hook registrations do not persist across transactions. If it’s desired to call the same hook on every transaction commit, then addAfterCommitHook() must be called with that hook during every transaction; in such a case consider registering a synchronizer object via a TransactionManager’s registerSynch() method instead.

getAfterCommitHooks()

Return iterable producing the registered addAfterCommit hooks.

A triple (hook, args, kws) is produced for each registered hook. The hooks are produced in the order in which they would be invoked by a top-level transaction commit.

set_data(ob, data)

Hold data on behalf of an object

For objects such as data managers or their subobjects that work with multiple transactions, it’s convenient to store transaction-specific data on the transaction itself. The transaction knows nothing about the data, but simply holds it on behalf of the object.

The object passed should be the object that needs the data, as opposed to simple object like a string. (Internally, the id of the object is used as the key.)

data(ob)

Retrieve data held on behalf of an object.

See set_data.

interface transaction.interfaces.IDataManager[source]

Objects that manage transactional storage.

These objects may manage data for other objects, or they may manage non-object storages, such as relational databases. For example, a ZODB.Connection.

Note that when some data is modified, that data’s data manager should join a transaction so that data can be committed when the user commits the transaction.

transaction_manager

The transaction manager (TM) used by this data manager.

This is a public attribute, intended for read-only use. The value is an instance of ITransactionManager, typically set by the data manager’s constructor.

abort(transaction)

Abort a transaction and forget all changes.

Abort must be called outside of a two-phase commit.

Abort is called by the transaction manager to abort transactions that are not yet in a two-phase commit. It may also be called when rolling back a savepoint made before the data manager joined the transaction.

In any case, after abort is called, the data manager is no longer participating in the transaction. If there are new changes, the data manager must rejoin the transaction.

tpc_begin(transaction)

Begin commit of a transaction, starting the two-phase commit.

transaction is the ITransaction instance associated with the transaction being committed.

commit(transaction)

Commit modifications to registered objects.

Save changes to be made persistent if the transaction commits (if tpc_finish is called later). If tpc_abort is called later, changes must not persist.

This includes conflict detection and handling. If no conflicts or errors occur, the data manager should be prepared to make the changes persist when tpc_finish is called.

tpc_vote(transaction)

Verify that a data manager can commit the transaction.

This is the last chance for a data manager to vote ‘no’. A data manager votes ‘no’ by raising an exception.

transaction is the ITransaction instance associated with the transaction being committed.

tpc_finish(transaction)

Indicate confirmation that the transaction is done.

Make all changes to objects modified by this transaction persist.

transaction is the ITransaction instance associated with the transaction being committed.

This should never fail. If this raises an exception, the database is not expected to maintain consistency; it’s a serious error.

tpc_abort(transaction)

Abort a transaction.

This is called by a transaction manager to end a two-phase commit on the data manager. Abandon all changes to objects modified by this transaction.

transaction is the ITransaction instance associated with the transaction being committed.

This should never fail.

sortKey()

Return a key to use for ordering registered DataManagers.

In order to guarantee a total ordering, keys must be strings.

ZODB uses a global sort order to prevent deadlock when it commits transactions involving multiple resource managers. The resource manager must define a sortKey() method that provides a global ordering for resource managers.

interface transaction.interfaces.ISavepointDataManager[source]

Extends: transaction.interfaces.IDataManager

savepoint()

Return a data-manager savepoint (IDataManagerSavepoint).

interface transaction.interfaces.IRetryDataManager[source]

Extends: transaction.interfaces.IDataManager

should_retry(exception)

Return whether a given exception instance should be retried.

A data manager can provide this method to indicate that a a transaction that raised the given error should be retried. This method may be called by an ITransactionManager when considering whether to retry a failed transaction.

interface transaction.interfaces.IDataManagerSavepoint[source]

Savepoint for data-manager changes for use in transaction savepoints.

Datamanager savepoints are used by, and only by, transaction savepoints.

Note that data manager savepoints don’t have any notion of, or responsibility for, validity. It isn’t the responsibility of data-manager savepoints to prevent multiple rollbacks or rollbacks after transaction termination. Preventing invalid savepoint rollback is the responsibility of transaction rollbacks. Application code should never use data-manager savepoints.

rollback()

Rollback any work done since the savepoint.

interface transaction.interfaces.ISavepoint[source]

A transaction savepoint.

rollback()

Rollback any work done since the savepoint.

InvalidSavepointRollbackError is raised if the savepoint isn’t valid.

valid

Boolean indicating whether the savepoint is valid

class transaction.interfaces.InvalidSavepointRollbackError[source]

Attempt to rollback an invalid savepoint.

A savepoint may be invalid because:

  • The surrounding transaction has committed or aborted.
  • An earlier savepoint in the same transaction has been rolled back.
interface transaction.interfaces.ISynchronizer[source]

Objects that participate in the transaction-boundary notification API.

beforeCompletion(transaction)

Hook that is called by the transaction at the start of a commit.

afterCompletion(transaction)

Hook that is called by the transaction after completing a commit.

newTransaction(transaction)

Hook that is called at the start of a transaction.

This hook is called when, and only when, a transaction manager’s begin() method is called explictly.

class transaction.interfaces.TransactionError[source]

An error occurred due to normal transaction processing.

class transaction.interfaces.TransactionFailedError[source]

Cannot perform an operation on a transaction that previously failed.

An attempt was made to commit a transaction, or to join a transaction, but this transaction previously raised an exception during an attempt to commit it. The transaction must be explicitly aborted, either by invoking abort() on the transaction, or begin() on its transaction manager.

class transaction.interfaces.DoomedTransaction[source]

A commit was attempted on a transaction that was doomed.

class transaction.interfaces.TransientError[source]

An error has occured when performing a transaction.

It’s possible that retrying the transaction will succeed.

API Objects

class transaction._transaction.Transaction(synchronizers=None, manager=None)[source]
isDoomed()[source]

See ITransaction.

doom()[source]

See ITransaction.

join(resource)[source]

See ITransaction.

savepoint(optimistic=False)[source]

See ITransaction.

register(obj)[source]

See ITransaction.

commit()[source]

See ITransaction.

getBeforeCommitHooks()[source]

See ITransaction.

addBeforeCommitHook(hook, args=(), kws=None)[source]

See ITransaction.

getAfterCommitHooks()[source]

See ITransaction.

addAfterCommitHook(hook, args=(), kws=None)[source]

See ITransaction.

abort()[source]

See ITransaction.

note(text)[source]

See ITransaction.

setUser(user_name, path=u'/')[source]

See ITransaction.

setExtendedInfo(name, value)[source]

See ITransaction.

class transaction._transaction.Savepoint(transaction, optimistic, *resources)[source]

Transaction savepoint.

Transaction savepoints coordinate savepoints for data managers participating in a transaction.

rollback()[source]

See ISavepoint.

class transaction._manager.TransactionManager(explicit=False)[source]
__enter__()

Alias for get()

__exit__(t, v, tb)[source]

On error, aborts the current transaction. Otherwise, commits.

begin()[source]

See ITransactionManager.

get()[source]

See ITransactionManager.

registerSynch(synch)[source]

See ITransactionManager.

unregisterSynch(synch)[source]

See ITransactionManager.

clearSynchs()[source]

See ITransactionManager.

registeredSynchs()[source]

See ITransactionManager.

isDoomed()[source]

See ITransactionManager.

doom()[source]

See ITransactionManager.

commit()[source]

See ITransactionManager.

abort()[source]

See ITransactionManager.

savepoint(optimistic=False)[source]

See ITransactionManager.

class transaction._manager.ThreadTransactionManager(explicit=False)[source]

Thread-aware transaction manager.

Each thread is associated with a unique transaction.