MongoDB

安装配置
Windows安装：

Mongo数据模型

01
 一个Mongo系统（参考上述部署）包含一组数据库
 
02
 一个 database 包含一组collection
 

03
 一个 collection 包含一组document
 
04
 一个 document 是一组field
 

05
 一个 field 是一对key-value
 
06
 一个 key 是一个名字（字符串）
 

07
 一个 value 可以是一个
 
08
 基本类型，如字符串，整数，浮点数，时间戳，二进制等等
 

09
 document
 
10
 value的数组
 

1、下载 MongoDB

MongoDB官网下载地址：http://www.mongodb.org/downloads 我下载的是Nightly（latest & stable）

2、在C盘新建目录mongoDB，并把刚才下的Zip包中的bin解压到新建的mongoDB 中。

1
 mkdir c:\mongodb
 
2
 mkdir c:\mongodb\bin
 

bin下的文件列表如下

01
 c:\mongoDB\bin 的目录
 
02
 
 

03
 2011/09/06 14:26 <DIR> .
 
04
 2011/09/06 14:26 <DIR> ..
 

05
 2011/08/31 02:06 4,692,480 bsondump.exe
 
06
 2011/08/31 02:09 2,347,008 mongo.exe
 

07
 2011/08/31 02:14 5,054,464 mongod.exe
 
08
 2011/08/31 02:17 4,709,888 mongodump.exe
 

09
 2011/08/31 02:19 4,696,576 mongoexport.exe
 
10
 2011/08/31 02:22 4,714,496 mongofiles.exe
 

11
 2011/08/31 02:24 4,734,464 mongoimport.exe
 
12
 2011/08/31 02:27 4,705,792 mongorestore.exe
 

13
 2011/08/31 02:29 3,448,832 mongos.exe
 
14
 2011/08/31 02:31 4,774,400 mongostat.exe
 

3、在c:\mongodb下新建文件夹data

1
 mkdir c:\mongodb\data
 

4、启动mongodb

01
 c:\mongoDB\bin>mongod -dbpath c:\mongodb\data
 
02
 Tue Sep 06 16:02:06 [initandlisten] MongoDB starting : pid=452 port=27017 dbpath
 

03
 =c:\mongodb\data 64-bit
 
04
 Tue Sep 06 16:02:06 [initandlisten] db version v1.8.4-pre-, pdfile version 4.5
 

05
 Tue Sep 06 16:02:06 [initandlisten] git version: f3bd113e0df642703fda8cc9fe7f6cd
 
06
 f6503e5e8
 

