MongoDB 4.0
is just around the corner and with rc0 we can get a good idea of what we can expect in the GA version. MongoDB 4.0 will allow transactions to run in a replica set and, in a future release, the MongoDB transaction will be cluster-wide. This is a really big change!
Multi-statement transactions are a big deal for a lot of companies. The transactions feature has been in development since MongoDB version 3.6 when sessions were added. Now, we will be able to see how both sessions and transactions work. In an earlier blog post we highlighted a few details from what was delivered in 3.6 that indicated that 4.0 would have transactions.
There are a few limitations for transactions and some operations are not allowed yet. A detailed list can be found in the MongoDB documentation of the Session.startTransaction() method.
One restriction that we must be aware of is that the collection MUST exist in order to use transactions.
A simple transaction will be declared in a very similar way to that we use for other databases. The caveat is that we need to start a session before starting a transaction. This means that multi-statement transactions are not the default behavior to write to the database.
How to use transactions in MongoDB 4.0
Download MongoDB 4.0 RC (or you can install it from the repositories).
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu1604-4.0.0-rc1.tgz
Uncompress the files:
tar -xvzf mongodb-linux-x86_64-ubuntu1604-4.0.0-rc1.tgz
Rename the folder to mongo4.0 and create the data folder inside of the bin folder:
mv mongodb-linux-x86_64-ubuntu1604-4.0.0-rc1 mongo4.0
cd mongo4.0
cd bin
mkdir data
Start the database process:
Important: in order to have multi-statement transactions replica-set must be enabled
./mongod --dbpath data --logpath data/log.log --fork --replSet foo
Initialize the replica-set:
> rs.initiate()
foo:Primary> use percona
foo:Primary> db.createCollection('test')
Start a session and then a transaction:
session = db.getMongo().startSession()
session.startTransaction()
session.getDatabase("percona").test.insert({today : new Date()})
session.getDatabase("percona").test.insert({some_value : "abc"})
Then you can decide whether to commit the transaction or abort it:
session.commitTransaction()
session.abortTransaction()
If the startTransaction throws the IllegalOperation error, make sure the database is running with replica set.
Transaction isolation level in in MongoDB 4.0: Snapshot Isolation
MongoDB 4.0 implements snapshot isolation for the transactions. The pending uncommitted changes are only visible inside the session context (the session which has started the transaction) and are not visible outside. Here is an example:
Connection 1:
foo:PRIMARY> use percona
switched to db percona
foo:PRIMARY> db.createCollection('test')
{
"ok" : 1,
"operationTime" : Timestamp(1528903182, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1528903182, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
foo:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("bdd82af7-ab9d-4cd3-9238-f08ee928f31e") }
foo:PRIMARY> session.startTransaction()
foo:PRIMARY> session.getDatabase("percona").test.insert({today : new Date()})
WriteResult({ "nInserted" : 1 })
foo:PRIMARY> session.getDatabase("percona").test.insert({some_value : "abc"})
WriteResult({ "nInserted" : 1 })
Connection 2: starting second transaction in its own session:
foo:PRIMARY> use percona
switched to db percona
foo:PRIMARY> db.test.find()
foo:PRIMARY> db.test.find()
foo:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("eb628bfd-425e-450c-a51b-733435474eaa") }
foo:PRIMARY> session.startTransaction()
foo:PRIMARY> session.getDatabase("percona").test.find()
foo:PRIMARY>
Connection 1: commit
foo:PRIMARY> session.commitTransaction()
Connection 2: after connection1 commits:
foo:PRIMARY> db.test.find()
{ "_id" : ObjectId("5b21361252bbe6e5b9a70a4e"), "today" : ISODate("2018-06-13T15:19:46.645Z") }
{ "_id" : ObjectId("5b21361252bbe6e5b9a70a4f"), "some_value" : "abc" }
Outside of the session it sees the new values, however inside the opened session it will not see the new values.
foo:PRIMARY> session.getDatabase("percona").test.find()
foo:PRIMARY>
Now if we commit the transaction inside connection 2 it will commit as well, and we will have 2 rows now (as there are no conflicts).
Sometimes, however, we may see the transient transaction error when committing or even doing find() inside a session:
foo:PRIMARY> session.commitTransaction()
2018-06-14T21:56:29.111+0000 E QUERY [js] Error: command failed: {
"errorLabels" : [
"TransientTransactionError"
],
"operationTime" : Timestamp(1529013385, 1),
"ok" : 0,
"errmsg" : "Transaction 0 has been aborted.",
"code" : 251,
"codeName" : "NoSuchTransaction",
"$clusterTime" : {
"clusterTime" : Timestamp(1529013385, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
} :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
doassert@src/mongo/shell/assert.js:18:14
_assertCommandWorked@src/mongo/shell/assert.js:520:17
assert.commandWorked@src/mongo/shell/assert.js:604:16
commitTransaction@src/mongo/shell/session.js:878:17
@(shell):1:1
From the MongoDB doc we can read that we could retry the transaction back when we have this error.
If an operation encounters an error, the returned error may have an errorLabels array field. If the error is a transient error, the errorLabels array field contains “TransientTransactionError” as an element and the transaction as a whole can be retried.
MongoDB transactions: conflict
What about transaction conflicts in MongoDB? Let’s say we are updating the same row. Here is the demo:
First we create a record, trx, in the collection:
use percona
db.test.insert({trx : 0})
Then we create session1 and update trx to change from 0 to 1:
foo:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("0b7b8ce0-919a-401a-af01-69fe90876301") }
foo:PRIMARY> session.startTransaction()
foo:PRIMARY> session.getDatabase("percona").test.update({trx : 0}, {trx: 1})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
Then (before committing) create another session which will try to change from 0 to 2:
foo:PRIMARY> session = db.getMongo().startSession()
session { "id" : UUID("b312c662-247c-47c5-b0c9-23d77f4e9f6d") }
foo:PRIMARY> session.startTransaction()
foo:PRIMARY> session.getDatabase("percona").test.update({trx : 0}, {trx: 2})
WriteCommandError({
"errorLabels" : [
"TransientTransactionError"
],
"operationTime" : Timestamp(1529675754, 1),
"ok" : 0,
"errmsg" : "WriteConflict",
"code" : 112,
"codeName" : "WriteConflict",
"$clusterTime" : {
"clusterTime" : Timestamp(1529675754, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
})
As we can see, MongoDB catches the conflict and return the error on the insert (even before the commit).
We hope this post, with its simple example how transactions will work, has been useful. Feedback is welcome: you can comment here, catch Adamo on twitter @AdamoTonete or talk to the team at @percona.
The post MongoDB transactions: your very first transaction with MongoDB 4.0 appeared first on Percona Database Performance Blog.
Percona’s latest blog poll asks how you run your database in the cloud?
In this blog post, we will talk a bit about the product 
Serverless is a new buzzword in the database industry. Even though it gets tossed around often, there is some confusion about what it really means and how it really works. Serverless architectures rely on third-party Backend as a Service (BaaS) services. They can also include custom code that is run in managed, ephemeral containers on a Functions as a Service (FaaS) platform. In comparison to traditional Platform as a Service (PaaS) server architecture, where you pay a predetermined sum for your instances, serverless applications benefit from reduced costs of operations and lower complexity. They are also considered to be more agile, allowing for reduced engineering efforts.
Building on community
Ways you can join in
