原子性：保证事务中的所有操作全部执行或全部不执行。例如执行转账事务，要么转账成功，要么失败。成功，则金额从转出帐户转入到目的帐户，并且两个帐户金额将发生相应的变化；失败，则两个账户的金额都不变。不会出现转出帐户扣了钱，而目的帐户没有收到钱的情况。

一致性：保证数据库始终保持数据的一致性——事务操作之前是一致的，事务操作之后也是一致的，不管事务成功与否。如上面的例子，转账之前和之后数据库都保持数据上的一致性。

隔离性：多个事务并发执行的话，结果应该与多个事务串行执行效果是一样的。显然最简单的隔离就是将所有事务都串行执行：先来先执行，一个事务执行完了才允许执行下一个。但这样数据库的效率低下，如：两个不同的事务只是读取同一批数据，这样完全可以并发进行。为了控制并发执行的效果就有了不同的隔离级别。下面将详细介绍。

持久性：持久性表示事物操作完成之后，对数据库的影响是持久的，即使数据库因故障而受到破坏，数据库也应该能够恢复。通常的实现方式是采用日志。

事务隔离级别（transaction isolation levels）：隔离级别就是对对事务并发控制的等级。ANSI/ ISOSQL将其分为串行化（SERIALIZABLE）、可重复读（REPEATABLE READ）、读已提交（READ COMMITED）、读未提交（READ UNCOMMITED）四个等级。为了实现隔离级别通常数据库采用锁（Lock）。一般在编程的时候只需要设置隔离等级，至于具体采用什么锁则由数据库来设置。首先介绍四种等级，然后举例解释后面三个等级（可重复读、读已提交、读未提交）中会出现的并发问题。

串行化（SERIALIZABLE）：所有事务都一个接一个地串行执行，这样可以避免幻读（phantom reads）。对于基于锁来实现并发控制的数据库来说，串行化要求在执行范围查询（如选取年龄在10到30之间的用户）的时候，需要获取范围锁（range lock）。如果不是基于锁实现并发控制的数据库，则检查到有违反串行操作的事务时，需要滚回该事务。

可重复读（REPEATABLE READ）：所有被Select获取的数据都不能被修改，这样就可以避免一个事务前后读取数据不一致的情况。但是却没有办法控制幻读，因为这个时候其他事务不能更改所选的数据，但是可以增加数据，因为前一个事务没有范围锁。

读已提交（READ COMMITED）：被读取的数据可以被其他事务修改。这样就可能导致不可重复读。也就是说，事务的读取数据的时候获取读锁，但是读完之后立即释放（不需要等到事务结束），而写锁则是事务提交之后才释放。释放读锁之后，就可能被其他事物修改数据。该等级也是SQL Server默认的隔离等级。

读未提交（READ UNCOMMITED）：这是最低的隔离等级，允许其他事务看到没有提交的数据。这种等级会导致脏读（Dirty Read）。

       例子：下面考察后面三种隔离等级对应的并发问题。假设有两个事务。事务1执行查询1，然后事务2执行查询2，然后提交，接下来事务1中的查询1再执行一次。查询基于以下表进行：

可重复读(幻读，phantom reads)

一个事务中先后各执行一次同一个查询，但是返回的结果集却不一样。发生这种情况是因为在执行Select操作的时候没有获取范围锁（Range Lock），导致其他事务仍然可以插入新的数据。

/* Query 1 */

SELECT * FROM users

WHERE age BETWEEN 10 AND 30;

/* Query 2 */

INSERT INTO users VALUES ( 3, 'Bob', 27 );

COMMIT;

/* Query 1 */

SELECT * FROM users

WHERE age BETWEEN 10 AND 30;

注意transaction 1对同一个查询语句（Query 1）执行了两次。 如果采用更高级别的隔离等级（即串行化）的话，那么前后两次查询应该返回同样的结果集。但是在可重复读隔离等级中却前后两次结果集不一样。但是为什么叫做可重复读等级呢？那是因为该等级解决了下面的不可重复读问题。