07
 Tue Sep 06 16:02:06 [initandlisten] build sys info: windows (6, 1, 7601, 2, 'Ser
 
08
 vice Pack 1') BOOST_LIB_VERSION=1_42
 

09
 Tue Sep 06 16:02:06 [initandlisten] waiting for connections on port 27017
 
10
 Tue Sep 06 16:02:06 [websvr] web admin interface listening on port 28017
 

嗯 MongoDB已经起了。

Linux安装：

先去MongoDB的官方下载http://www.mongodb.org/downloads，我这里下的是LINUX 32－BIT 1.8.2的版本。

下完文件名为mongodb-linux-i686-1.8.2.tgz

解压 tar xzvf mongodb-linux-i686-1.8.2.tgz

得到文件夹mongodb-linux-i686-1.8.2，把这个文件移动到$HOME目录下，然后设置PATH

不知道HOME目录是什么就在Terminal里 echo $HOME你就知道了

在$HOME目录下建个.bashrc文件，写入如下配置

export MONGODB_HOME=/home/castiel/mongodb-linux-i686-1.8.2
export PATH=$MONGODB_HOME/bin:$PATH

好了，现在再建个目录作为保存我们数据库的地方

我还是建在$HOME目录下，名字叫mongodatabase

现在我们启动Mongodb的服务，在Terminal里输入

mongod -dbpath /home/castiel/mongodatabse

后面的参数指定了我们刚新建的文件夹作为存放数据库的地方

现在服务应该跑起来了，再开个Terminal,输入mongo,就进入mongodb的shell交互界面

如果到此一切成功，那么基础环境就算是搞定了。

使用介绍

Mongodb中有document,collection,database

关系为database里有多个collection,每个collection里有多个document

document就是以key-value的形式存放的,value也可以是document

在shell里，db代表当前所使用的数据库，

1
 show dbs ＃显示所有数据库
 
2
 db.version() ＃显示Mongodb的版本号
 

以下"collection"代表任意collection

db.collection.update ＃mongodb的update是atomic，假如有两个人同时update同一个数据，两个都会生效，数据的状态是最后update的状态（last update win）

db.collection.remove #不加参数则全部删除，但保留index

1
 x = db.collection.findOne()
 
2
 x.num = 42
 

3
 db.collection.save(x) #shell中一种比用update来更新的更好办法
 

db.drop_collection("name_of_collection") ＃彻底删除

db.collection.insert() #插入document

update里用的modifier

$set #用来设置一个document，如不存在则创建该document

1
 {"$set" : {"author.name" : "joe schmoe"}}
 

$unset #用来删除一个document

$inc #用来增加一个document的value部分，value必需是数字。如不存在则创建该document

1
 {"$inc" : {"score" : 10000}}
 

$push ＃用来向一个document的value部分，以数组的方式

1
 {$push : {"comments" :{"name" : "joe", "email" : "joe@example.com", "content" : "nice post."}}
 

$ne #与$push配合使用，不存在存会添加，存在就不会添加

1
 {"authors cited" : {"$ne" : "Richie"}}, {$push : {"authors cited" : "Richie"}}
 

$addToSet ＃同上，但是是单独使用的.有的时候你不确定某个document到底存不存在，用这个就不会造成数据的重复

1
 {"$addToSet" : {"emails" : "joe@hotmail.com"}}
 

$each ＃与$addToSet配合使用，添加数组

1
 {"$addToSet" :{"emails" : {"$each" : ["joe@php.net","joe@example.com","joe@python.org"]}}
 

$pop ＃像栈一样删除，随便从哪头开始

1
 {$pop : {key : 1}}
 
2
 {$pop : {key : －1}}
 

$pull #根据所给的KEY删除指定的document,假如有多个KEY匹配，则删除多个document

1
 {"$pull" : {"todo" : "laundry"}}
 

假如有下面这样的一个docment

01
 {
 
02
 "_id" : ObjectId("4b329a216cc613d5ee930192"),
 

03
 "content" : "...",
 
04
 "comments" : [
 

05
 {
 
06
 "comment" : "good post",
 

07
 "author" : "John",
 
08
 "votes" : 0
 

09
 },
 
10
 {
 

11
 "comment" : "i thought it was too short",
 
12
 "author" : "Claire",
 

13
 "votes" : 3
 
14
 },
 

15
 {
 
16
 "comment" : "free watches",
 

17
 "author" : "Alice",
 
18
 "votes" : -1
 

19
 }]
 
20
 }
 

我们现在想要更新第一个名为good post的comments的votes,可以这样做

1
 db.blog.update({"post" : post_id}, {"$inc" : {"comments.0.votes" : 1}}) ＃看见没，可以像操作数组一样，多方便啊
 

现在我们来把这个comment的author由John改成Jim，但如果这个时候我不知道John是在数组里的第几个，即我不知道index，这个时候可以用$,即原来用index的地主改成$,就像下面这样

1
 db.blog.update({"comments.author" : "John"},{"$set" : {"comments.$.author" : "Jim"}})
 

update还有另一种形式，就是其第三个参数设置为true，使之成为一个upsert

1
 db.analytics.update({"url" : "/blog"}, {"$inc" : {"visits" : 1}}, true)
 

上面的update包含了两个意思，以{url : "/blog"}进行查询，成功找到就更新，没有找到就创建

这样我们就不用自己写代码来判断存在或是不存在的情况了

update默认情况下只会更新第一个匹配的到的数据，如果要更新所有都匹配的数据，只要把它的第四个参数也设置为true就行

用findAndModify可以解决多线程争用问题，不知道这词用的对不对，反正自己明白就好了

用在update上

1
 ps = db.runCommand({"findAndModify" : "processes",
 
2
 "query" : {"status" : "READY"},
 

3
 "sort" : {"priority" : -1},
 
4
 "update" : {"$set" : {"status" : "RUNNING"}}).value
 

5
 do_something(ps)
 
6
 db.process.update({"_id" : ps._id}, {"$set" : {"status" : "DONE"}})
 

可以用在remove上

1
 ps = db.runCommand({"findAndModify" : "processes",
 
2
 "query" : {"status" : "READY"},
 

3
 "sort" : {"priority" : -1},
 
4
 "remove" : true).value
 

5
 do_something(ps)
 

对于，这三种操作:insert,remove,update，这三种速度都很快，因为他们都是fire-and-forget类型的操作，即不用等待服务器作出response,就马上可以进行下一步操作。

那也许你就会问，我都不能确定服务器收到了我的数据，那怎么办，其实是有办法的，现在我还没有看到而已。

1
 db.users.find({}, {"username" : 1, "email" : 1})
 

上面代码的意思是找到USERS里所有的数据里的username和email这两种KEY所对应的数据。

USERS里可能还有其它的key比如:gender,address什么的，但某些情况下我们只需要其中的一部分。

每次用find或是findOne的时候，它总是会返回_id这个key-value，不想让它返回这个怎么办，这样做

1
 db.users.find({}, {"username" : 1, "_id" : 0}) ＃这时候就只会返回username了,不会返回_id了
 

"$lt", "$lte", "$gt", "$gte" 这四个分别代表 <, <=,>, >=，它们是用来设置查询范围的，比如

1
 db.users.find({"age" : {"$gte" : 18, "$lte" : 30}}) #找出年龄在18<=age<=30之间的user
 

$ne在这里的用法，即是不等于的意思

1
 db.users.find({"username" : {"$ne" : "joe"}}) ＃找出所有名字不是JOE的user
 

$in，后接个数组，表范围

1
 db.raffle.find({"ticket_no" : {"$in" : [725, 542, 390]}}) #找出ticket_no为725或542或390的
 

数组里的数据类型可是不一样的

1
 db.users.find({"user_id" : {"$in" : [12345, "joe"]}) ＃找出user_id等于12345或是joe的人
 

与$in相反的就是$uin，用法一样

1
 db.raffle.find({"ticket_no" : {"$nin" : [725, 542, 390]}}) ＃找出ticket_no不是725，542，390的所有人
 

$or，$in或$uin的缺点就是只能用一个KEY作为条件，而是$or则可以多个

1
 db.raffle.find({"$or" : [{"ticket_no" : 725}, {"winner" : true}]}) ＃两个条件满足其一即可
 

可以将$or和$in结合起来一起用

1
 db.raffle.find({"$or" : [{"ticket_no" : {"$in" : [725, 542, 390]}},{"winner" : true}]})
 

$mod,如其名所表达的意思一样，求余数

1
 db.users.find({"id_num" : {"$mod" : [5, 1]}}) #条件为id_num%5=1,满足条件的有1,6,11,16等
 

$not，取反运算

1
 db.users.find({"id_num" : {"$not" : {"$mod" : [5, 1]}}}) ＃条件为id_num%5!=1.满足技术优势的有2，3，4，5，7等
 

$exists，用来确保KEY的存在

1
 db.c.find({"z" : {"$in" : [null], "$exists" : true}}) ＃这样就不会返回例如{y:null}这样KEY不是Z的数据了
 

可以用正则作为value查询值

1
 db.users.find({"name" : /joe/i})
 
2
 db.users.find({"name" : /joey?/i})
 

$all,即满足所有条件

1
 db.food.find({fruit : {$all : ["apple", "banana"]}}) ＃水果里必须同时有苹果和香蕉
 

$size

1
 db.food.find({"fruit" : {"$size" : 3}}) ＃fruit的size必须是3
 

$slice

1
 db.blog.posts.findOne(criteria, {"comments" : {"$slice" : 10}}) ＃前10条
 
2
 db.blog.posts.findOne(criteria, {"comments" : {"$slice" : -10}}) ＃后10条
 

3
 db.blog.posts.findOne(criteria, {"comments" : {"$slice" : [23, 10]}}) ＃以offset为23开始的10条
 

对于如下数据

1
 {
 
2
 "name" : {
 

3
 "first" : "Joe",
 
4
 "last" : "Schmoe"},
 

5
 "age" : 45
 
6
 }
 

可以这样来find，好处就是如果name里再加了个middle的属性，这条find还是有效的

1
 db.people.find({"name.first" : "Joe", "name.last" : "Schmoe"}) ＃对document里的document操作
 

如果是这样的find就不行了

1
 db.people.find({"name" : {"first" : "Joe", "last" : "Schmoe"}}) ＃如果更改了结构，加了个middle，就不能匹配
 

$elemMatch，用来匹配document里的document的，即embedded document，假设如下数据

01
 {
 
02
 "content" : "...",
 

03
 "comments" : [
 
04
 {
 

05
 "author" : "joe",
 
06
 "score" : 3,
 

07
 "comment" : "nice post"
 
08
 },
 

09
 {
 
10
 "author" : "mary",
 

11
 "score" : 6,
 
12
 "comment" : "terrible post"
 

13
 }]
 
14
 }
 

现在我们要找出作者是joe，score大于等于5的comment，就可以用$elemMatch

1
 db.blog.find({"comments" : {"$elemMatch" : {"author" : "joe","score" : {"$gte" : 5}}}})
 

$where,用指定的javascript代码来做查询，先插入两条数据

1
 db.foo.insert({"apple" : 1, "banana" : 6, "peach" : 3})
 
2
 db.foo.insert({"apple" : 8, "spinach" : 4, "watermelon" : 4})
 

然后我们找出其中值相等的的数据，这里就是spinach和watermelon，因为它们的值都是4

01
 db.foo.find({"$where" : function () {
 
02
 for (var current in this) {
 

03
 for (var other in this) {
 
04
 if (current != other && this[current] == this[other]) {
 

05
 return true;
 
06
 }
 

07
 }
 
08
 }
 

09
 return false;
 
10
 }})
 

11
 ＃如果函数返回真，则这条document就会被作为查询结果返回回来
 
12
 ＃非特殊情况下还是不要用这种方式来查询，因为效率很低，因为每个document都会通过$where被转成BSON格式，
 

13
 #交给javasript处理，然后再回到$where语句这里。
 

现在介绍下cursor，先插入100条数据，然后查询

1
 for(i=0; i<100; i++) {
 
2
 db.c.insert({x : i});
 

3
 }
 
4
 var cursor = db.collection.find()
 

然后你就可以这样来操作结果集了

1
 while (cursor.hasNext()) { ＃hasNext用来判断还有没有数据
 
2
 obj = cursor.next(); ＃next获得一条数据，然后当前的位置加1
 

3
 do stuff ＃你要进行的操作
 
4
 }
 

cursor同样也实现的迭代功能，即forEach

1
 var cursor = db.people.find();
 
2
 cursor.forEach(function(x) {
 

3
 print(x.name);
 
4
 });
 

组合用法，例如下面就是分页的一例子

1
 var cursor = db.foo.find().sort({"x" : 1}).limit(1).skip(10); #sort，排序，1为升序，－1为降序
 
2
 var cursor = db.foo.find().limit(1).sort({"x" : 1}).skip(10); ＃limit，限制返回数量
 

3
 var cursor = db.foo.find().skip(10).limit(1).sort({"x" : 1}); ＃skip，偏移量
 
4
 ＃以上只是建立好了查询语句，并没有真正向服务器提交查询，只有当调用了hasNext方法，查询才会被提交到服务器，
 

5
 ＃ 但是服务器并不回一次性将所有的查询结果一次返回，而是根据你调用next，hasNext方法
 
6
 ＃每调用一次就返回一批数据，直到全部数据都返回
 

这里要说明下用skip来分页的方法效率很低，应该用其它给的办法代替，比如说先得到前100条数据，然后用第100条数据里的某一属性做为查询条件，得到剩下的数据，然后再limit（100）。代码如下

1
 var page1 = db.foo.find().sort({"date" : -1}).limit(100)
 
2
 var latest = null;
 

3
 while (page1.hasNext()) {
 
4
 latest = page1.next();
 

5
 display(latest);
 
6
 }
 

7
 // 用第100数据里的date做为查询条件，得到剩下的数据
 
8
 var page2 = db.foo.find({"date" : {"$gt" : latest.date}});
 

9
 page2.sort({"date" : -1}).limit(100);
 

管理

索引index，注意不要为每个KEY都加上index，这样虽然查询快，但是插入的话速度就大大降低了

01
 //对people中的username建立索引,多个索引用逗号隔开，1或－1表示建立索引的顺序
 
02
 db.people.ensureIndex({"username" : 1})
 

03
 //对embedded document建立索引的方式
 
04
 db.blog.ensureIndex({"comments.date" : 1})
 

05
 //索引名是由mongodb自动建立的，你也可以指定自己想的名字，只需要传入第二个参数
 
06
 db.foo.ensureIndex({"a" : 1, "b" : 1, "c" : 1, ..., "z" : 1}, {"name" : "alphabet"})
 

07
 //unique索引，就像是关系数据库里的主键一样，值是唯一的
 
08
 db.people.ensureIndex({"username" : 1}, {"unique" : true}) //现在username的值就是唯一的了
 

09
 //dropIndex，用来删除索引的
 
10
 db.runCommand({"dropIndexes" : "foo", "index" : "alphabet"})
 

11
 //改变索引时，最长加上一个参数，即background：true，正如字面说的那在，在后台进行，不会影响当前活动的任何操作
 
12
 //如果是false的话，那么就会block任何对该collection的操作，直到新的索引建立完成
 

13
 db.people.ensureIndex({"username" : 1}, {"background" : true})
 

其实有的时候根本就不需要索引，例如你每次都要从collection中提取一半以上的数据，这个时候不用index速度更快。

使用sort时，最是对已经建立好了索引的KEY进行sort。

关于建立索引必须思考的几个问题：

弄清楚要查询的东西，为优化查询而建立索引。

建立索引时要搞清楚索引的排序（升还是降）。

你的数据库结构以后会不会拓展？是否要改变现有的索引结构。

1
 //这里多了个dropDups，意思是把重复的username给删掉，这是为了解决防止在建立索引之前就已经存在值重复而用的方法
 
2
 db.people.ensureIndex({"username" : 1}, {"unique" : true, "dropDups" : true}
 

3
 //复合索引,就是将两对KEY－VALUE作为索引
 
4
 {files_id ：ObjectId("4b23c3ca7525f35f94b60a2d")，n : 1}
 

explain，可以用来查看mongodb在作查询的一些信息，比如说它用的是哪一个索引

1
 db.c.find({age : {$gt : 10}, username : "sally"}).explain()
 

hint，如果你用explain发现mongodb用的索引不是你想用的，你可以强制使用自己想要的那个

1
 db.c.find({"age" : 14, "username" : /.*/}).hint({"username" : 1, "age" : 1})
 

aggregation

1
 db.foo.count() //计算总共有多少条数据
 
2
 db.foo.count({"x" : 1}) //按条件计算
 

3
 db.runCommand({"distinct" : "people", "key" : "age"}) //返回所有age不一样people
 

authenticate

1
 use dbname
 
2
 dbname.addUser("username","pwd")
 

3
 dbname.addUser("username","pwd",true) //加了true就代表该用户只有只读权限
 
4
 //在启动mongodb的时候加上--auth参数就可以启动用户验证
 

5
 //删除用户
 
6
 use admin
 

7
 db.system.users.remove("user":"the name of the user you want to remove")
 

数据备份和还原

01
 $ ./mongodump -d test -o backup //-d指定要备份的数据库，-o指定保存备份数据库的文件夹
 
02
 connected to: 127.0.0.1
 

03
 DATABASE: test
 
04
 to
 

05
 backup/test
 
06
 test.x to backup/test/x.bson
 

07
 1 objects
 
08
 $ ./mongorestore -d foo --drop backup/test/ // --drop 还原之前先清空数据库
 

09
 connected to: 127.0.0.1
 
10
 backup/test/x.bson
 

11
 going into namespace [foo.x]
 
12
 dropping
 

13
 1 objects
 

fsync,lock

1
 //锁定数据库，使这不能进行任何write，并强制mongodb将所有内存中的数据flush到disk上
 
2
 db.runCommand({"fsync" : 1, "lock" : 1})
 

3
 //解锁
 
4
 db.$cmd.sys.unlock.findOne(）
 

5
 //测试下是否已经解锁了
 
6
 db.currentOp()
 

修复数据库

1
 //在启动mongodb服务时，加上--repair参数
 
2
 mongod --repair
 

3
 //或是
 
4
 use somedb
 

5
 db.repairDatabase()
 

master－slave方式备份

01
 //启动一个master，端口号为10000
 
02
 $ mkdir -p ~/dbs/master
 

03
 $ ./mongod --dbpath ~/dbs/master --port 10000 --master
 
04
 //启动一个slave，端口号为10001，数据源地址（即master）为localhost:10000
 

05
 $ mkdir -p ~/dbs/slave
 
06
 $ ./mongod --dbpath ~/dbs/slave --port 10001 --slave --source localhost:10000
 

07
 
 
08
 //其它的可选项还有
 

09
 --only //设置只对某一个数据库备份，而不是整个文件夹
 
10
 --slavedelay //设置备份延迟
 

11
 
 
12
 //可以在启动slave时，不设定它的source
 

13
 $ ./mongod --slave --dbpath ~/dbs/slave --port 27018
 
14
 //而后在shell里指定
 

15
 use local
 
16
 db.sources.insert({"host" : "localhost:27017"})
 

17
 //也可以修改
 
18
 db.sources.insert({"host" : "prod.example.com:27017"}) //现在的source
 

19
 db.sources.remove({"host" : "localhost:27017"}) //移除以前的