Transactions - 事务

Sequelize 支持两种使用事务的方法：

  • 一个将根据 promise 链的结果自动提交或回滚事务，（如果启用）用回调将该事务传递给所有调用
  • 而另一个 leave committing，回滚并将事务传递给用户。

主要区别在于托管事务使用一个回调，对非托管事务而言期望 promise 返回一个 promise 的结果。

托管事务（auto-callback）

托管事务自动处理提交或回滚事务。你可以通过将回调传递给 sequelize.transaction 来启动托管事务。

注意回传传递给 transaction 的回调是否是一个 promise 链，并且没有明确地调用t.commit（）或 t.rollback()。 如果返回链中的所有 promise 都已成功解决，则事务被提交。 如果一个或几个 promise 被拒绝，事务将回滚。

  1. return sequelize.transaction(function (t) {
  3.   // 在这里链接您的所有查询。 确保你返回他们。
  4.   return User.create({
  5.     firstName: 'Abraham',
  6.     lastName: 'Lincoln'
  7.   }, {transaction: t}).then(function (user) {
  8.     return user.setShooter({
  9.       firstName: 'John',
  10.       lastName: 'Boothe'
  11.     }, {transaction: t});
  12.   });
  14. }).then(function (result) {
  15.   // 事务已被提交
  16.   // result 是 promise 链返回到事务回调的结果
  17. }).catch(function (err) {
  18.   // 事务已被回滚
  19.   // err 是拒绝 promise 链返回到事务回调的错误
  20. });

抛出错误到回滚

使用托管事务时，你应该 永不 手动提交或回滚事务。 如果所有查询都成功，但您仍然希望回滚事务（例如因为验证失败），则应该抛出一个错误来断开和拒绝链接：

  1. return sequelize.transaction(function (t) {
  2.   return User.create({
  3.     firstName: 'Abraham',
  4.     lastName: 'Lincoln'
  5.   }, {transaction: t}).then(function (user) {
  6.     // 查询成功，但我们仍然想回滚！
  7.     throw new Error();
  8.   });
  9. });

自动将事务传递给所有查询

在上面的例子中，事务仍然是手动传递的，通过传递 {transaction:t} 作为第二个参数。 要自动将事务传递给所有查询，您必须安装 continuation local storage (CLS) 模块，并在您自己的代码中实例化一个命名空间：

  1. const cls = require('continuation-local-storage'),
  2.     namespace = cls.createNamespace('my-very-own-namespace');

要启用CLS，您必须通过使用sequelize构造函数的静态方法来告诉Sequelize要使用的命名空间：

  1. const Sequelize = require('sequelize');
  2. Sequelize.useCLS(namespace);
  4. new Sequelize(....);

请注意， useCLS() 方法在 构造函数 上，而不是在 sequelize 的实例上。 这意味着所有实例将共享相同的命名空间，并且 CLS 是全部或全无方式 - 你不能仅在某些实例中启用它。

CLS 的工作方式就像一个用于回调的本地线程存储。 这在实践中意味着不同的回调链可以通过使用 CLS 命名空间来访问局部变量。 当启用 CLS 时，创建新事务时，Sequelize 将在命名空间上设置 transaction 属性。 由于回调链中设置的变量对该链是私有的，因此可以同时存在多个并发事务：

  1. sequelize.transaction(function (t1) {
  2.   namespace.get('transaction') === t1; // true
  3. });
  5. sequelize.transaction(function (t2) {
  6.   namespace.get('transaction') === t2; // true
  7. });

在大多数情况下，你不需要直接访问 namespace.get('transaction')，因为所有查询都将自动在命名空间中查找事务：

  1. sequelize.transaction(function (t1) {
  2.   // 启用 CLS 后，将在事务中创建用户
  3.   return User.create({ name: 'Alice' });
  4. });

在使用 Sequelize.useCLS() 后，从 sequelize 返回的所有 promise 将被修补以维护 CLS 上下文。 CLS 是一个复杂的课题 - cls-bluebird的文档中有更多细节，用于使 bluebird promise 的补丁与CLS一起工作。

