Class Transaction

The transaction object is used to identify a running transaction. It is created by calling Sequelize.transaction(). To run a query under a transaction, you should pass the transaction in the options object.

Transaction

See

Constructors

constructor

Properties

#afterCommitHooks #afterHooks #afterRollbackHooks #connection #finished #name #savepoints id options parent sequelize

Accessors

LOCK finished rootTransaction ISOLATION_LEVELS LOCK TYPES

Methods

#begin #cleanup #dispatchHooks #forceCleanup #setDeferrable afterCommit afterRollback afterTransaction commit getConnection getConnectionIfExists prepareEnvironment rollback setIsolationLevel

Constructors

constructor

Properties

Private Readonly #afterCommitHooks

#afterCommitHooks: Set<TransactionCallback> = ...

Private Readonly #afterHooks

#afterHooks: Set<TransactionCallback> = ...

Private Readonly #afterRollbackHooks

#afterRollbackHooks: Set<TransactionCallback> = ...

Private #connection

#connection: undefined | AbstractConnection

Private #finished

#finished: undefined | "rollback" | "commit"

Private Readonly #name

#name: string

Private Readonly #savepoints

#savepoints: Map<string, Transaction> = ...

Readonly id

id: string

Readonly options

options: Readonly<NormalizedTransactionOptions>

Readonly parent

parent: null | Transaction

sequelize

sequelize: Sequelize<AbstractDialect<object, object>>

Accessors

LOCK

finished

rootTransaction

Static ISOLATION_LEVELS

  • get ISOLATION_LEVELS(): typeof IsolationLevel

  • Isolation levels can be set per-transaction by passing options.isolationLevel to sequelize.transaction. Sequelize uses the default isolation level of the database, you can override this by passing options.isolationLevel in Sequelize constructor options.

    Pass in the desired level as the first argument:

    Returns typeof IsolationLevel

    Example

    try {
      const result = await sequelize.transaction({isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE}, transaction => {
        // your transactions
      });
      // transaction has been committed. Do something after the commit if required.
    } catch(err) {
      // do something with the err.
    }

    Deprecated

    use the IsolationLevel export

Static LOCK

  • get LOCK(): typeof Lock

  • Possible options for row locking. Used in conjunction with find calls:

    Returns typeof Lock

    possible options for row locking

    Example

    // t1 is a transaction
    Model.findAll({
      where: ...,
      transaction: t1,
      lock: t1.LOCK...
    });

    Example: Postgres also supports specific locks while eager loading by using OF:

    UserModel.findAll({
      where: ...,
      include: [TaskModel, ...],
      transaction: t1,
      lock: {
        level: t1.LOCK...,
        of: UserModel
      }
    });

    UserModel will be locked but TaskModel won't!

    Example: You can also skip locked rows:

    // t1 is a transaction
    Model.findAll({
      where: ...,
      transaction: t1,
      lock: true,
      skipLocked: true
    });

    The query will now return any rows that aren't locked by another transaction

    Deprecated

    use the Lock export

Static TYPES

  • get TYPES(): typeof TransactionType

  • Types can be set per-transaction by passing options.type to sequelize.transaction. Default to DEFERRED but you can override the default type by passing options.transactionType in new Sequelize. Sqlite only.

    Pass in the desired level as the first argument:

    Returns typeof TransactionType

    Example

    try {
      await sequelize.transaction({ type: Sequelize.Transaction.TYPES.EXCLUSIVE }, transaction => {
         // your transactions
      });
      // transaction has been committed. Do something after the commit if required.
    } catch(err) {
      // do something with the err.
    }

    Deprecated

    use the TransactionType export

Methods

Private #begin

Private #cleanup

Private #dispatchHooks

Private #forceCleanup

  • #forceCleanup(): Promise<void>

  • Kills the connection this transaction uses. Used as a last resort, for instance because COMMIT or ROLLBACK resulted in an error and the transaction is left in a broken state, and releasing the connection to the pool would be dangerous.

    Returns Promise<void>

Private #setDeferrable

afterCommit

afterRollback

afterTransaction

  • afterTransaction(callback): this

  • Adds a hook that is run after a transaction completes, no matter if it was committed or rolled back.

    Parameters

    Returns this

commit

getConnection

getConnectionIfExists

prepareEnvironment

  • prepareEnvironment(): Promise<void>

  • Called to acquire a connection to use and set the correct options on the connection. We should ensure all the environment that's set up is cleaned up in cleanup() below.

    Returns Promise<void>

rollback

setIsolationLevel

Settings

Member Visibility

Theme

On This Page

constructor#afterCommitHooks#afterHooks#afterRollbackHooks#connection#finished#name#savepointsidoptionsparentsequelizeLOCKfinishedrootTransactionISOLATION_LEVELSLOCKTYPES#begin#cleanup#dispatchHooks#forceCleanup#setDeferrableafterCommitafterRollbackafterTransactioncommitgetConnectiongetConnectionIfExistsprepareEnvironmentrollbacksetIsolationLevel