读已提交（不可重复读，Non-repeatable reads）

在采用锁来实现并发控制的数据库系统中，不可重复读是因为在执行Select操作的时候没有加读锁（read lock）。

/* Query 1 */

SELECT * FROM users WHERE id = 1;

/* Query 2 */

UPDATE users SET age = 21 WHERE id = 1;

COMMIT; 

/* Query 1 */

SELECT * FROM users WHERE id = 1;

在这个例子当中，Transaction 2提交成功,所以Transaction 1第二次将获取一个不同的age值.在SERIALIZABLE和REPEATABLE READ隔离级别中,数据库应该返回同一个值。而在READ COMMITTED和READ UNCOMMITTED级别中数据库返回更新的值。这样就出现了不可重复读。

读未提交 (脏读，dirty reads)

如果一个事务2读取了另一个事务1修改的值，但是最后事务1滚回了，那么事务2就读取了一个脏数据，这也就是所谓的脏读。发生这种情况就是允许事务读取未提交的更新。

/* Query 1 */

SELECT * FROM users WHERE id = 1;

/* Query 2 */

UPDATE users SET age = 21 WHERE id = 1;

/* Query 1 */

SELECT * FROM users WHERE id = 1;

综上述，可以等到下面的表格：

Use the collections 'natural primary key' in the _id field.

_id's can be any type, so if your objects have a natural unique identifier, consider using that in _id to both save space and avoid an additional index.

When possible, use _id values that are roughly in ascending order.

If the _id's are in a somewhat well defined order, on inserts the entire b-tree for the _id index need not be loaded. BSON ObjectIds have this property.

Store Binary GUIDs as BinData, rather than as hex encoded strings

BSON includes a binary data datatype for storing byte arrays. Using this will make the id values, and their respective keys in the _id index, twice as small.

Note that unlike the BSON Object ID type (see above), most UUIDs do not have a rough ascending order, which creates additional caching needs for their index.

> // mongo shell bindata info: 
> help misc         
    b = new BinData(subtype,base64str)      create a BSON BinData value             
    b.subtype()                             the BinData subtype (0..255)         
    b.length()                              length of the BinData data in bytes         
    b.hex()                                 the data as a hex encoded string         
    b.base64()                              the data as a base 64 encoded string         
    b.toString() 

Extract insertion times from _id rather than having a separate timestamp field.

The BSON ObjectId format provides documents with a creation timestamp (one second granularity) for free. Almost all drivers implement methods for extracting these timestamps; see the relevant api docs for details. In the shell:

> // mongo shell ObjectId methods 
> help misc         
    o = new ObjectId()      create a new ObjectId         
    o.getTimestamp()        return timestamp derived from first 32 bits of the OID         
    o.isObjectId()         
    o.toString()         
    o.equals(otherid) 

Sort by _id to sort by insertion time

BSON ObjectId's begin with a timestamp. Thus sorting by _id, when using the ObjectID type, results in sorting by time. Note: granularity of the timestamp portion of the ObjectID is to one second only.

> // get 10 newest items 
> db.mycollection.find().sort({id:-1}).limit(10);  

1. Document Database > Most of you data is embedded in a document, so in order to get the data about a person, you don't have to join several tables. Thus, better performance for many use cases.
2. Strong Query Language > Despite not been an RDBMS, MongoDB has a very strong query language that allows you to get something very specific or very general from a document or documents. The DB is queried using javascript so you can do many more things beside querying (e.g. functions, calculations).
3. Sharding & Replication > Sharding allows you application to scale horizontally rather than vertically. In other words, more small servers instead of one huge server. And replication gives you fail-over safety in several configurations (e.g. master/slave).
4. Powerful Indexing - I originally got interested in MongoDB because it allows geo-spatial indexing out of the box but it has many other indexing configurations as well.
5. Cross-Platform - MongoDB has many drivers.