mongodb多文档事务：两段提交(<4.0)/4.0多文档事务

mongodb summary_2018/10

1、概述

• mongodb4.0前对单个文档的操作是原子性的(但可以使用建模的方式保证多个子文档操作的原子性)，在4.0支持了对复制集的多文档事务的支持。因此为了实现多文档事务(多个操作)，在4.0之前我们可以使用两段提交的方式，而在4.0及以后可以直接使用官方的多文档事务。
• 这里可能有一些同学可能不是很理解这里的事务，事务被定义为一系列操作序列，要么全部完成，要么都不做，即遵循ACID特性。对于单文档来说，只有一个操作，遵循ACID特性，也是可以理解为事务，只是不是严格上的事务；对于多文档就比较好理解了，进行一系列操作，形成事务。

2、建模实现多文档原子性（<4.0）

• 这个在上面已经说了，就是把需要操作的文档放在子文档里，保证了多文档的原子性，当然有很大的局限性。

3、两阶段提交实现多文档事务（<4.0）

• 两阶段提交协议（Two-phase Commit，2PC）经常被用来实现分布式事务。一般分为协调器和若干事务执行者两种角色，这里的事务执行者就是具体的数据库，抽象点可以说是可以控制给数据库的程序。 协调器可以和事务执行器在一台机器上。
  
  • 在分布式系统中，每个节点虽然可以知晓自己的操作时成功或者失败，却无法知道其他节点的操作的成功或失败。当一个事务跨越多个节点时，为了保持事务的ACID特性，需要引入一个作为协调者的组件来统一掌控所有节点(称作参与者)。当所有的节点都成功是进行提交，当有失败发生时进行回滚。
  • 2PC比较简单，当然也有一定的缺点：

1、涉及协调器和节点多次通信，通信时间较长。
2、因此整个事务的持续时间也变长，对资源的占有时间也会变长，会产生较长的等待。

• 下面我们运用两阶段提交来实现mongo多文档事务，对文档的操作当作分布式中的节点，并通过一个协调者来掌控所有节点,我们以官方文档中的例子为例，但是好像4.0出来就没有了，因为没有必要了：

## 假设一个场景
从账户A转钱到账户B，在关系型数据库中，我们可以在一个事务中完成，但在小于4.0的mongo中，我们需要使用2PC完成。
## 使用2PC来完成这个事务
// 初始化A/B两个账户
db.accounts.insert(
   [
     { _id: "A", balance: 1000, pendingTransactions: [] },
     { _id: "B", balance: 1000, pendingTransactions: [] }
   ]
)
// 初始化一个协调者来协调所有参与的文档，在mongo中我们使用一个transactions集合，当需要完成一个事务时，插入一条数据，包含如下字段：
source 和 destination 字段，与 accounts 集合里的 _id 字段相关联的。
value 字段，指定影响 source 账户和 destination 账户 balance 的传输量，
state 字段，反应传输的当前状态。state 字段可以具有值 initial ， pending ， applied ， done ， canceling 和 canceled 。
lastModified 字段，反映了最后修改的日期。
db.transactions.insert(
    { _id: 1, source: "A", destination: "B", value: 100, state: "initial", lastModified: new Date() }
)
// 从协调器中取出需要完成的事务，即状态为initial
var t = db.transactions.findOne( { state: "initial" } )
// 处理取出来的事务
1、Update transaction state to pending
db.transactions.update(
    { _id: t._id, state: "initial" },
    {
      $set: { state: "pending" },
      $currentDate: { lastModified: true }
    }
)
2、Apply the transaction to both accounts.（并没有对资源保持持续占有，只保证不会重复操作，若要持续占有可以判定：pendingTransactions: []时）
db.accounts.update(
   { _id: t.source, pendingTransactions: { $ne: t._id } },
   { $inc: { balance: -t.value }, $push: { pendingTransactions: t._id } }
)
db.accounts.update(
   { _id: t.destination, pendingTransactions: { $ne: t._id } },
   { $inc: { balance: t.value }, $push: { pendingTransactions: t._id } }
)
3、Update transaction state to applied
db.transactions.update(
   { _id: t._id, state: "pending" },
   {
     $set: { state: "applied" },
     $currentDate: { lastModified: true }
   }
)
4、Update both accounts’ list of pending transactions.
db.accounts.update(
   { _id: t.source, pendingTransactions: t._id },
   { $pull: { pendingTransactions: t._id } }
)
db.accounts.update(
   { _id: t.destination, pendingTransactions: t._id },
   { $pull: { pendingTransactions: t._id } }
)
// 在协调器中标记事务完成
db.transactions.update(
   { _id: t._id, state: "applied" },
   {
     $set: { state: "done" },
     $currentDate: { lastModified: true }
   }
)

