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

id options parent sequelize

Accessors

finished LOCK rootTransaction ISOLATION_LEVELS LOCK TYPES

Methods

afterCommit afterRollback afterTransaction commit getConnection getConnectionIfExists prepareEnvironment rollback setIsolationLevel

Constructors

constructor

Properties

Readonlyid

id: string

Readonlyoptions

options: Readonly<NormalizedTransactionOptions>

Readonlyparent

parent: null | Transaction

sequelize

sequelize: Sequelize

Accessors

finished

LOCK

rootTransaction

StaticISOLATION_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

StaticLOCK

  • 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

StaticTYPES

  • 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

afterCommit

afterRollback

afterTransaction

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

On This Page

Constructors
Properties
Accessors
Methods