Class: QgsTransaction

Allows creation of a multi-layer database-side transaction.

This class allows including a set of layers in a database-side transaction, provided the layer data providers support transactions and are compatible with each other.

Only layers which are not in edit mode can be included in a transaction, and all layers need to be in read-only mode for a transaction to be committed or rolled back.

Layers can only be included in one transaction at a time.

When editing layers which are part of a transaction group, all changes are sent directly to the data provider (bypassing the undo/redo stack), and the changes can either be committed or rolled back on the database side via the QgsTransaction.commit and QgsTransaction.rollback methods.

As long as the transaction is active, the state of all layer features reflects the current state in the transaction.

Edits on features can get rejected if another conflicting transaction is active.

Note

This is an abstract class, with methods which must be implemented by a subclass.

The following methods must be implemented: executeSql()

Class Hierarchy

Base classes

QObject

Abstract Methods

executeSql

Execute the sql string.

Methods

addLayer	Add the layer to the transaction.
begin	Begin transaction The statementTimeout (in seconds) specifies how long an sql statement is allowed to block QGIS before it is aborted.
commit	Commit transaction.
connectionString	Returns the connection string of the transaction
createSavepoint	creates a save point returns empty string on error returns the last created savepoint if it's not dirty
dirtyLastSavePoint	dirty save point such that next call to createSavepoint will create a new one
lastSavePointIsDirty	returns the last created savepoint
rollback	Roll back transaction.
savePoints	returns savepoints

Virtual Methods

In PyQGIS, only methods marked as virtual can be safely overridden in a Python subclass of QgsTransaction. See the FAQ for more details.

rollbackToSavepoint

rollback to save point, the save point is maintained and is "undertied"

Static Methods

create	Create a transaction for the specified connection string connString and provider with providerKey.
supportsTransaction	Checks if the provider of a given layer supports transactions.

Signals

afterRollback	Emitted after a rollback
afterRollbackToSavepoint	Emitted after a rollback to savepoint
dirtied	Emitted if a sql query is executed and the underlying data is modified

class qgis.core.QgsTransaction

Bases: QObject

addLayer(self, layer: QgsVectorLayer | None, addLayersInEditMode: bool = False) → bool

Add the layer to the transaction. The connection string must match.

Parameters:

• layer (Optional[QgsVectorLayer]) – that will be added to the transaction

• addLayersInEditMode (bool = False) – if set layers that are already

Added in version 3.26.

Return type:

bool

signal afterRollback

Emitted after a rollback

signal afterRollbackToSavepoint(savepointName: str)

Emitted after a rollback to savepoint

Added in version 3.42.

Parameters:

savepointName (str)

begin(self, statementTimeout: int = 20)

Begin transaction The statementTimeout (in seconds) specifies how long an sql statement is allowed to block QGIS before it is aborted. Statements can block, if multiple transactions are active and a statement would produce a conflicting state. In these cases, the statements block until the conflicting transaction is committed or rolled back. Some providers might not honour the statement timeout.

Parameters:

statementTimeout (int = 20) -> (bool)

commit(self)

Commit transaction.

connectionString(self) → str

Returns the connection string of the transaction

Added in version 3.26.

Return type:

str

static create(connString: str | None, providerKey: str | None) → QgsTransaction | None

Create a transaction for the specified connection string connString and provider with providerKey.

Parameters:

• connString (Optional[str])

• providerKey (Optional[str])

Return type:

Optional[QgsTransaction]

static create(layers: Iterable[QgsVectorLayer]) → QgsTransaction | None

Create a transaction which includes the layers. All layers are expected to have the same connection string and data provider.

Parameters:

layers (Iterable[QgsVectorLayer])

Return type:

Optional[QgsTransaction]

createSavepoint(self)

creates a save point returns empty string on error returns the last created savepoint if it’s not dirty

createSavepoint(self, savePointId: str | None)

creates a save point returns empty string on error

Parameters:

savePointId (Optional[str]) -> (str)

signal dirtied(sql: str, name: str)

Emitted if a sql query is executed and the underlying data is modified

Parameters:

• sql (str)

• name (str)

dirtyLastSavePoint(self)

dirty save point such that next call to createSavepoint will create a new one

abstract executeSql(self, sql: str | None, isDirty: bool = False, name: str | None = '')

Execute the sql string.

Parameters:

• sql (Optional[str]) – The sql query to execute

• isDirty (bool = False) – Flag to indicate if the underlying data will be modified

• name (Optional[str] = '') -> (bool) – Name of the transaction ( only used if isDirty is True)

Returns:

• True if everything is OK, False otherwise

• error: The error message

lastSavePointIsDirty(self) → bool

returns the last created savepoint

Return type:

bool

rollback(self)

Roll back transaction.

virtual rollbackToSavepoint(self, name: str | None)

rollback to save point, the save point is maintained and is “undertied”

Parameters:

name (Optional[str]) -> (bool)

savePoints(self) → List[str]

returns savepoints

Return type:

List[str]

static supportsTransaction(layer: QgsVectorLayer | None) → bool

Checks if the provider of a given layer supports transactions.

Parameters:

layer (Optional[QgsVectorLayer])

Return type:

bool