Sequelize-nodejs-8-Transactions

Sequelize supports two ways of using transactions:

Sequelize支持两种使用transactions的方法

• One which will automatically commit or rollback the transaction based on the result of a promise chain and, (if enabled) pass the transaction to all calls within the callback一是基于promise链的结果去自动提交或回滚事务，（如果可以）并在回调中传递事务给所有调用
• And one which leaves committing, rolling back and passing the transaction to the user.另一个则放弃提交、回滚和传递事务给用户

The key difference is that the managed transaction uses a callback that expects a promise to be returned to it while the unmanaged transaction returns a promise.

主要的不同在管理事务使用了promise被返回给它的回调，然而非管理交易也返回promise

Managed transaction (auto-callback)管理事务

Managed transactions handle committing or rolling back the transaction automagically. You start a managed transaction by passing a callback to sequelize.transaction.

管理事务将自动处理提交或回滚事务。你通过传递回调给sequelize.transaction来开始一个管理事务。

Notice how the callback passed to transaction returns a promise chain, and does not explicitly call t.commit() nor t.rollback(). If all promises in the returned chain are resolved successfully the transaction is committed. If one or several of the promises are rejected, the transaction is rolled back.

注意，回调怎么被传给事务将返回一个promise链，并不显式地调用 t.commit()或t.rollback()。如果在返回链中的所有的promise都成功解决，事务将被提交。如果一个或一些promise被拒绝，事务将回滚。

return sequelize.transaction(function (t) {

  // chain all your queries here. make sure you return them.
  return User.create({
    firstName: 'Abraham',
    lastName: 'Lincoln'
  }, {transaction: t}).then(function (user) {
    return user.setShooter({
      firstName: 'John',
      lastName: 'Boothe'
    }, {transaction: t});
  });

}).then(function (result) {
  // Transaction has been committed
  // result is whatever the result of the promise chain returned to the transaction callback
}).catch(function (err) {
  // Transaction has been rolled back
  // err is whatever rejected the promise chain returned to the transaction callback
});

Throw errors to rollback抛出错误给回滚

When using the managed transaction you should never commit or rollback the transaction manually. If all queries are successful, but you still want to rollback the transaction (for example because of a validation failure) you should throw an error to break and reject the chain:

当使用管理事务时，你绝不应该手动提交或回滚事务。如果所有的查询都成功了，但是你仍然想要回滚事务（比如因为验证失败），你应该抛出一个错误去停止事务，并拒绝加入链中：

return sequelize.transaction(function (t) {
  return User.create({
    firstName: 'Abraham',
    lastName: 'Lincoln'
  }, {transaction: t}).then(function (user) {
    // Woops, the query was successful but we still want to roll back!
    throw new Error();
  });
});

Automatically pass transactions to all queries自动传递事务给所有查询

In the examples above, the transaction is still manually passed, by passing { transaction: t } as the second argument. To automatically pass the transaction to all queries you must install the continuation local storage(CLS) module and instantiate a namespace in your own code:

在上面的例子中，事务都是手动传递，通过传递{ transaction: t }作为第二变量。为了自动传递事务给所有查询，你一定要安装continuation local storage(CLS) 模块并在你的代码中实例化一个命名空间

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

To enable CLS you must tell sequelize which namespace to use by using a static method of the sequelize constructor:

为了使用CLS，你一定要通过sequelize构造函数的静态方法告诉sequelize使用的是那个命名空间：

const Sequelize = require('sequelize');
Sequelize.useCLS(namespace);

new Sequelize(....);

Notice, that the useCLS() method is on the constructor, not on an instance of sequelize. This means that all instances will share the same namespace, and that CLS is all-or-nothing - you cannot enable it only for some instances.

注意，useCLS()方法是在构造函数中，而不是在sequelize中的。这意味着所有实例都可以共享这个命名空间，CLS是all-or-nothing的-你不可能只能在一些实例中使用它

CLS works like a thread-local storage for callbacks. What this means in practice is that different callback chains can access local variables by using the CLS namespace. When CLS is enabled sequelize will set the transactionproperty on the namespace when a new transaction is created. Since variables set within a callback chain are private to that chain several concurrent transactions can exist at the same time:

CLS像回调的本地线程存储一样工作。这意味着在实际中，当事务创建时不同的回调链能够通过CLS命名空间调用本地变量。因此回调链中的变量集对于该链都是私有的，多个并发事务可以同时存在；

sequelize.transaction(function (t1) {
  namespace.get('transaction') === t1; // true
});

sequelize.transaction(function (t2) {
  namespace.get('transaction') === t2; // true
});

In most case you won't need to access namespace.get('transaction') directly, since all queries will automatically look for a transaction on the namespace:

在更多情况下，我们不需要直接访问namespace.get('transaction')，因此所有查询将自动在命名空间中查找事务

sequelize.transaction(function (t1) {
  // With CLS enabled, the user will be created inside the transaction
  return User.create({ name: 'Alice' });
});

After you've used Sequelize.useCLS() all promises returned from sequelize will be patched to maintain CLS context. CLS is a complicated subject - more details in the docs for cls-bluebird, the patch used to make bluebird promises work with CLS.