注意: 当使用 cls-hooked 软件包的时候，CLS 仅支持 async/await. 即使, cls-hooked 依靠 试验性的 API async_hooks

并行/部分事务

你可以在一系列查询中执行并发事务，或者将某些事务从任何事务中排除。 使用 {transaction: } 选项来控制查询所属的事务：

警告: SQLite 不能同时支持多个事务。

不启用CLS

  1. sequelize.transaction(function (t1) {
  2.   return sequelize.transaction(function (t2) {
  3.     // 启用CLS，这里的查询将默认使用 t2    
  4.     // 通过 `transaction` 选项来定义/更改它们所属的事务。
  5.         return Promise.all([
  6.         User.create({ name: 'Bob' }, { transaction: null }),
  7.         User.create({ name: 'Mallory' }, { transaction: t1 }),
  8.         User.create({ name: 'John' }) // 这将默认为 t2
  9.     ]);
  10.   });
  11. });

隔离等级

启动事务时可能使用的隔离等级：

  1. Sequelize.Transaction.ISOLATION_LEVELS.READ_UNCOMMITTED // "READ UNCOMMITTED"
  2. Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED // "READ COMMITTED"
  3. Sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ  // "REPEATABLE READ"
  4. Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE // "SERIALIZABLE"

默认情况下，sequelize 使用数据库的隔离级别。 如果要使用不同的隔离级别，请传入所需级别作为第一个参数：

  1. return sequelize.transaction({
  2.   isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
  3.   }, function (t) {
  5.   //  你的事务
  7.   });

注意: 在MSSQL的情况下，SET ISOLATION LEVEL 查询不被记录, 指定的 isolationLevel 直接传递到 tedious

非托管事务（then-callback）

非托管事务强制您手动回滚或提交交易。 如果不这样做，事务将挂起，直到超时。 要启动非托管事务，请调用 sequelize.transaction() 而不用 callback（你仍然可以传递一个选项对象），并在返回的 promise 上调用 then。 请注意，commit() 和 rollback() 返回一个 promise。

  1. return sequelize.transaction().then(function (t) {
  2.   return User.create({
  3.     firstName: 'Bart',
  4.     lastName: 'Simpson'
  5.   }, {transaction: t}).then(function (user) {
  6.     return user.addSibling({
  7.       firstName: 'Lisa',
  8.       lastName: 'Simpson'
  9.     }, {transaction: t});
  10.   }).then(function () {
  11.     return t.commit();
  12.   }).catch(function (err) {
  13.     return t.rollback();
  14.   });
  15. });

参数

可以使用options对象作为第一个参数来调用transaction方法，这允许配置事务。

  1. return sequelize.transaction({ /* options */ });

以下选项（使用默认值）可用：

  1. {
  2.   autocommit: true,
  3.   isolationLevel: 'REPEATABLE_READ',
  4.   deferrable: 'NOT DEFERRABLE' // postgres 的默认设置
  5. }

在为 Sequelize 实例或每个局部事务初始化时，isolationLevel可以全局设置：

  1. // 全局
  2. new Sequelize('db', 'user', 'pw', {
  3.   isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
  4. });
  6. // 局部
  7. sequelize.transaction({
  8.   isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
  9. });

deferrable 选项在事务开始后触发一个额外的查询，可选地将约束检查设置为延迟或立即。 请注意，这仅在PostgreSQL中受支持。

  1. sequelize.transaction({
  2.   // 推迟所有约束：
  3.   deferrable: Sequelize.Deferrable.SET_DEFERRED,
  5.   // 推迟具体约束：
  6.   deferrable: Sequelize.Deferrable.SET_DEFERRED(['some_constraint']),
  8.   // 不推迟约束：
  9.   deferrable: Sequelize.Deferrable.SET_IMMEDIATE
  10. })

使用其他 Sequelize 方法

transaction 选项与其他大多数选项一起使用，通常是方法的第一个参数。
对于取值的方法，如 .create, .update(), .updateAttributes() 等。应该传递给第二个参数的选项。
如果不确定，请参阅API文档中的用于确定签名的方法。