Saltar al contenido principal
Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Transacciones

Creación y uso de transacciones​

Las transacciones se crean usando DataSource o EntityManager. Ejemplos:

await myDataSource.transaction(async (transactionalEntityManager) => {
    // execute queries using transactionalEntityManager
})

o

await myDataSource.manager.transaction(async (transactionalEntityManager) => {
    // execute queries using transactionalEntityManager
})

Todo lo que quieras ejecutar en una transacción debe realizarse en una devolución de llamada:

await myDataSource.manager.transaction(async (transactionalEntityManager) => {
    await transactionalEntityManager.save(users)
    await transactionalEntityManager.save(photos)
    // ...
})

La restricción más importante al trabajar con transacciones es SIEMPRE usar la instancia proporcionada del gestor de entidades - en este ejemplo, transactionalEntityManager. NO USES EL GESTOR DE ENTIDADES GLOBAL. Todas las operaciones DEBEN ejecutarse usando el gestor de entidades transaccional proporcionado.

Especificación del nivel de aislamiento​

Puedes especificar el nivel de aislamiento para la transacción proporcionándolo como primer parámetro:

await myDataSource.manager.transaction(
    "SERIALIZABLE",
    (transactionalEntityManager) => {},
)

Niveles de aislamiento admitidos​

Las implementaciones de niveles de aislamiento no son agnósticas en todas las bases de datos. Cada controlador declara qué niveles admite, y TypeORM lanzará un error si solicitas un nivel no admitido.

CockroachDB

  • READ COMMITTED — requires the cluster setting sql.txn.read_committed_isolation.enabled, which is enabled by default in recent versions
  • REPEATABLE READ — requires the cluster setting sql.txn.repeatable_read_isolation.enabled, which is disabled by default (introduced in v24.3.0)
  • SERIALIZABLE (default)

CockroachDB maps weaker SQL isolation requests to stronger levels. The fallback behavior depends on the corresponding cluster settings. For example, when you request READ UNCOMMITTED, READ COMMITTED or REPEATABLE READ via SQL (e.g. BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED), CockroachDB accepts the syntax and may run the transaction at a stricter level instead:

  • READ COMMITTED → runs as:
    • SERIALIZABLE if sql.txn.read_committed_isolation.enabled is false and sql.txn.repeatable_read_isolation.enabled is false
    • REPEATABLE READ if sql.txn.repeatable_read_isolation.enabled is true and sql.txn.read_committed_isolation.enabled is false
  • READ UNCOMMITTED → runs as:
    • SERIALIZABLE if sql.txn.read_committed_isolation.enabled is false and sql.txn.repeatable_read_isolation.enabled is false
    • READ COMMITTED if sql.txn.read_committed_isolation.enabled is true
    • REPEATABLE READ if sql.txn.repeatable_read_isolation.enabled is true and sql.txn.read_committed_isolation.enabled is false
  • REPEATABLE READ → runs as SERIALIZABLE if sql.txn.repeatable_read_isolation.enabled is false
Learn more

Nivel de aislamiento predeterminado​

Puedes configurar un nivel de aislamiento predeterminado para todas las transacciones estableciendo isolationLevel en las opciones de DataSource:

const dataSource = new DataSource({
    type: "postgres",
    isolationLevel: "SERIALIZABLE",
    // ...
})

Cuando se establece, todas las transacciones iniciadas sin un nivel de aislamiento explícito usarán este valor predeterminado. Un nivel de aislamiento explícito pasado a transaction() o startTransaction() sobrescribirá el valor predeterminado.

Uso de QueryRunner para crear y controlar el estado de conexiones únicas​

QueryRunner proporciona una única conexión a la base de datos. Las transacciones se organizan mediante gestores de consultas (query runners). Las transacciones individuales solo pueden establecerse en un único gestor de consultas. Puedes crear manualmente una instancia de QueryRunner y usarla para controlar manualmente el estado de las transacciones. Ejemplo:

// create a new query runner
const queryRunner = dataSource.createQueryRunner()

// establish real database connection using our new query runner
await queryRunner.connect()

// now we can execute any queries on a query runner, for example:
await queryRunner.query("SELECT * FROM users")

// we can also access entity manager that works with connection created by a query runner:
const users = await queryRunner.manager.find(User)

// lets now open a new transaction:
await queryRunner.startTransaction()

try {
    // execute some operations on this transaction:
    await queryRunner.manager.save(user1)
    await queryRunner.manager.save(user2)
    await queryRunner.manager.save(photos)

    // commit transaction now:
    await queryRunner.commitTransaction()
} catch (err) {
    // since we have errors let's rollback changes we made
    await queryRunner.rollbackTransaction()
} finally {
    // you need to release query runner which is manually created:
    await queryRunner.release()
}

Existen 3 métodos para controlar transacciones en QueryRunner:

  • startTransaction - inicia una nueva transacción dentro de la instancia del gestor de consultas (query runner).

  • commitTransaction - confirma todos los cambios realizados usando la instancia del gestor de consultas.

  • rollbackTransaction - revierte todos los cambios realizados usando la instancia del gestor de consultas.

Aprende más sobre Query Runner.