在你使用 Sequelize.useCLS()之后，所有从sequelize中返回的promises将被修补去保持CLS上下文。CLS是复杂的主题-更多细节在文档cls-bluebird

Note: _CLS only supports async/await, at the moment, when using cls-hooked package. Although, cls-hookedrelies on experimental APIasync_hooks_

Concurrent/Partial transactions并发/局部事务

You can have concurrent transactions within a sequence of queries or have some of them excluded from any transactions. Use the {transaction: } option to control which transaction a query belong to:

在一系列查询中你可以有并发事务或一部分被事务排除

Warning:SQLite does not support more than one transaction at the same time.

SQLite不支持一次超过一个事务

Without CLS enabled

sequelize.transaction(function (t1) {
  return sequelize.transaction(function (t2) {
    // With CLS enable, queries here will by default use t2
    // Pass in the `transaction` option to define/alter the transaction they belong to.
    return Promise.all([
        User.create({ name: 'Bob' }, { transaction: null }),
        User.create({ name: 'Mallory' }, { transaction: t1 }),
        User.create({ name: 'John' }) // this would default to t2
    ]);
  });
});

Isolation levels

The possible isolations levels to use when starting a transaction:

在开始事务是可能的隔离级别：

Sequelize.Transaction.ISOLATION_LEVELS.READ_UNCOMMITTED // "READ UNCOMMITTED"
Sequelize.Transaction.ISOLATION_LEVELS.READ_COMMITTED // "READ COMMITTED"
Sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ  // "REPEATABLE READ"
Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE // "SERIALIZABLE"

By default, sequelize uses the isolation level of the database. If you want to use a different isolation level, pass in the desired level as the first argument:

默认sequelize使用数据库的隔离级别。如果你想要使用不同的隔离级别，传递你心仪的级别作为第一变量

return sequelize.transaction({
  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
  }, function (t) {

  // your transactions

  });

Note:The SET ISOLATION LEVEL queries are not logged in case of MSSQL as the specified isolationLevel is passed directly to tedious

Unmanaged transaction (then-callback)非管理事务

Unmanaged transactions force you to manually rollback or commit the transaction. If you don't do that, the transaction will hang until it times out. To start an unmanaged transaction, call sequelize.transaction()without a callback (you can still pass an options object) and call then on the returned promise. Notice that commit() and rollback() returns a promise.

非管理事务强迫你手动地回滚或提交事务。如果你不想这么做，事务将被挂起直至超时。为了开始非管理事务，调用没有回调的sequelize.transaction()（你还是可以传递选项options对象的）并在返回的promise中调用then。注意 commit()和rollback()都返回promise

return sequelize.transaction().then(function (t) {
  return User.create({
    firstName: 'Bart',
    lastName: 'Simpson'
  }, {transaction: t}).then(function (user) {
    return user.addSibling({
      firstName: 'Lisa',
      lastName: 'Simpson'
    }, {transaction: t});
  }).then(function () {
    return t.commit();
  }).catch(function (err) {
    return t.rollback();
  });
});

Options

The transaction method can be called with an options object as the first argument, that allows the configuration of the transaction.

事务方法可以带着options对象作为第一参数来被调用，options允许事务的配置

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

The following options (with their default values) are available:

下面的options（带着默认值）是可用的：

{
  autocommit: true,
  isolationLevel: 'REPEATABLE_READ',
  deferrable: 'NOT DEFERRABLE' // implicit default of postgres
}

The isolationLevel can either be set globally when initializing the Sequelize instance or locally for every transaction:

当初始化Sequelize示例时，对每个事务isolationLevel要么被设置为全局的，要么是局部的

// globally
new Sequelize('db', 'user', 'pw', {
  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
});

// locally
sequelize.transaction({
  isolationLevel: Sequelize.Transaction.ISOLATION_LEVELS.SERIALIZABLE
});

The deferrable option triggers an additional query after the transaction start that optionally set the constraint checks to be deferred or immediate. Please note that this is only supported in PostgreSQL.

在????开始之后，deferrable选项触发额外的查询，将选择性地将限制查看设置为deferred或immediate。

请注明这个只在PostgreSQL中使用

sequelize.transaction({
  // to defer all constraints:
  deferrable: Sequelize.Deferrable.SET_DEFERRED,

  // to defer a specific constraint:
  deferrable: Sequelize.Deferrable.SET_DEFERRED(['some_constraint']),

  // to not defer constraints:
  deferrable: Sequelize.Deferrable.SET_IMMEDIATE
})

Usage with other sequelize methods

The transaction option goes with most other options, which are usually the first argument of a method. For methods that take values, like .create, .update(), .updateAttributes() etc. transaction should be passed to the option in the second argument. If unsure, refer to the API documentation for the method you are using to be sure of the signature.

事务选项有着很多其他的options，通常都是方法的第一参数。比如获取值的方法像.create, .update(), .updateAttributes()等，事务应该在第二个参数中传递option。如果不确定，就参考API文档。