• 虽然我们在上面完成了一个事务，但是事务最重要的地方却还没有提到，即事务失败时对事务进行回滚/撤销保证数据的一致性：

## Applied 状态的事务
这种情况，最好不要回滚事务，而是创建一个相同的事务来抵消该事务
## Pending 状态的事务
1、Update transaction state to canceling.
2、Undo the transaction on both accounts.
3、Update transaction state to canceled.
Tips：基本和进行事务的方式相同，进行2PC
## 其它注意点
1、在2PC的过程中，每一步都需要判定是否成功，根据具体情况对事务进行回滚/重试
2、如何保证在整个过程中，保证对资源的持续占有，其实上述过程中并没有保证对资源的持续占有，只保证了避免重复操作。

• 上面只是最简单的情况，然而实际情况其实更加复杂
  
  • 比如如果要操作多个文档，可能需要结合建模使用，或者当转账时余额是否足够等等

4、4.0多文档事务

• 上面两种方式都有比较大的局限性，实现完全的事务支持还是比较麻烦，较为复杂的可能并不能实现，因此mongo在4.0提供了对复制集的事务支持，完全意义上的事务，计划在4.2提供对分片事务的支持。
• 我们来看看4.0事务的简单了解和使用：

// 看一下一个其它人写的例子
//app.js
(async function()  {
  // 连接DB
  const { MongoClient } = require('mongodb');
  const uri = 'mongodb://localhost:1301/dbfour';
  const client = await MongoClient.connect(uri, { useNewUrlParser: true });
  const db = client.db();
  await db.dropDatabase();
  console.log('(1) 首先 删库 dbfour, then 跑路\n')
  // 插入两个账户并充值一些金额
  await db.collection('Account').insertMany([
    { name: 'A', balance: 50 },
    { name: 'B', balance: 10 }
  ]);
  console.log('(2) 执行 insertMany,  A 充值 50, B 充值 10\n')
  await transfer('A', 'B', 10); // 成功
  console.log('(3) 然后 A 给 B 转账 10\n')
  try {
    // 余额不足 转账失败
    console.log('(4) A 再次转账给 B 50\n')
    await transfer('A', 'B', 50);
  } catch (error) {
    //error.message; // "Insufficient funds: 40"
    console.log(error.message)
    console.log('\n(5) A 余额不够啊，所以这次转账操作不成功')
  }
  // 转账逻辑
  async function transfer(from, to, amount) {
    const session = client.startSession();
    session.startTransaction();
    try {
      const opts = { session, returnOriginal: false };
      const A = await db.collection('Account').
        findOneAndUpdate({ name: from }, { $inc: { balance: -amount } }, opts).
        then(res => res.value);
      if (A.balance < 0) {
        // 如果 A 的余额不足，转账失败 中止事务
        // `session.abortTransaction()` 会撤销上面的 `findOneAndUpdate()` 操作
        throw new Error('Insufficient funds: ' + (A.balance + amount));
      }
      const B = await db.collection('Account').
        findOneAndUpdate({ name: to }, { $inc: { balance: amount } }, opts).
        then(res => res.value);
      await session.commitTransaction();
      session.endSession();
      return { from: A, to: B };
    } catch (error) {
      // 如果错误发生，中止全部事务并回退到修改之前
      await session.abortTransaction();
      session.endSession();
      throw error; //使其调用者 catch error
    }
  }
})()
Tips:When using the drivers, you must pass the session to each operation in the transaction.

5、参考文档

• perform-two-phase-commits
• 理解分布式事务的两阶段提交2pc
• MongoDB4 事务