Atomic in MongoDB with transfer money - mysql

Question

I'm new for MongoDB
I make a simple application abount account in bank.an account can transfer money to others
I design Account collection like that
account
{
name:A
age: 24
money: 100
}
account
{
name:B
age: 22
money: 300
}
assuming that user A transfer 100$ for user B , there are 2 operations :
1) decrease 100$ in user A // update for document A
2) increase 100$ for user B // update with document B
It said that atomic only applied for only single document but no mutiple document.
I have a alter desgign
Bank
{
name:
address:
Account[
{
name:A
age: 22
money: SS
},
{
name:B
age: 23
money: S1S
}
]
}
I have some question :
If I use later way, How can I write transaction query (Can I use findAndModify() function?) ?
Does MongoDB support transaction operations like Mysql (InnoDB)?
Some pepple tell me that use Mysql for this project is the best way, and just only use MongoDB to save transaction information.(use extra
collection named Transaction_money to save them), If I use both
MongoDB and Mysql (InnoDB) how can make some operations below are
atomic (fail or success whole):
> 1) -100$ with user A
> 2) +100$ with user B
> 3) save transaction
information like
transaction
{
sender: A
receiver: B
money : 100
date: 05/04/2013
}
Thank so much.

Answer 1

I am not sure this is what you are looking for:
db.bank.update({name : "name"},{ "$inc" : {'Account.0.money' : -100, 'Account.1.money' : 100}})
update() operation is satisfies ACI properties of ( ACID ). Durability ( D ) depends on the mongo and application configuration while making query.
You can prefer to use findAndModify() which won't yield lock on page fault
MongoDB provides transactions within a document
I can't understand, if your application requirement is very simple, then why you are trying to use mongodb. No doubt its a good data-store, but I guess MySql will satisfy all your requirements.
Just FYI : There is a doc which is exactly the problem you are trying to solve. http://docs.mongodb.org/manual/tutorial/perform-two-phase-commits/
But I won't recommend you to use this because a single query ( transferring money) has been turned into sequence of queries.
Hope it helped

Answer 2

If I use later way, How can I write transaction query (Can I use findAndModify() function?) ?
There are a lot of mis-conceptions about what findAndModify does; it is not a transaction. That being said it is atomic, which is quite different.
The reason for two phase commits and transactions in this sense is so that if something goes wrong you can fix it (Or at least have a 99.99% chance that corruption hasn't occurred)
The problem with findAndModify is that it has no such transactional behaviour, not only that but MongoDB only provides atomic state upon single document level which means that, in the same call, if your functions change multiple documents you could actually have an in-consistent in-between state in your database data. This, of course, won't do for money handling.
It is noted that MongoDB is not extremely great in these scenarios and you are trying to use MongoDB away from its purpose, with this in mind it is clear you have not researched your question well, as your next question shows:
Does MongoDB support transaction operations like Mysql (InnoDB)?
No it does not.
With all that background info aside let's look at your schema:
Bank
{
name:
address:
Account[{
name:A
age: 22
money: SS
},{
name:B
age: 23
money: S1S
}]
}
It is true that you could get a transaction query on here whereby the document would never be able to exist in a in-between state, only one or the other; as such no in-consistencies would exist.
But then we have to talk more about the real world. A document in MongoDB is 16mb big. I do not think you would fit an entire bank into one document, so this schema is badly planned and useless.
Instead you would require (maybe) a document per account holder in your bank with a subdocument of their accounts. With this you now have the problem that in-consistencies can occur.
MongoDB, as #Abhishek states, does support client side 2 phase commits but these are not going to be as good as server-side within the database itself whereby the mongod can take safety precautions to ensure that the data is consistent at all times.
So coming back to your last question:
Some pepple tell me that use Mysql for this project is the best way, and just only use MongoDB to save transaction information.(use extra collection named Transaction_money to save them), If I use both MongoDB and Mysql (InnoDB) how can make some operations below are atomic (fail or success whole):
I would say something a bit more robust than MySQL personally, I heard MSSQL is quite good for this.