Transactions

    交易不会产生额外费用。您只需为作为事务一部分使用的读取和写入 IOs 付费。

    要使用事务功能，您需要满足以下要求：

    • 您必须使用 Amazon DocumentDB 4.0 引擎。

    • 您必须使用与 MongoDB 4.0 或更高版本兼容的驱动程序。

    最佳实践

    下面是一些最佳做法，以便您能充分利用与 Amazon DocumentDB 的事务。

    • 在事务完成后，始终提交或中止事务。使事务保持在不完整的状态会联系数据库资源，并可能导致写冲突。

    • 建议将事务保持在所需的最小命令数。如果您的事务具有多个可拆分为多个较小事务的语句，则建议这样做以降低超时的可能性。始终旨在创建短事务，而不是长时间运行的读取。

    Limitations

    • Amazon DocumentDB 不支持在事务中使用游标。

    • Amazon DocumentDB 无法在事务中创建新集合，并且无法针对非现有集合进行查询/更新。

    • 文档级写入锁定受 1 分钟超时的约束，用户无法配置该超时。

    • 不支持可重试写入、可重试提交和可重试中止。

    • 每个 Amazon DocumentDB 实例对于同时在实例上打开的并发事务的数量都有一个上限。有关限制，请参阅实例限制。

    • 对于给定事务，事务日志大小必须小于 32MB。

    • Amazon DocumentDB 在事务中支持 ，但并非所有驱动程序都支持此功能。一种替代方法是使用 countDocuments() API，它将计数查询转换为客户端的聚合查询。

    • 事务具有一分钟执行限制，会话超时为 30 分钟。如果事务超时，则该事务将中止，并且现有事务的会话中发出的任何后续命令将生成以下错误：

    在 Amazon DocumentDB 4.0 中支持事务时，添加了其他 CloudWatch 指标，以帮助您监控事务。

    新 CloudWatch 指标

    • DatabaseTransactions：在一分钟期间内进行的打开事务数。

    • DatabaseTransactionsAborted：在一分钟周期内执行的已中止事务数。

    • DatabaseTransactionsMax：一分钟周期内打开的事务的最大数量。

    • TransactionsAborted：一分钟内在实例上中止的事务数。

    • TransactionsCommitted：一分钟内在实例上提交的事务数。

    • TransactionsOpen：在以一分钟为间隔在实例上打开的事务数。

    • TransactionsOpenMax：在一分钟内在实例上打开的事务的最大数量。

    • TransactionsStarted：在一分钟内在实例上启动的事务数。

    注意

    有关 CloudWatch 的更多 Amazon DocumentDB 指标，请转到 。

    此外，新字段已添加到 currentOp lsid、transactionThreadId 和“idle transaction”和 serverStatus 事务的新状态：currentActive、currentInactive、currentOpen、totalAborted、totalCommitted 和 totalStarted。

    事务隔离级别

    在启动事务时，您能够同时指定 readConcern 和 writeConcern，如以下示例所示：

    mySession.startTransaction({readConcern: {level: 'snapshot'}, writeConcern: {w: 'majority'}});

    对于 readConcern，Amazon DocumentDB 默认情况下支持快照隔离。如果指定了本地、可用或大多数 readConcern，Amazon DocumentDB 会将 readConcern 级别升级到快照。Amazon DocumentDB 不支持可线性的 readConcern，并且指定此类读取问题会导致错误。

    对于 writeConcern，默认情况下，Amazon DocumentDB 支持大多数写入 quorum，并在跨三个 AZs 保留四个数据副本时实现写入 quorum。 如果指定了较低的 writeConcern，Amazon DocumentDB 会将 writeConcern 升级到大多数。此外，会记录所有 Amazon DocumentDB 写入，并且无法禁用日志。

    使用案例

    在本节中，我们将演练事务的两个使用案例：多语句和多集合。

    Amazon DocumentDB 事务是多语句，这意味着您可以编写一个跨多个语句以及显式提交或回滚的事务。您可以将 insert、update、update 和 findAndModify 操作分组为单个原子操作。

    2. // *** Transfer $500 from Alice to Bob inside a transaction: Success Scenario***
    3. // Setup bank account for Alice and Bob. Each have $1000 in their account
    5. var databaseName = "bank";
    6. var collectionName = "account";
    7. var amountToTransfer = 500;
    9. var session = db.getMongo().startSession({causalConsistency: false});   
    10. var bankDB = session.getDatabase(databaseName);
    11. var accountColl = bankDB[collectionName];
    12. accountColl.drop();
    14. accountColl.insert({name: "Alice", balance: 1000});
    15. accountColl.insert({name: "Bob", balance: 1000});
    17. session.startTransaction();
    19. // deduct $500 from Alice's account
    20. var aliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    21. var newAliceBalance = aliceBalance - amountToTransfer;
    22. accountColl.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    23. var findAliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    25. // add $500 to Bob's account
    26. var bobBalance = accountColl.find({"name": "Bob"}).next().balance;
    27. var newBobBalance = bobBalance + amountToTransfer;
    28. accountColl.update({"name": "Bob"},{"$set": {"balance": newBobBalance}});
    29. var findBobBalance = accountColl.find({"name": "Bob"}).next().balance;
    31. session.commitTransaction();
    33. accountColl.find();
    35. // *** Transfer $500 from Alice to Bob inside a transaction: Failure Scenario***
    37. // Setup bank account for Alice and Bob. Each have $1000 in their account
    38. var databaseName = "bank";
    39. var collectionName = "account";
    40. var amountToTransfer = 500;
    42. var session = db.getMongo().startSession({causalConsistency: false});   
    43. var bankDB = session.getDatabase(databaseName);
    44. var accountColl = bankDB[collectionName];
    45. accountColl.drop();
    47. accountColl.insert({name: "Alice", balance: 1000});
    48. accountColl.insert({name: "Bob", balance: 1000});
    50. session.startTransaction();
    52. // deduct $500 from Alice's account
    53. var aliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    54. var newAliceBalance = aliceBalance - amountToTransfer;
    55. accountColl.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    56. var findAliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    58. session.abortTransaction();
    59.

    多集合事务

    我们的事务也是多集合事务，这意味着它们可用于在单个事务内以及跨多个集合执行多个操作。这将提供一致的数据视图并维护数据的完整性。当您将命令提交为单个 <> 时，事务是“要么全有要么全无”执行—，因为前者要么全部成功，要么全部失败。

    下面是使用同一个方案的多收集事务的示例，以及来自多语句事务示例的数据。

    2. // *** Transfer $500 from Alice to Bob inside a transaction: Success Scenario***
    4. // Setup bank account for Alice and Bob. Each have $1000 in their account
    5. var amountToTransfer = 500;
    6. var collectionName = "account";
    8. var session = db.getMongo().startSession({causalConsistency: false});   
    9. var accountCollInBankA = session.getDatabase("bankA")[collectionName];
    10. var accountCollInBankB = session.getDatabase("bankB")[collectionName];
    12. accountCollInBankA.drop();
    13. accountCollInBankB.drop();
    15. accountCollInBankA.insert({name: "Alice", balance: 1000});
    16. accountCollInBankB.insert({name: "Bob", balance: 1000});
    18. session.startTransaction();
    20. // deduct $500 from Alice's account
    21. var aliceBalance = accountCollInBankA.find({"name": "Alice"}).next().balance;
    22. var newAliceBalance = aliceBalance - amountToTransfer;
    23. accountCollInBankA.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    24. var findAliceBalance = accountCollInBankA.find({"name": "Alice"}).next().balance;
    26. // add $500 to Bob's account
    27. var bobBalance = accountCollInBankB.find({"name": "Bob"}).next().balance;
    28. var newBobBalance = bobBalance + amountToTransfer;
    29. accountCollInBankB.update({"name": "Bob"},{"$set": {"balance": newBobBalance}});
    30. var findBobBalance = accountCollInBankB.find({"name": "Bob"}).next().balance;
    32. session.commitTransaction();
    34. accountCollInBankA.find(); // Alice holds $500 in bankA
    35. accountCollInBankB.find(); // Bob holds $1500 in bankB
    37. // *** Transfer $500 from Alice to Bob inside a transaction: Failure Scenario***
    39. // Setup bank account for Alice and Bob. Each have $1000 in their account
    40. var collectionName = "account";
    41. var amountToTransfer = 500;
    43. var session = db.getMongo().startSession({causalConsistency: false});   
    44. var accountCollInBankA = session.getDatabase("bankA")[collectionName];
    45. var accountCollInBankB = session.getDatabase("bankB")[collectionName];
    47. accountCollInBankA.drop();
    48. accountCollInBankB.drop();
    50. accountCollInBankA.insert({name: "Alice", balance: 1000});
    51. accountCollInBankB.insert({name: "Bob", balance: 1000});
    53. session.startTransaction();
    55. // deduct $500 from Alice's account
    56. var aliceBalance = accountCollInBankA.find({"name": "Alice"}).next().balance;
    57. var newAliceBalance = aliceBalance - amountToTransfer;
    58. accountCollInBankA.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    59. var findAliceBalance = accountCollInBankA.find({"name": "Alice"}).next().balance;
    61. // add $500 to Bob's account
    62. var bobBalance = accountCollInBankB.find({"name": "Bob"}).next().balance;
    63. var newBobBalance = bobBalance + amountToTransfer;
    64. accountCollInBankB.update({"name": "Bob"},{"$set": {"balance": newBobBalance}});
    65. var findBobBalance = accountCollInBankB.find({"name": "Bob"}).next().balance;
    67. session.abortTransaction();
    69. accountCollInBankA.find(); // Alice holds $1000 in bankA
    70. accountCollInBankB.find(); // Bob holds $1000 in bankB
    71.

    回调 API 仅适用于 4.2 版以上的驱动程序。

    Javascript

    以下代码演示如何将 Amazon DocumentDB 事务 API 与 Javascript 结合使用。

    1. // *** Transfer $500 from Alice to Bob inside a transaction: Success ***
    2. // Setup bank account for Alice and Bob. Each have $1000 in their account
    3. var databaseName = "bank";
    4. var collectionName = "account";
    5. var amountToTransfer = 500;
    7. var session = db.getMongo().startSession({causalConsistency: false});  
    8. var bankDB = session.getDatabase(databaseName);
    9. var accountColl = bankDB[collectionName];
    10. accountColl.drop();
    12. accountColl.insert({name: "Alice", balance: 1000});
    13. accountColl.insert({name: "Bob", balance: 1000});
    15. session.startTransaction();
    17. // deduct $500 from Alice's account
    18. var aliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    19. assert(aliceBalance >= amountToTransfer);
    20. var newAliceBalance = aliceBalance - amountToTransfer;
    21. accountColl.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    22. var findAliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    23. assert.eq(newAliceBalance, findAliceBalance);
    25. // add $500 to Bob's account
    26. var bobBalance = accountColl.find({"name": "Bob"}).next().balance;
    27. var newBobBalance = bobBalance + amountToTransfer;
    28. accountColl.update({"name": "Bob"},{"$set": {"balance": newBobBalance}});
    29. var findBobBalance = accountColl.find({"name": "Bob"}).next().balance;
    30. assert.eq(newBobBalance, findBobBalance);
    32. session.commitTransaction();
    34. accountColl.find();

    Node.js

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 Node.js 结合使用。

    1. // Node.js callback API:
    3. const bankDB = await mongoclient.db("bank");
    4. var accountColl = await bankDB.createCollection("account");
    5. var amountToTransfer = 500;
    7. const session = mongoclient.startSession({causalConsistency: false});
    8. await accountColl.drop();
    10. await accountColl.insertOne({name: "Alice", balance: 1000}, { session });
    11. await accountColl.insertOne({name: "Bob", balance: 1000}, { session });
    13. const transactionOptions = {
    14.     readConcern: { level: 'snapshot' },
    15.     writeConcern: { w: 'majority' } 
    16.     };
    18. // deduct $500 from Alice's account
    19. var aliceBalance = await accountColl.findOne({name: "Alice"}, {session});
    20. assert(aliceBalance.balance >= amountToTransfer);
    21. var newAliceBalance = aliceBalance - amountToTransfer;
    22. session.startTransaction(transactionOptions);
    23. await accountColl.updateOne({name: "Alice"}, {$set: {balance: newAliceBalance}}, {session });
    24. await session.commitTransaction();
    25. aliceBalance = await accountColl.findOne({name: "Alice"}, {session});
    26. assert(newAliceBalance == aliceBalance.balance);
    28. // add $500 to Bob's account
    29. var bobBalance = await accountColl.findOne({name: "Bob"}, {session});
    30. var newBobBalance = bobBalance.balance + amountToTransfer;
    31. session.startTransaction(transactionOptions);
    32. await accountColl.updateOne({name: "Bob"}, {$set: {balance: newBobBalance}}, {session });
    33. await session.commitTransaction();
    34. bobBalance = await accountColl.findOne({name: "Bob"}, {session});
    35. assert(newBobBalance == bobBalance.balance);

    C#

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 C# 结合使用。

    1. // C# Callback API
    3. var dbName = "bank";
    4. var collName = "account";
    5. var amountToTransfer = 500;
    7. using (var session = client.StartSession(new ClientSessionOptions{CausalConsistency = false}))
    8. {
    9.     var bankDB = client.GetDatabase(dbName);
    10.     var accountColl = bankDB.GetCollection<BsonDocument>(collName);
    11.     bankDB.DropCollection(collName);
    12.     accountColl.InsertOne(session, new BsonDocument { {"name", "Alice"}, {"balance", 1000 } });
    13.     accountColl.InsertOne(session, new BsonDocument { {"name", "Bob"}, {"balance", 1000 } });
    15.     // start transaction
    16.     var transactionOptions = new TransactionOptions(
    17.             readConcern: ReadConcern.Snapshot,
    18.             writeConcern: WriteConcern.WMajority);
    19.     var result = session.WithTransaction(
    20.         (sess, cancellationtoken) =>
    21.         {
    22.             // deduct $500 from Alice's account
    23.             var aliceBalance = accountColl.Find(sess, Builders<BsonDocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    24.             Debug.Assert(aliceBalance >= amountToTransfer);
    25.             var newAliceBalance = aliceBalance.AsInt32 - amountToTransfer;
    26.             accountColl.UpdateOne(sess, Builders<BsonDocument>.Filter.Eq("name", "Alice"), 
    27.                                     Builders<BsonDocument>.Update.Set("balance", newAliceBalance));
    28.             aliceBalance = accountColl.Find(sess, Builders<BsonDocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    29.             Debug.Assert(aliceBalance == newAliceBalance);
    31.             // add $500 from Bob's account
    32.             var bobBalance = accountColl.Find(sess, Builders<BsonDocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    33.             var newBobBalance = bobBalance.AsInt32 + amountToTransfer;
    34.             accountColl.UpdateOne(sess, Builders<BsonDocument>.Filter.Eq("name", "Bob"), 
    35.                                     Builders<BsonDocument>.Update.Set("balance", newBobBalance));
    36.             bobBalance = accountColl.Find(sess, Builders<BsonDocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    37.             Debug.Assert(bobBalance == newBobBalance);
    39.             return "Transaction committed";
    40.         }, transactionOptions);
    41.    // check values outside of transaction
    42.     var aliceNewBalance = accountColl.Find(Builders<BsonDocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    43.     var bobNewBalance = accountColl.Find(Builders<BsonDocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    44.     Debug.Assert(aliceNewBalance ==  500);
    45.     Debug.Assert(bobNewBalance ==  1500);
    46. }

    Ruby

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 Ruby 结合使用。

    1. // Ruby Callback API
    3. dbName = "bank"
    4. collName = "account"
    5. amountToTransfer = 500
    7. session = client.start_session(:causal_consistency=> false)
    8. bankDB = Mongo::Database.new(client, dbName)
    9. accountColl = bankDB[collName]
    10. accountColl.drop()
    12. accountColl.insert_one({"name"=>"Alice", "balance"=>1000})
    13. accountColl.insert_one({"name"=>"Bob", "balance"=>1000})
    15.     # start transaction 
    16.     session.with_transaction(read_concern: {level: :snapshot}, write_concern: {w: :majority}) do
    17.         # deduct $500 from Alice's account
    18.         aliceBalance = accountColl.find({"name"=>"Alice"}, :session=> session).first['balance']
    19.         assert aliceBalance >= amountToTransfer
    20.         newAliceBalance = aliceBalance - amountToTransfer
    21.         accountColl.update_one({"name"=>"Alice"}, { "$set" => {"balance"=>newAliceBalance} }, :session=> session)
    22.         aliceBalance = accountColl.find({"name"=>>"Alice"}, :session=> session).first['balance']
    23.         assert_equal(newAliceBalance, aliceBalance)
    25.         # add $500 from Bob's account
    26.         bobBalance = accountColl.find({"name"=>"Bob"}, :session=> session).first['balance']
    27.         newBobBalance = bobBalance + amountToTransfer
    28.         accountColl.update_one({"name"=>"Bob"}, { "$set" => {"balance"=>newBobBalance} }, :session=> session)
    29.         bobBalance = accountColl.find({"name"=>"Bob"}, :session=> session).first['balance']
    30.         assert_equal(newBobBalance, bobBalance)
    31.     end
    33.    # check results outside of transaction
    34.     aliceBalance = accountColl.find({"name"=>"Alice"}).first['balance']
    35.     bobBalance = accountColl.find({"name"=>"Bob"}).first['balance']
    36.     assert_equal(aliceBalance, 500)
    37.     assert_equal(bobBalance, 1500)
    39. session.end_session

    Go

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 Go 结合使用。

    Java

    以下代码演示如何将 Amazon DocumentDB 事务 API 与 Java 结合使用。

    1. // Java (sync) - Callback API
    2. MongoDatabase bankDB = mongoClient.getDatabase("bank");
    3. MongoCollection accountColl = bankDB.getCollection("account");
    4. accountColl.drop();
    5. int amountToTransfer = 500;
    7. // add sample data
    8. accountColl.insertOne(new Document("name", "Alice").append("balance", 1000));
    9. accountColl.insertOne(new Document("name", "Bob").append("balance", 1000));
    11. TransactionOptions txnOptions = TransactionOptions.builder()
    12.         .readConcern(ReadConcern.SNAPSHOT)
    13.         .writeConcern(WriteConcern.MAJORITY)
    14.         .build();
    15. ClientSessionOptions sessionOptions = ClientSessionOptions.builder().causallyConsistent(false).build();
    16. try ( ClientSession clientSession = mongoClient.startSession(sessionOptions) ) {
    17.     clientSession.withTransaction(new TransactionBody<Void>() {
    18.         @Override
    19.         public Void execute() {
    20.             // deduct $500 from Alice's account
    21.             List<Document> documentList = new ArrayList<>();
    22.             accountColl.find(clientSession, new Document("name", "Alice")).into(documentList);
    23.             int aliceBalance = (int) documentList.get(0).get("balance");
    24.             int newAliceBalance = aliceBalance - amountToTransfer;
    26.             accountColl.updateOne(clientSession, new Document("name", "Alice"), new Document("$set", new Document("balance", newAliceBalance)));
    28.             documentList = new ArrayList<>();
    29.             accountColl.find(clientSession, new Document("name", "Alice")).into(documentList);
    30.             int updatedBalance = (int) documentList.get(0).get("balance");
    31.             Assert.assertEquals(updatedBalance, newAliceBalance);
    33.             // add $500 to Bob's account
    34.             documentList = new ArrayList<>();
    35.             accountColl.find(clientSession, new Document("name", "Bob")).into(documentList);
    37.             int newBobBalance = bobBalance + amountToTransfer;
    39.             accountColl.updateOne(clientSession, new Document("name", "Bob"), new Document("$set", new Document("balance", newBobBalance)));
    41.             // check Bob's new balance
    42.             documentList = new ArrayList<>();
    43.             accountColl.find(clientSession, new Document("name", "Bob")).into(documentList);
    44.             updatedBalance = (int) documentList.get(0).get("balance");
    45.             Assert.assertEquals(updatedBalance, newBobBalance);
    47.             return null;
    48.         }
    49.     }, txnOptions);
    50. }

    C

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 C 结合使用。

    1. // Sample Code for C with Callback
    3. #include <bson.h>
    4. #include <mongoc.h>
    5. #include <stdio.h>
    6. #include <string.h>
    7. #include <assert.h>
    9. typedef struct {
    10.     int64_t balance;
    11.     bson_t *account;
    12.     bson_t *opts;
    13.     mongoc_collection_t *collection;
    14. } ctx_t;
    16. bool callback_session (mongoc_client_session_t *session, void *ctx, bson_t **reply, bson_error_t *error)
    17. {
    18.     bool r = true;
    19.     ctx_t *data = (ctx_t *) ctx;
    20.     bson_t local_reply;
    21.     bson_t *selector = data->account;
    22.     bson_t *update = BCON_NEW ("$set", "{", "balance", BCON_INT64 (data->balance), "}");
    24.     mongoc_collection_update_one (data->collection, selector, update, data->opts, &local_reply, error);
    26.     *reply = bson_copy (&local_reply);
    27.     bson_destroy (&local_reply);
    28.     bson_destroy (update);
    29.     return r;
    30. }
    32. void test_callback_money_transfer(mongoc_client_t* client, mongoc_collection_t* collection, int amount_to_transfer){
    34.     bson_t reply;
    35.     bool r = true;
    36.     const bson_t *doc;
    37.     bson_iter_t iter;
    38.     ctx_t alice_ctx;
    39.     ctx_t bob_ctx;
    40.     bson_error_t error;
    42.     // find query
    43.     bson_t *alice_query = bson_new ();
    44.     BSON_APPEND_UTF8(alice_query, "name", "Alice");
    46.     bson_t *bob_query = bson_new ();
    47.     BSON_APPEND_UTF8(bob_query, "name", "Bob");
    49.     // create session
    50.     // set causal consistency to false
    51.     mongoc_session_opt_t *session_opts = mongoc_session_opts_new ();
    52.     mongoc_session_opts_set_causal_consistency (session_opts, false);
    53.     // start the session
    54.     mongoc_client_session_t *client_session = mongoc_client_start_session (client, session_opts, &error);
    56.     // add session to options
    57.     bson_t *opts = bson_new();
    58.     mongoc_client_session_append (client_session, opts, &error);
    60.     // deduct 500 from Alice
    61.     // find account balance of Alice
    62.     mongoc_cursor_t *cursor = mongoc_collection_find_with_opts (collection, alice_query, NULL, NULL);
    63.     mongoc_cursor_next (cursor, &doc);
    64.     bson_iter_init (&iter, doc);
    65.     bson_iter_find (&iter, "balance");
    66.     int64_t alice_balance = (bson_iter_value (&iter))->value.v_int64; 
    67.     assert(alice_balance >= amount_to_transfer);
    68.     int64_t new_alice_balance = alice_balance - amount_to_transfer;
    70.     // set variables which will be used by callback function
    71.     alice_ctx.collection = collection;
    72.     alice_ctx.opts = opts;
    73.     alice_ctx.balance = new_alice_balance;
    74.     alice_ctx.account = alice_query;
    76.     // callback
    77.     r = mongoc_client_session_with_transaction (client_session, &callback_session, NULL, &alice_ctx, &reply, &error);
    78.     assert(r);
    80.     // find account balance of Alice after transaction
    81.     cursor = mongoc_collection_find_with_opts (collection, alice_query, NULL, NULL);
    82.     mongoc_cursor_next (cursor, &doc);
    83.     bson_iter_init (&iter, doc);
    84.     bson_iter_find (&iter, "balance");
    85.     alice_balance = (bson_iter_value (&iter))->value.v_int64;
    86.     assert(alice_balance == new_alice_balance);
    87.     assert(alice_balance == 500);
    89.         // add 500 to bob's balance
    90.     // find account balance of Bob
    91.     cursor = mongoc_collection_find_with_opts (collection, bob_query, NULL, NULL);
    92.     mongoc_cursor_next (cursor, &doc);
    93.     bson_iter_init (&iter, doc);
    94.     bson_iter_find (&iter, "balance");
    95.     int64_t bob_balance = (bson_iter_value (&iter))->value.v_int64;
    96.     int64_t new_bob_balance = bob_balance + amount_to_transfer;
    98.     bob_ctx.collection = collection;
    99.     bob_ctx.opts = opts;
    100.     bob_ctx.balance = new_bob_balance;
    101.     bob_ctx.account = bob_query;
    103.     // set read & write concern
    104.     mongoc_read_concern_t *read_concern = mongoc_read_concern_new ();
    105.     mongoc_write_concern_t *write_concern = mongoc_write_concern_new ();
    106.     mongoc_transaction_opt_t *txn_opts = mongoc_transaction_opts_new ();
    108.     mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
    109.     mongoc_read_concern_set_level(read_concern, MONGOC_READ_CONCERN_LEVEL_SNAPSHOT);
    110.     mongoc_transaction_opts_set_write_concern (txn_opts, write_concern);
    111.     mongoc_transaction_opts_set_read_concern (txn_opts, read_concern);
    113.     // callback
    114.     r = mongoc_client_session_with_transaction (client_session, &callback_session, txn_opts, &bob_ctx, &reply, &error);
    115.     assert(r);
    117.     // find account balance of Bob after transaction
    118.     cursor = mongoc_collection_find_with_opts (collection, bob_query, NULL, NULL);
    119.     mongoc_cursor_next (cursor, &doc);
    120.     bson_iter_init (&iter, doc);
    121.     bson_iter_find (&iter, "balance");
    122.     bob_balance = (bson_iter_value (&iter))->value.v_int64;
    123.     assert(bob_balance == new_bob_balance);
    124.     assert(bob_balance == 1500);
    126.     // cleanup
    127.     bson_destroy(alice_query);
    128.     bson_destroy(bob_query);
    129.     mongoc_client_session_destroy(client_session);
    130.     bson_destroy(opts);
    131.     mongoc_transaction_opts_destroy(txn_opts);
    132.     mongoc_read_concern_destroy(read_concern);
    133.     mongoc_write_concern_destroy(write_concern);
    134.     mongoc_cursor_destroy(cursor);
    135.     bson_destroy(doc);
    136. }
    137. int main(int argc, char* argv[]) {
    138.     mongoc_init ();
    139.     mongoc_client_t* client = mongoc_client_new (<connection uri>);
    140.     bson_error_t error;
    142.     // connect to bank db
    143.     mongoc_database_t *database = mongoc_client_get_database (client, "bank");
    144.     // access account collection
    145.     mongoc_collection_t* collection = mongoc_client_get_collection(client, "bank", "account");
    146.     // set amount to transfer
    147.     int64_t amount_to_transfer = 500;
    148.     // delete the collection if already existing
    149.     mongoc_collection_drop(collection, &error);
    151.     // open Alice account
    152.     bson_t *alice_account = bson_new ();
    153.     BSON_APPEND_UTF8(alice_account, "name", "Alice");
    154.     BSON_APPEND_INT64(alice_account, "balance", 1000);
    156.     // open Bob account
    157.     bson_t *bob_account = bson_new ();
    158.     BSON_APPEND_UTF8(bob_account, "name", "Bob");
    159.     BSON_APPEND_INT64(bob_account, "balance", 1000);
    161.     bool r = true;
    163.     r = mongoc_collection_insert_one(collection, alice_account, NULL, NULL, &error);
    164.     if (!r) {printf("Error encountered:%s", error.message);}
    165.     r = mongoc_collection_insert_one(collection, bob_account, NULL, NULL, &error);
    166.     if (!r) {printf("Error encountered:%s", error.message);}
    168.     test_callback_money_transfer(client, collection, amount_to_transfer);
    170. }

    Python

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 Python 结合使用。

    1. // Sample Python code with callback api
    3. import pymongo
    5. def callback(session, balance, query):
    6.     collection.update_one(query, {'$set': {"balance": balance}}, session=session)
    8. client = pymongo.MongoClient(<connection uri>)
    9. rc_snapshot = pymongo.read_concern.ReadConcern('snapshot')
    10. wc_majority = pymongo.write_concern.WriteConcern('majority')
    12. # To start, drop and create an account collection and insert balances for both Alice and Bob
    13. collection = client.get_database("bank").get_collection("account")
    14. collection.drop()
    15. collection.insert_one({"_id": 1, "name": "Alice", "balance": 1000})
    16. collection.insert_one({"_id": 2, "name": "Bob", "balance": 1000})
    18. amount_to_transfer = 500
    20. # deduct 500 from Alice's account
    21. alice_balance = collection.find_one({"name": "Alice"}).get("balance")
    22. assert alice_balance >= amount_to_transfer
    23. new_alice_balance = alice_balance - amount_to_transfer
    25. with client.start_session({'causalConsistency':False}) as session:
    26.     session.with_transaction(lambda s: callback(s, new_alice_balance, {"name": "Alice"}), read_concern=rc_snapshot, write_concern=wc_majority)
    28. updated_alice_balance = collection.find_one({"name": "Alice"}).get("balance")
    29. assert updated_alice_balance == new_alice_balance
    31. # add 500 to Bob's account
    32. bob_balance = collection.find_one({"name": "Bob"}).get("balance")
    33. assert bob_balance >= amount_to_transfer
    34. new_bob_balance = bob_balance + amount_to_transfer
    36. with client.start_session({'causalConsistency':False}) as session:
    37.     session.with_transaction(lambda s: callback(s, new_bob_balance, {"name": "Bob"}), read_concern=rc_snapshot, write_concern=wc_majority)
    39. updated_bob_balance = collection.find_one({"name": "Bob"}).get("balance")
    40. assert updated_bob_balance == new_bob_balance
    41. Sample Python code with Core api
    42. import pymongo
    44. client = pymongo.MongoClient(<connection_string>)
    45. rc_snapshot = pymongo.read_concern.ReadConcern('snapshot')
    46. wc_majority = pymongo.write_concern.WriteConcern('majority')
    48. # To start, drop and create an account collection and insert balances for both Alice and Bob
    49. collection = client.get_database("bank").get_collection("account")
    50. collection.drop()
    51. collection.insert_one({"_id": 1, "name": "Alice", "balance": 1000})
    52. collection.insert_one({"_id": 2, "name": "Bob", "balance": 1000})
    54. amount_to_transfer = 500
    56. # deduct 500 from Alice's account
    57. alice_balance = collection.find_one({"name": "Alice"}).get("balance")
    58. assert alice_balance >= amount_to_transfer
    59. new_alice_balance = alice_balance - amount_to_transfer
    61. with client.start_session({'causalConsistency':False}) as session:
    62.     session.start_transaction(read_concern=rc_snapshot, write_concern=wc_majority)
    63.     collection.update_one({"name": "Alice"}, {'$set': {"balance": new_alice_balance}}, session=session)
    64.     session.commit_transaction()
    66. updated_alice_balance = collection.find_one({"name": "Alice"}).get("balance")
    67. assert updated_alice_balance == new_alice_balance
    69. # add 500 to Bob's account
    70. bob_balance = collection.find_one({"name": "Bob"}).get("balance")
    71. assert bob_balance >= amount_to_transfer
    72. new_bob_balance = bob_balance + amount_to_transfer
    74. with client.start_session({'causalConsistency':False}) as session:
    75.     session.start_transaction(read_concern=rc_snapshot, write_concern=wc_majority)
    76.     collection.update_one({"name": "Bob"}, {'$set': {"balance": new_bob_balance}}, session=session)
    77.     session.commit_transaction()
    79. updated_bob_balance = collection.find_one({"name": "Bob"}).get("balance")
    80. assert updated_bob_balance == new_bob_balance

    核心 API 的事务 API 示例

    Javascript

    以下代码演示如何将 Amazon DocumentDB 事务 API 与 Javascript 结合使用。

    1. // *** Transfer $500 from Alice to Bob inside a transaction: Success ***
    2. // Setup bank account for Alice and Bob. Each have $1000 in their account
    3. var databaseName = "bank";
    4. var collectionName = "account";
    5. var amountToTransfer = 500;
    7. var session = db.getMongo().startSession({causalConsistency: false});  
    8. var bankDB = session.getDatabase(databaseName);
    9. var accountColl = bankDB[collectionName];
    10. accountColl.drop();
    12. accountColl.insert({name: "Alice", balance: 1000});
    13. accountColl.insert({name: "Bob", balance: 1000});
    15. session.startTransaction();
    17. // deduct $500 from Alice's account
    18. var aliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    19. assert(aliceBalance >= amountToTransfer);
    20. var newAliceBalance = aliceBalance - amountToTransfer;
    21. accountColl.update({"name": "Alice"},{"$set": {"balance": newAliceBalance}});
    22. var findAliceBalance = accountColl.find({"name": "Alice"}).next().balance;
    23. assert.eq(newAliceBalance, findAliceBalance);
    25. // add $500 to Bob's account
    26. var bobBalance = accountColl.find({"name": "Bob"}).next().balance;
    27. var newBobBalance = bobBalance + amountToTransfer;
    28. accountColl.update({"name": "Bob"},{"$set": {"balance": newBobBalance}});
    29. var findBobBalance = accountColl.find({"name": "Bob"}).next().balance;
    30. assert.eq(newBobBalance, findBobBalance);
    32. session.commitTransaction();
    34. accountColl.find();

    C#

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 C# 结合使用。

    1. // C# Core API
    3. public void TransferMoneyWithRetry(IMongoCollection<bSondocument> accountColl, IClientSessionHandle session) 
    4. {
    5.     var amountToTransfer = 500;
    7.     // start transaction
    8.    var transactionOptions = new TransactionOptions(
    9.                 readConcern: ReadConcern.Snapshot,
    10.                 writeConcern: WriteConcern.WMajority);
    11.     session.StartTransaction(transactionOptions);
    12.    try
    13.     {
    14.         // deduct $500 from Alice's account
    15.         var aliceBalance = accountColl.Find(session, Builders<bSondocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    16.         Debug.Assert(aliceBalance >= amountToTransfer);
    17.         var newAliceBalance = aliceBalance.AsInt32 - amountToTransfer;
    18.         accountColl.UpdateOne(session, Builders<bSondocument>.Filter.Eq("name", "Alice"), 
    19.                                 Builders<bSondocument>.Update.Set("balance", newAliceBalance));
    20.         aliceBalance = accountColl.Find(session, Builders<bSondocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    21.         Debug.Assert(aliceBalance == newAliceBalance);
    23.         // add $500 from Bob's account
    24.         var bobBalance = accountColl.Find(session, Builders<bSondocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    25.         var newBobBalance = bobBalance.AsInt32 + amountToTransfer;
    26.         accountColl.UpdateOne(session, Builders<bSondocument>.Filter.Eq("name", "Bob"), 
    27.                                 Builders<bSondocument>.Update.Set("balance", newBobBalance));
    28.         bobBalance = accountColl.Find(session, Builders<bSondocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    29.         Debug.Assert(bobBalance == newBobBalance);
    31.     }
    32.     catch (Exception e)
    33.     {
    34.         session.AbortTransaction();
    35.         throw;
    36.     }
    38.     session.CommitTransaction();
    39.  }
    41. public void DoTransactionWithRetry(MongoClient client)
    42. {
    43.     var dbName = "bank";
    44.     var collName = "account";
    45.     using (var session = client.StartSession(new ClientSessionOptions{CausalConsistency = false}))
    46.     {
    47.         try 
    48.         {
    49.             var bankDB = client.GetDatabase(dbName);
    50.             var accountColl = bankDB.GetCollection<bSondocument>(collName);
    51.             bankDB.DropCollection(collName);
    52.             accountColl.InsertOne(session, new BsonDocument { {"name", "Alice"}, {"balance", 1000 } });
    53.             accountColl.InsertOne(session, new BsonDocument { {"name", "Bob"}, {"balance", 1000 } });
    55.             while(true) {
    56.                 try 
    58.                         TransferMoneyWithRetry(accountColl, session);
    59.                         break;
    60.                 }
    61.                 catch (MongoException e) 
    62.                 {
    63.                     if(e.HasErrorLabel("TransientTransactionError"))
    64.                     {
    65.                         continue;
    66.                     }
    67.                     else
    68.                     {
    69.                         throw;
    70.                     }
    71.                 }
    72.             }
    74.             // check values outside of transaction
    75.             var aliceNewBalance = accountColl.Find(Builders<bSondocument>.Filter.Eq("name", "Alice")).FirstOrDefault().GetValue("balance");
    76.             var bobNewBalance = accountColl.Find(Builders<bSondocument>.Filter.Eq("name", "Bob")).FirstOrDefault().GetValue("balance");
    77.             Debug.Assert(aliceNewBalance ==  500);
    78.             Debug.Assert(bobNewBalance ==  1500);
    79.         }
    80.         catch (Exception e)
    81.         {
    82.             Console.WriteLine("Error running transaction: " + e.Message);
    83.         }
    84.     }        
    85. }

    Ruby

    以下代码演示如何将 Amazon DocumentDB 事务 API 与 Ruby 结合使用。

    1. # Ruby Core API
    3. def transfer_money_w_retry(session, accountColl)
    4.     amountToTransfer = 500
    6.     session.start_transaction(read_concern: {level: :snapshot}, write_concern: {w: :majority})
    7.     # deduct $500 from Alice's account
    8.     aliceBalance = accountColl.find({"name"=>"Alice"}, :session=> session).first['balance']
    9.     assert aliceBalance >= amountToTransfer
    10.     newAliceBalance = aliceBalance - amountToTransfer
    11.     accountColl.update_one({"name"=>"Alice"}, { "$set" => {"balance"=>newAliceBalance} }, :session=> session)
    12.     aliceBalance = accountColl.find({"name"=>"Alice"}, :session=> session).first['balance']
    13.     assert_equal(newAliceBalance, aliceBalance)
    15.     # add $500 to Bob's account
    16.     bobBalance = accountColl.find({"name"=>"Bob"}, :session=> session).first['balance']
    17.     newBobBalance = bobBalance + amountToTransfer
    18.     accountColl.update_one({"name"=>"Bob"}, { "$set" => {"balance"=>newBobBalance} }, :session=> session)
    19.     bobBalance = accountColl.find({"name"=>"Bob"}, :session=> session).first['balance']
    20.     assert_equal(newBobBalance, bobBalance)
    22.     session.commit_transaction
    24. end
    26. def do_txn_w_retry(client)
    27.      dbName = "bank"
    28.     collName = "account"
    30.     session = client.start_session(:causal_consistency=> false)
    31.     bankDB = Mongo::Database.new(client, dbName)
    32.     accountColl = bankDB[collName]
    33.     accountColl.drop()
    35.     accountColl.insert_one({"name"=>"Alice", "balance"=>1000})
    36.     accountColl.insert_one({"name"=>"Bob", "balance"=>1000})
    38.     begin
    39.         transferMoneyWithRetry(session, accountColl)
    40.         puts "transaction committed"
    41.     rescue Mongo::Error => e
    42.         if e.label?('TransientTransactionError')
    43.             retry
    44.         else
    45.             puts "transaction failed"
    46.             raise
    47.         end
    48.     end
    50.     # check results outside of transaction
    51.     aliceBalance = accountColl.find({"name"=>"Alice"}).first['balance']
    52.     bobBalance = accountColl.find({"name"=>"Bob"}).first['balance']
    53.     assert_equal(aliceBalance, 500)
    54.     assert_equal(bobBalance, 1500)
    56. end

    Java

    以下代码演示如何将 Amazon DocumentDB 事务 API 与 Java 结合使用。

    C

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 C 结合使用。

    1. // Sample C code with core session
    3. bool core_session(mongoc_client_session_t *client_session, mongoc_collection_t* collection, bson_t *selector, int64_t balance){
    4.     bool r = true;
    5.     bson_error_t error;
    6.     bson_t *opts = bson_new();
    7.     bson_t *update = BCON_NEW ("$set", "{", "balance", BCON_INT64 (balance), "}");
    9.     // set read & write concern
    10.     mongoc_read_concern_t *read_concern = mongoc_read_concern_new ();
    11.     mongoc_write_concern_t *write_concern = mongoc_write_concern_new ();
    12.     mongoc_transaction_opt_t *txn_opts = mongoc_transaction_opts_new ();
    14.     mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);
    15.     mongoc_read_concern_set_level(read_concern, MONGOC_READ_CONCERN_LEVEL_SNAPSHOT);
    16.     mongoc_transaction_opts_set_write_concern (txn_opts, write_concern);
    17.     mongoc_transaction_opts_set_read_concern (txn_opts, read_concern);
    19.     mongoc_client_session_start_transaction (client_session, txn_opts, &error);
    20.     mongoc_client_session_append (client_session, opts, &error);
    22.     r = mongoc_collection_update_one (collection, selector, update, opts, NULL, &error);
    24.     mongoc_client_session_commit_transaction (client_session, NULL, &error);
    25.     bson_destroy (opts);
    26.     mongoc_transaction_opts_destroy(txn_opts);
    27.     mongoc_read_concern_destroy(read_concern);
    28.     mongoc_write_concern_destroy(write_concern);
    29.     bson_destroy (update);
    30.     return r;
    31. }
    33. void test_core_money_transfer(mongoc_client_t* client, mongoc_collection_t* collection, int amount_to_transfer){
    35.     bson_t reply;
    36.     bool r = true;
    37.     const bson_t *doc;
    38.     bson_iter_t iter;
    39.     bson_error_t error;
    41.     // find query
    42.     bson_t *alice_query = bson_new ();
    43.     BSON_APPEND_UTF8(alice_query, "name", "Alice");
    45.     bson_t *bob_query = bson_new ();
    46.     BSON_APPEND_UTF8(bob_query, "name", "Bob");
    48.     // create session
    49.     // set causal consistency to false
    50.     mongoc_session_opt_t *session_opts = mongoc_session_opts_new ();
    51.     mongoc_session_opts_set_causal_consistency (session_opts, false);
    52.     // start the session
    53.     mongoc_client_session_t *client_session = mongoc_client_start_session (client, session_opts, &error);
    55.     // add session to options
    56.     bson_t *opts = bson_new();
    57.     mongoc_client_session_append (client_session, opts, &error);
    59.     // deduct 500 from Alice
    60.     // find account balance of Alice
    61.     mongoc_cursor_t *cursor = mongoc_collection_find_with_opts (collection, alice_query, NULL, NULL);
    62.     mongoc_cursor_next (cursor, &doc);
    63.     bson_iter_init (&iter, doc);
    64.     bson_iter_find (&iter, "balance");
    65.     int64_t alice_balance = (bson_iter_value (&iter))->value.v_int64; 
    66.     assert(alice_balance >= amount_to_transfer);
    67.     int64_t new_alice_balance = alice_balance - amount_to_transfer;
    69.     // core
    70.     r = core_session (client_session, collection, alice_query, new_alice_balance);
    71.     assert(r);
    73.     // find account balance of Alice after transaction
    74.     cursor = mongoc_collection_find_with_opts (collection, alice_query, NULL, NULL);
    75.     mongoc_cursor_next (cursor, &doc);
    76.     bson_iter_init (&iter, doc);
    77.     bson_iter_find (&iter, "balance");
    78.     alice_balance = (bson_iter_value (&iter))->value.v_int64;
    79.     assert(alice_balance == new_alice_balance);
    80.     assert(alice_balance == 500);
    82.     // add 500 to Bob's balance
    83.     // find account balance of Bob
    84.     cursor = mongoc_collection_find_with_opts (collection, bob_query, NULL, NULL);
    85.     mongoc_cursor_next (cursor, &doc);
    86.     bson_iter_init (&iter, doc);
    87.     bson_iter_find (&iter, "balance");
    88.     int64_t bob_balance = (bson_iter_value (&iter))->value.v_int64;
    89.     int64_t new_bob_balance = bob_balance + amount_to_transfer;
    91.     //core
    92.     r = core_session (client_session, collection, bob_query, new_bob_balance);
    93.     assert(r);
    95.     // find account balance of Bob after transaction
    96.     cursor = mongoc_collection_find_with_opts (collection, bob_query, NULL, NULL);
    97.     mongoc_cursor_next (cursor, &doc);
    98.     bson_iter_init (&iter, doc);
    99.     bson_iter_find (&iter, "balance");
    100.     bob_balance = (bson_iter_value (&iter))->value.v_int64;
    101.     assert(bob_balance == new_bob_balance);
    102.     assert(bob_balance == 1500);
    104.     // cleanup
    105.     bson_destroy(alice_query);
    106.     bson_destroy(bob_query);
    107.     mongoc_client_session_destroy(client_session);
    108.     bson_destroy(opts);
    109.     mongoc_cursor_destroy(cursor);
    110.     bson_destroy(doc);
    111. }
    113. int main(int argc, char* argv[]) {    
    114.     mongoc_init ();
    115.     mongoc_client_t* client = mongoc_client_new (<connection uri>);
    116.     bson_error_t error;
    118.     // connect to bank db
    119.     mongoc_database_t *database = mongoc_client_get_database (client, "bank");
    120.     // access account collection
    121.     mongoc_collection_t* collection = mongoc_client_get_collection(client, "bank", "account");
    122.     // set amount to transfer
    123.     int64_t amount_to_transfer = 500;
    124.     // delete the collection if already existing
    125.     mongoc_collection_drop(collection, &error);
    127.     // open Alice account
    128.     bson_t *alice_account = bson_new ();
    129.     BSON_APPEND_UTF8(alice_account, "name", "Alice");
    130.     BSON_APPEND_INT64(alice_account, "balance", 1000);
    132.     // open Bob account
    133.     bson_t *bob_account = bson_new ();
    134.     BSON_APPEND_UTF8(bob_account, "name", "Bob");
    135.     BSON_APPEND_INT64(bob_account, "balance", 1000);
    137.     bool r = true;
    139.     r = mongoc_collection_insert_one(collection, alice_account, NULL, NULL, &error);
    140.     if (!r) {printf("Error encountered:%s", error.message);}
    141.     r = mongoc_collection_insert_one(collection, bob_account, NULL, NULL, &error);
    142.     if (!r) {printf("Error encountered:%s", error.message);}
    144.     test_core_money_transfer(client, collection, amount_to_transfer);
    146. }

    Scala

    以下代码演示了如何将 Amazon DocumentDB 事务 API 与 Scala 结合使用。

    1. // Scala Core API
    2. def transferMoneyWithRetry(sessionObservable: SingleObservable[ClientSession] , database: MongoDatabase ): Unit = {
    3.     val accountColl = database.getCollection("account")
    4.     var amountToTransfer = 500
    6.     var transactionObservable: Observable[ClientSession] = sessionObservable.map(clientSession => {
    7.     clientSession.startTransaction()
    9.     // deduct $500 from Alice's account
    10.     var aliceBalance = accountColl.find(clientSession, Document("name" -> "Alice")).await().head.getInteger("balance")
    11.     assert(aliceBalance >= amountToTransfer)
    12.     var newAliceBalance = aliceBalance - amountToTransfer
    13.     accountColl.updateOne(clientSession, Document("name" -> "Alice"), Document("$set" -> Document("balance" -> newAliceBalance))).await()
    14.     aliceBalance = accountColl.find(clientSession, Document("name" -> "Alice")).await().head.getInteger("balance")
    15.     assert(aliceBalance == newAliceBalance)
    17.     // add $500 to Bob's account
    18.     var bobBalance = accountColl.find(clientSession, Document("name" -> "Bob")).await().head.getInteger("balance")
    19.     var newBobBalance = bobBalance + amountToTransfer     
    20.     accountColl.updateOne(clientSession, Document("name" -> "Bob"), Document("$set" -> Document("balance" -> newBobBalance))).await()
    21.     bobBalance = accountColl.find(clientSession, Document("name" -> "Bob")).await().head.getInteger("balance")
    22.     assert(bobBalance == newBobBalance)
    24.     clientSession   
    25.     })
    27.     transactionObservable.flatMap(clientSession => clientSession.commitTransaction()).await()
    28. }
    30. def doTransactionWithRetry(): Unit = {
    31.     val client: MongoClient = MongoClientWrapper.getMongoClient()
    32.     val database: MongoDatabase = client.getDatabase("bank")
    33.     val accountColl = database.getCollection("account")
    34.     accountColl.drop().await()
    36.     val sessionOptions = ClientSessionOptions.builder().causallyConsistent(false).build()
    37.     var  sessionObservable: SingleObservable[ClientSession] = client.startSession(sessionOptions)
    38.     accountColl.insertOne(Document("name" -> "Alice", "balance" -> 1000)).await()
    39.     accountColl.insertOne(Document("name" -> "Bob", "balance" -> 1000)).await()
    41.     var retry = true
    42.     while (retry) {
    43.         try {
    44.         transferMoneyWithRetry(sessionObservable, database)
    45.         println("transaction committed")
    46.         retry = false
    47.         }
    48.         catch {
    49.         case e: MongoException if e.hasErrorLabel(MongoException.TRANSIENT_TRANSACTION_ERROR_LABEL) => {
    50.             println("retrying transaction") 
    51.         }
    52.         case other: Throwable => {
    53.             println("transaction failed")
    54.             retry = false
    55.             throw other
    57.         }
    58.         }
    59.     }
    61.     // check results outside of transaction
    62.     assert(accountColl.find(Document("name" -> "Alice")).results().head.getInteger("balance") == 500)
    63.     assert(accountColl.find(Document("name" -> "Bob")).results().head.getInteger("balance") == 1500)
    65.     accountColl.drop().await()
    67. }

    不支持的功能

    Methods阶段或命令

    db.collection.aggregate()

    $collStats

    $currentOp

    $indexStats

    $listSessions

    $out

    db.collection.count()

    db.collection.countDocuments()

    $where

    $near

    $nearSphere

    db.collection.insert()

    insert 如果不是针对现有集合运行的，则不支持 。如果此方法针对的是预先存在的集合，则支持此方法。

    Sessions

    MongoDB 会话是一个框架，用于跨分片支持可重试写入、因果一致性、事务和管理操作。创建会话时，客户端会生成一个逻辑会话标识符 （lsid），用于在向服务器发送命令时标记该会话中的所有操作。

    Amazon DocumentDB 支持使用会话启用事务，但不支持因果一致性或可重试写入。

    在 Amazon DocumentDB 中使用事务时，事务将从使用 session.startTransaction() API 的会话中发起，并且会话一次支持单个事务。同样，事务使用提交 （session.commitTransaction()） 或中止 （session.abortTransaction()） APIs 完成。

    原因一致性保证在单个客户端会话中，客户端将观察先写后读一致性、 Monatomical 读/写，并且写入操作将遵循读取并且这些保证适用于集群中的所有实例，而不仅仅是主实例。Amazon DocumentDB 不支持因果一致性，以下语句将导致错误。

    2. var mySession = db.getMongo().startSession();
    3. var mySessionObject = mySession.getDatabase('test').getCollection('account');
    5. mySessionObject.updateOne({"_id": 2}, {"$inc": {"balance": 400}});
    6. //Result:{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
    8. mySessionObject.find()
    9. //Error: error: {
    10. //         "ok" : 0,
    11. //         "code" : 303,
    12. //         "errmsg" : "Feature not supported: 'causal consistency'",
    13. //         "operationTime" : Timestamp(1603461817, 493214)
    14. //}
    16. mySession.endSession()

    您可以在会话中禁用因果一致性。请注意，这样做将使您能够利用会话框架，但不会对读取提供因果一致性保证。使用 Amazon DocumentDB 时，从主集群进行的读取将具有先写后读一致性，从副本实例进行的读取将具有最终一致性。事务是使用会话的主要使用案例。

    2. var mySession = db.getMongo().startSession({causalConsistency: false});
    3. var mySessionObject = mySession.getDatabase('test').getCollection('account');
    5. mySessionObject.updateOne({"_id": 2}, {"$inc": {"balance": 400}});
    6. //Result:{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
    8. mySessionObject.find()
    9. //{ "_id" : 1, "name" : "Bob", "balance" : 100 }
    10. //{ "_id" : 2, "name" : "Alice", "balance" : 1700 }

    可重试写入

    可重试写入是一种功能，在该功能中，客户端尝试重试写入操作（一次、网络出现错误或客户端找不到主集群）。在 Amazon DocumentDB 中，不支持可重试写入，必须禁用。您可以使用连接字符串中的命令 （retryWrites=false） 将其禁用。以下是示例：

    1. mongodb://chimera:<insertYourPassword>@docdb-2019-01-29-02-57-28.cluster-ccuszbx3pn5e.us-east-1.docdb.amazonaws.com:27017/?ssl=true&ssl_ca_certs=rds-combined-ca-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false

    使用事务时，在某些情况下， 可能会产生一个错误，指出事务编号与任何进行中的事务都不匹配。

    错误可在至少两个不同的场景中生成：

    • After the one-minute transaction timeout.
    • After an instance restart (due to patching, crash recovery, etc.), it is possible to receive this error even in cases where the transaction successfully committed. During an instance restart, the database can’t tell the difference between a transaction that successfully completed versus a transaction that aborted. In other words, the transaction completion state is ambiguous.

    处理此错误的最佳方式是使事务更新具有静态 - 例如，通过使用 $set 排列器而不是递增/递减操作。请参阅以下内容：

    1. { "ok" : 0,
    2. "operationTime" : Timestamp(1603938167, 1), 
    3. "code" : 251,
    4. "errmsg" : "Given transaction number 1 does not match any in-progress transactions."