-
安装配置
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"}) //移除以前的 |