MongoDB数据库学习
首先上mongodb官网（www.mongodb.org）看了一下开始文档，下了个windows版的，装了一下，玩起。
1，安装并启动数据库
从官网（www.mongodb.org/downloads）下载一个适合你平台的版本，我的系统是win7 64位的，下载文件也就10几M，将下载的文件解压放到任何目录，最好避免使用带空格和中文的目录，本机将其解压至C盘，并将文件夹改名为mongodb，这样也是为了后面输入目录更方便。
进入mongodb目录，我们发现有如下目录结构
|--mongodb
|-- bin
|-- mongo.exe
|-- mongod.exe ........
所以整个mongodb是非常简单的，以上列的也是我们最常用的命令，其它暂时不解释。
为了以后的操作方便，因此我们将当前的bin目录加入path，如果不会的可以百度Google。
现在打开一个命令窗口，键入mongod，则窗口会提示数据库启动失败，如果你仔细看控制台打出的消息，有如下这么一行：
dbpath (/data/db/) does not exist, terminating
目录/data/db/是Linux下面的表示法，代表着数据库默认的数据文件目录，而上面的提示的意思是说数据库目录不存在，那么我们就在mongodb止录下手动建立一个目录db，当然此时屏幕上可能有些乱，这时可输入cls进行清屏操作。再输入命令：mongodb --dbpath c:/mongodb/db，此时窗口打出几行日志，然后处于等待状态了，那么就表示数据库启动成功了！当然这个窗口不能关闭。
2，登录并操作数据库（Shell方式）
2.1，连接
打开命令窗口，键入mongo，如果系统提示：connecting to: test，表示连接成功。
2.2，查看所有库
键入show dbs,则会显示出当前数据库中所有的数据库名称。在mongodb里面是不用
去手动建立一个数据库的，你只要直接使用就好，如果不存在数据库引擎会帮我们创建他们。这一点与传统数据库相比有些不同。
2.3，使用mydb
键入use mydb，使用数据库mydb，当然
mongodb会帮助我们自动创建他们，当然这个时候数据库还是空的，可以通过输入 show dbs 来确认这一点。
2.4，新增记录
输入：db.user.save({name:"Rod",age:30})
2.5，查看集合当中所有文档
db.user.find()可查看出当前库user集合中所有的文档，如下图所示：
{ "_id" : ObjectId("4df2201ac905b4e2a5f555cb"), "name" : "Rod", "age" : 30 }
此时发现，在文档的前面多了一列"_id"，这是自动加进去的，不用管他。
2.6，删除记录
db.user.remove()将删除所有记录，db.user.remove({name:"Rod"})将删除指定记录
2.6，保存多条记录
输入： for(var i=1;i<=20;i++) db.user.save({x:8,y:i}) ，可以看出整个语法很像
JS，其实你正在使用的就是一个JavaScript Shell。此时可以输入db.user.find() 来查看所有记录。
2.7，迭代器的使用
我们再向集合中插入一条记录：db.user.save({x:"test"})，再次查看所有记录
db.user.find()，则发现只显示出了前20条记录。此时可以输入it（iteraor）来
查看余下的记录。 在mongodb里可以将cursor当成数组来使用，如下所示：
var cursor = db.user.find(); // 将游标缓存起来
printjson(cursor[4]); // 打印出第5条记录
注意此种方式会将前N行全查出来，所以对性能有较大影响。
2.8，根据条件查询
现要查询出y大于10的所有记录：
db.user.find({y:{$gt:10}});
其中$gt的意思就是“大于”，当然读者可推出其他N种表达。
2.9，查询指定列
db.user.find({x:8},{y:true});// 查询出x=8的所有记录的y列
db.user.find({},{y:true}); // 查询出所有的Y列
2.10，只查第一列
有的时候我们只需要第一行的值，如果自己编程实现显得有些麻烦，因此数据库为我们
提供了一个方法：db.user.findOne();
2.11，限制最大记录从而提高性能
我们可以通过limit来限制查询的最大行数，如下：
db.user.find().limit(4); // 只显示出前四条
2.12，修改记录
将第一条x为3的记录修改为后面的值，db.user.update({x:4},{x:4,y:1});
3，MongoDB 数据结构
从以上可以看出，每一个MongoDB包含了多个库（通过show dbs查看），这些库都是在第一次使用时自动创建的可以通过use dbName来使用指定库。每一个库包含了多个集合，可以使用命令show collections 显示所有集合，所以我们在操作文档的时候要手动指定集合(db.user.find)，每个集合包含多份文档，也就是json对象。
4，利用java操作MongoDB
从官网下载java版本的驱动并将其加入classpath。
3.1，建立连接
Mongo m = new Mongo(); // 连接本地的27017端口
// or
Mongo m = new Mongo( "localhost" ); // 默认端口27017
// or
Mongo m = new Mongo( "localhost" , 27017 ); // 指定主机与端口
DB db = m.getDB( "mydb" ); // 取得指定的库
3.2，用户认证（可选）
在登录数据库时，在数据库启动时可以指定是否需要认证（mongod --auth .....），
此时连接时就需要用户名和密码（--serviceUser xx --servicePassword xx），如下：
boolean auth = db.authenticate(myUserName, myPassword);
3.3，得到指定库的所有集合
Set
for (String s : colls) {
System.out.println(s);
}
3.4，得到指定集合
DBCollection coll = db.getCollection("user");
3.5，插入文档
BasicDBObject doc = new BasicDBObject();
doc.put("name", "MongoDB");
doc.put("type", "database");
doc.put("count", 1);
BasicDBObject info = new BasicDBObject();
info.put("x", 203);
info.put("y", 102);
doc.put("info", info);
coll.insert(doc); // 保存
3.6，查询集合中的第一份文档
DBObject myDoc = coll.findOne();
3.7，增加多份文档
for (int i=0; i < 100; i++) {
coll.insert(new BasicDBObject().append("i", i));
}
3.8，统计集合中文档的条数
System.out.println(coll.getCount());
3.9，利用游标得到所有记录
DBCursor cur = coll.find();
while(cur.hasNext()) {
System.out.println(cur.next());
}
3.10，查询指定文档
BasicDBObject query = new BasicDBObject();
query.put("x", 8);
cur = coll.find(query);
while(cur.hasNext()) {
System.out.println(cur.next());
}
有时个为了方便我们也可以写成这种形式：
query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));
// i.e. 20 < i <= 30
3.11，创建一个索引
coll.createIndex(new BasicDBObject("i", 1));
// create index on "i", ascending
3.12，查询集合中的索引列表
List
3.13，得到所有的库名
Mongo m = new Mongo();
m.getDatabaseNames();
3.14，删除一个库
m.dropDatabase("my_new_db");
4，MongoDB类型与java类型
4.1，自动成生主键
ObjectId id = new ObjectId();
ObjectId copy = new ObjectId(id);
4.2，正则表达式的运用
Pattern john = Pattern.compile("joh?n", CASE_INSENSITIVE);
BasicDBObject query = new BasicDBObject("name", john);
// finds all people with "name" matching /joh?n/i
DBCursor cursor = collection.find(query);
4.3，日期类型
java.util.Date now = new java.util.Date();
BasicDBObject time = new BasicDBObject("ts", now);
collection.save(time);
4.4, 数组
ArrayList x = new ArrayList();
x.add(1);
x.add(2);
x.add(new BasicDBObject("foo", "bar"));
x.add(4);
BasicDBObject doc = new BasicDBObject("x", x);
4.5，二进制数据
字节数组（byte[]）会被自动包装成二进制类型。
4.6，时间
Timestamp会被转换成BSONTimestamp。
4.7，源代码数据
源代码数据代表了JavaScript代码。CodeWScope类代表了这种数据。
5，高级操作部分
5.1，数据据安全
为了使MongoDB安全生效，必须以--auth参数启动，同时还要在db.system.users文档中增加用户信息
如果在db.system.users中无数据，即使以--auth启动，对于本地的访问也是允许的。
增加一个新的用户：db.addUser("foo", "bar");
查询刚才增加的用户：db.system.users.find();
删除用户：db.removeUser("foo");
为了提高查询性能和安全性，也可增加只读用户：db.addUser("foo", "bar", true);
此时虽然用户已经有了，但是怎么去测试是否生效了呢？先进行认证测试一下，如下：
db.auth("foo", "bar");
如果在服务端打出1则表示认证通过，客户端可以使用了，如果是0表示不通过
那么在客户端可以通过如下代码进行认证：
db.authenticate("foo", "bar".toCharArray());
由此可知，所有的用户信息是加在数据库上面的，每个库都有自己的用户信息。
如此便可增加安全认证功能了！
5.2，引用vs 内嵌
在关系型数据库中，我们可以通过外键引用来表达一对多关联，建立中间表来表达多对多关联。在MongoDB中却没有这种机制，我们可以通过对象的引用关系来实现这种关联，也可以把关联的文档内嵌到文档当中。
对于引用这种方式，我们可以通DBRef这个类进行实现。
那么在实际工作当中，我们应该选择哪种存储方式，有如下规则：
1） 顶层对象应该有自己的集合
2） 明细对象应该被嵌入父对象，例如OrderDetail与Order
3） 拥有包含关系的对易用应该被嵌入
4） 对于多对多关联应该使用数据库引用
5） 对于那种稳定的比较小的集合可以在服务器端将其缓存起来从而提高性能
6） 不能去引用一个嵌入的对象，至少目前还无法实现
7） 我们很难去统计嵌入的对象
8） 如果嵌入的对象太多太大会导致单个对象达到他的最大值
9） 记住最后一条：如果遇到性能问题，那么请使用嵌入方式进行存储
5.3，数据库优化
1）对于排序的字段，请加入索引
现在根据y字段倒序显示：db.user.find().sort({y: -1});，为了提高性能那么需要在字段y上加入索引
db.user.ensureIndex({y:1});这样一来，就可以根据索引排序，而不是直接查绚集合中的所有文档。
2）限制最大记录数：db.user.find().limit(10);
3）只查询所需要的键，而不是所有全查出来：db.user.find({}, {y: 1});
4）统计记录条数利用count()方法：db.user.find().count();
5）强制使用指定索引：db.user.find().hint({y: 1});
5.4，高级查询
1）利用索引提高查询速度
首先我们在x字段上建立索引：db.user.ensuerIndex({x : 1});
然后再查询：db.user.find({x:8}, {_id: 0, x: 1}).explain(); 会有如下输出： {
"cursor" : "BtreeCursor x_1",
"nscanned" : 19,
"nscannedObjects" : 19,
"n" : 19,
"millis" : 0,
"nYields" : 0,
"nChunkSkips" : 0,
"isMultiKey" : false,
"indexOnly" : true,
……………………….
}
其中"indexOnly" : true代表着此次查询启用了索引。
一般的查询不会利用索引，除非满足以下条件，
A） 必须列出要返回的字段名，这样才能决定是否需要启用索引
B） 必须显示的指出不显示_id字段{ _id : 0}
2）利用“.”（点号）进行对象间的导航
> db.user.find({}, {“x.y” : 1});
3）查询指定范围的值：db.user.find({y: {$gt : 4, $lt : 10}}); // 4 < y < 10
4）匹配所有$all：db.things.find( { a: { $all: [ 2, 3 ] } } );
5）存在性判断$exists：
db.things.find( { a : { $exists : true } } ); // 如果存在则返回
db.things.find( { a : { $exists : false } } ); // 如果不存在则返回
6）求余$mod：db.things.find( "this.a % 10 == 1")，也可写成如下形式：
db.things.find( { a : { $mod : [ 10 , 1 ] } } )
7）不等于$ne：db.things.find( { x : { $ne : 3 } } );
8）IN子句$in：db.things.find({j:{$in: [2,4,6]}});
9）Not In子句$nin：db.things.find({j:{$nin: [2,4,6]}});
10）OR条件$or：db.foo.find( { $or : [ { a : 1 } , { b : 2 } ] } )
11）利用正则表达式进行复杂匹配
db.customers.find( { name : /acme.*corp/i } );
db.customers.find( { name : { $regex : "acme.*corp", $options: "i" } } );
db.customers.find( { name : { $regex : /acme.*corp/i, $nin : ["acmeblahcorp"] } } );
i表示大小写不敏感
12）取反操作$not：db.customers.find( { name : { $not : /acme.*corp/i } } );
13）统计文档数：
nstudents = db.students.find({"address.state" : "CA"}).count();
不要这样做，这样会导致客户端排序，增加网络传输
nstudents = db.students.find({"address.state" : "CA"}).toArray().length; // VERY BAD
14）分页查询： n = db.students.find().skip(20).limit(10).count(true);
15）排序sort()： db.myCollection.find().sort( { ts : -1 } ); // 按TS降序排列
转自：http://blog.csdn.net/wangpeng047/article/details/7705588
上一节我们讲解了对于MongoDB的一些认识和概念，那么接下来就要切实步入mongodb的学习中了。
mongodb不像关系型数据库有很强大的GUI客户端，虽然mongodb也有，但功能和稳定性实在不敢恭维，所以操作mongodb我们大部分都是用类似cmd命令的方式（mongodb称为shell操作）来完成，因此学好mongodb shell操作是非常重要的基础。
一、准备工作
1、 下载mongoDB
下载地址：http://www.mongodb.org/downloads
选择合适你的版本
相关文档：http://www.mongodb.org/display/DOCS/Tutorial
2、 安装mongoDB
A、 不解压模式：
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默认端口27017，db保存的路径是系统C硬盘目录的根目录的/data/db目录。也就是说，如果你的mongoDB-xxx.zip在E盘，那么你需要在C盘下建立data/db目录。mongoDB不会帮你建立这个目录的。
然后运行mongo即可连接到test数据库，你就可以进行数据操作。运行help显示帮助命令行。
B、 解压模式
将下载下来的mongoDB-xxx.zip解压到任意目录，找到bin目录，运行mongod.exe就可以启动mongoDB，默认端口27017，db保存的路径是当前zip所在硬盘目录的根目录的/data/db目录。也就是说，如果你的mongoDB-xxx.zip在E盘，那么你需要在E盘下建立data/db目录。mongoDB不会帮你建立这个目录的。
然后运行mongo即可连接到test数据库，你就可以进行数据操作。运行help显示帮助命令行。
3、 简单测试
- > 2+4
- 6
- > db
- test
- > //第一次插入数据会创建数据库
- Fri May 20 16:47:39 malformed UTF-8 character sequence at offset 27
- error2:(shellhelp1) exec failed: malformed UTF-8 character sequence at offset 27
- > db.foo.insert({id: 2011, userName: 'hoojo', age: 24, email: "[email protected]"});
- > db.foo.find();
- { "_id" : ObjectId("4dd62b0352a70cbe79e04f81"), "id" : 2011, "userName" : "hoojo",
- "age" : 24, "email" : "[email protected]" }
- >
上面完成了简单运算，显示当前使用的数据库，以及添加数据、查询数据操作
二、DB shell数据操作
shell命令操作语法和JavaScript很类似，其实控制台底层的查询语句都是用JavaScript脚本完成操作的。
Ø 数据库
1、Help查看命令提示
- > help
- > db.help();
- > db.yourColl.help();
- > db.youColl.find().help();
- > rs.help();
2、切换/创建数据库
- > use yourDB;
当创建一个集合(table)的时候会自动创建当前数据库
3、查询所有数据库
- > show dbs;
4、删除当前使用数据库
- > db.dropDatabase();
5、从指定主机上克隆数据库
- > db.cloneDatabase(“127.0.0.1”);
将指定机器上的数据库的数据克隆到当前数据库
6、从指定的机器上复制指定数据库数据到某个数据库
- > db.copyDatabase("mydb", "temp", "127.0.0.1");
将本机的mydb的数据复制到temp数据库中
7、修复当前数据库
- > db.repairDatabase();
8、查看当前使用的数据库
- > db.getName();
- > db;
db和getName方法是一样的效果，都可以查询当前使用的数据库
9、显示当前db状态
- > db.stats();
10、当前db版本
- > db.version();
11、查看当前db的链接机器地址
- > db.getMongo();
Ø Collection聚集集合
1、创建一个聚集集合（table）
- > db.createCollection(“collName”, {size: 20, capped: 5, max: 100});
2、得到指定名称的聚集集合（table）
- > db.getCollection("account");
3、得到当前db的所有聚集集合
- > db.getCollectionNames();
4、显示当前db所有聚集索引的状态
- > db.printCollectionStats();
Ø 用户相关
1、添加一个用户
- > db.addUser("name");
- > db.addUser("userName", "pwd123", true);
添加用户、设置密码、是否只读
2、数据库认证、安全模式
- > db.auth("userName", "123123");
3、显示当前所有用户
- > show users;
4、删除用户
- > db.removeUser("userName");
Ø 其他
1、查询之前的错误信息
- > db.getPrevError();
2、清除错误记录
- > db.resetError();
三、Collection聚集集合操作
Ø 查看聚集集合基本信息
1、查看帮助
- > db.yourColl.help();
2、查询当前集合的数据条数
- > db.yourColl.count();
3、查看数据空间大小
- > db.userInfo.dataSize();
4、得到当前聚集集合所在的db
- > db.userInfo.getDB();
5、得到当前聚集的状态
> db.userInfo.stats();6、得到聚集集合总大小
> db.userInfo.totalSize();7、聚集集合储存空间大小
> db.userInfo.storageSize();8、Shard版本信息
> db.userInfo.getShardVersion()
9、聚集集合重命名
> db.userInfo.renameCollection("users");将userInfo重命名为users
10、删除当前聚集集合
> db.userInfo.drop();Ø 聚集集合查询
1、查询所有记录
> db.userInfo.find();相当于：select * from userInfo;
默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；”
但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize = 50;这样每页就显示50条记录了。
2、查询去掉后的当前聚集集合中的某列的重复数据
> db.userInfo.distinct("name");会过滤掉name中的相同数据
相当于：select distict name from userInfo;
3、查询age = 22的记录
> db.userInfo.find({"age": 22});相当于：select * from userInfo where age = 22;
4、查询age > 22的记录
> db.userInfo.find({age: {$gt: 22}});相当于：select * from userInfo where age > 22;
5、查询age < 22的记录
> db.userInfo.find({age: {$lt: 22}});相当于：select * from userInfo where age < 22;
6、查询age >= 25的记录
> db.userInfo.find({age: {$gte: 25}});相当于：select * from userInfo where age >= 25;
7、查询age <= 25的记录
> db.userInfo.find({age: {$lte: 25}});8、查询age >= 23 并且 age <= 26
> db.userInfo.find({age: {$gte: 23, $lte: 26}});9、查询name中包含 mongo的数据
> db.userInfo.find({name: /mongo/});相当于：select * from userInfo where name like ‘%mongo%’;
10、查询name中以mongo开头的
> db.userInfo.find({name: /^mongo/});select * from userInfo where name like ‘mongo%’;
11、查询指定列name、age数据
> db.userInfo.find({}, {name: 1, age: 1});相当于：select name, age from userInfo;
当然name也可以用true或false,当用ture的情况下河name:1效果一样，如果用false就是排除name，显示name以外的列信息。
12、查询指定列name、age数据, age > 25
> db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1});相当于：select name, age from userInfo where age > 25;
13、按照年龄排序
升序：
> db.userInfo.find().sort({age: 1});
降序：
> db.userInfo.find().sort({age: -1});14、查询name = zhangsan, age = 22的数据
> db.userInfo.find({name: 'zhangsan', age: 22});相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;
15、查询前5条数据
> db.userInfo.find().limit(5);相当于：select top 5 * from userInfo;
16、查询10条以后的数据
> db.userInfo.find().skip(10);相当于：select * from userInfo where id not in ( select top 10 * from userInfo );
17、查询在5-10之间的数据
> db.userInfo.find().limit(10).skip(5);可用于分页，limit是pageSize，skip是第几页*pageSize
18、or与 查询
> db.userInfo.find({$or: [{age: 22}, {age: 25}]});相当于：select * from userInfo where age = 22 or age = 25;
19、查询第一条数据
> db.userInfo.findOne();相当于：select top 1 * from userInfo;
> db.userInfo.find().limit(1);20、查询某个结果集的记录条数
> db.userInfo.find({age: {$gte: 25}}).count();相当于：select count(*) from userInfo where age >= 20;
21、按照某列进行排序
> db.userInfo.find({sex: {$exists: true}}).count();相当于：select count(sex) from userInfo;
Ø 索引
1、创建索引
> db.userInfo.ensureIndex({name: 1});
> db.userInfo.ensureIndex({name: 1, ts: -1});2、查询当前聚集集合所有索引
> db.userInfo.getIndexes();
3、查看总索引记录大小
> db.userInfo.totalIndexSize();4、读取当前集合的所有index信息
> db.users.reIndex();5、删除指定索引
> db.users.dropIndex("name_1");6、删除所有索引索引
> db.users.dropIndexes();Ø 修改、添加、删除集合数据
1、添加
> db.users.save({name: ‘zhangsan’, age: 25, sex: true});添加的数据的数据列，没有固定，根据添加的数据为准
2、修改
> db.users.update({age: 25}, {$set: {name: 'changeName'}}, false, true);相当于：update users set name = ‘changeName’ where age = 25;
> db.users.update({name: 'Lisi'}, {$inc: {age: 50}}, false, true);相当于：update users set age = age + 50 where name = ‘Lisi’;
> db.users.update({name: 'Lisi'}, {$inc: {age: 50}, $set: {name: 'hoho'}}, false, true);相当于：update users set age = age + 50, name = ‘hoho’ where name = ‘Lisi’;
3、删除
> db.users.remove({age: 132});4、查询修改删除
- > db.users.findAndModify({
- ... query: {age: {$gte: 25}},
- ... sort: {age: -1},
- ... update: {$set: {name: 'a2'}, $inc: {age: 2}},
- ... remove: true
- ... });
- > db.runCommand({ findandmodify : "users",
- ... query: {age: {$gte: 25}},
- ... sort: {age: -1},
- ... update: {$set: {name: 'a2'}, $inc: {age: 2}},
- ... remove: true
- ... });
update 或 remove 其中一个是必须的参数; 其他参数可选。
| 参数 |
详解 |
默认值 |
| query |
查询过滤条件 |
{} |
| sort |
如果多个文档符合查询过滤条件，将以该参数指定的排列方式选择出排在首位的对象，该对象将被操作 |
{} |
| remove |
若为true，被选中对象将在返回前被删除 |
N/A |
| update |
一个 修改器对象 |
N/A |
| new |
若为true，将返回修改后的对象而不是原始对象。在删除操作中，该参数被忽略。 |
false |
| fields |
参见Retrieving a Subset of Fields (1.5.0+) |
All fields |
| upsert |
创建新对象若查询结果为空。 示例 (1.5.4+) |
false |
1、简单Hello World
- > print("Hello World!");
这种写法调用了print函数，和直接写入"Hello World!"的效果是一样的；
2、将一个对象转换成json
- > tojson(new Object());
- > tojson(new Object('a'));
3、循环添加数据
- > for (var i = 0; i < 30; i++) {
- ... db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
- ... };
这样就循环添加了30条数据，同样也可以省略括号的写法
- > for (var i = 0; i < 30; i++) db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
也是可以的，当你用db.users.find()查询的时候，显示多条数据而无法一页显示的情况下，可以用it查看下一页的信息；
4、find 游标查询
- >var cursor = db.users.find();
- > while (cursor.hasNext()) {
- ... printjson(cursor.next());
- ... }
这样就查询所有的users信息，同样可以这样写
- >var cursor = db.users.find();
- >while (cursor.hasNext()) { printjson(cursor.next); }
同样可以省略{}号
5、forEach迭代循环
- >db.users.find().forEach(printjson);
forEach中必须传递一个函数来处理每条迭代的数据信息
6、将find游标当数组处理
- > var cursor = db.users.find();
- > cursor[4];
取得下标索引为4的那条数据
既然可以当做数组处理，那么就可以获得它的长度：cursor.length();或者cursor.count();
那样我们也可以用循环显示数据
- > for (var i = 0, len = c.length(); i < len; i++) printjson(c[i]);
7、将find游标转换成数组
- > var arr = db.users.find().toArray();
- > printjson(arr[2]);
用toArray方法将其转换为数组
8、定制我们自己的查询结果
只显示age <= 28的并且只显示age这列数据
- > db.users.find({age: {$lte: 28}}, {age: 1}).forEach(printjson);
- > db.users.find({age: {$lte: 28}}, {age: true}).forEach(printjson);
排除age的列
- > db.users.find({age: {$lte: 28}}, {age: false}).forEach(printjson);
9、forEach传递函数显示信息
- > db.things.find({x:4}).forEach(function(x) {print(tojson(x));});
上面介绍过forEach需要传递一个函数，函数会接受一个参数，就是当前循环的对象，然后在函数体重处理传入的参数信息。
那么关于mongodb的shell操作的讲解就先到这了，基本涵盖了mongodb最为常用的操作方法，那么下一节我们会讲述用Java如何驱动mongodb，即所谓的CRUD。
转自：http://blog.csdn.net/wangpeng047/article/details/7612948
一、基本概念
MongoDB 是一个高性能，开源，无模式的文档型数据库，是当前NoSQL 数据库产品中最热门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式，MongoDB 使用C++开发。MongoDB 的官方网站地址是：http://www.mongodb.org/，大家可以在此获得更详细的信息。
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json 的bjson 格式，因此可以存储比较复杂的数据类型。MongoDB 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。它是一个面向集合的,模式自由的文档型数据库。
二、对比
|
|
MongoDB |
关系型数据库 |
| 数据存储 |
面向集合 |
面向关系表 |
| 数据结构 |
模式自由 |
二维表关系模式 |
| 事务 |
不支持 |
支持 |
| 大型数据（视频） |
很好 |
一般 |
| 大数据量查询（千万条以上） |
很好 |
较差 |
| 数据库维护 |
相对简单 |
相对复杂 |
| 数据及表关系、结构浏览 |
困难 |
简单 |
| 数据安全性 |
较差 |
很好 |
| 分布式 |
很好 |
一般 |
| 查询 |
非常灵活 |
非常强大 |
| 主外键关联 |
不支持 |
支持 |
| 索引 |
支持 |
支持 |
| 存储过程 |
支持 |
支持 |
三、对比说明
1. 数据存储
MongoDB是面向集合（collection）的，集合中又包含多个文档（document），并支持对象型数据的存储。其中集合和文档的概念，在关系型数据库中类似于表（table）和元组（row：也就是所谓的一行数据）。另外MongoDB是以bson形式存储，而关系型数据库是以二维关系形式存储。
2. 数据结构
MongoDB对数据结构的支持非常灵活，从横向到纵向的支持都很好，比如下面的数据都能存储在同一个集合中：
① {“name”: “wangwu”, “age”: 25}
② {“name”: “lisi”}
③ {“state”: “激活”, “remark”: “无”}
④ {“name”: 6, “age”: “你猜”}
从上面的例子我们能看出，横向方面，支持字段的动态增减（如①和②），从纵向方面，支持字段数据类型混合存储（如①和④）。而在关系型数据库中这种方式的存储是绝对达不到的。
3. 事务
MongoDB本身不支持事务处理，只能通过程序代码来保证。
4. 大型数据
MongoDB不仅支持结构化数据，还支持非结构化数据存储（音频、视频、文档、XML、HTML等），而关系型数据库虽然支持大型数据（如视频）的存储，但是不管从存储效率上还是从获取速度上都不及MongoDB，MongoDB可采用高效的二进制来存储大型数据。
5. 大型数据量查询
MongoDB对于上千万条以上的数据，在查询速度上非常快。而这点却是关系型数据库中的一大痛处。
6. 数据库维护
MongoDB在数据库备份和还原以及数据的导入导出的操作上是非常简单的，通过简单的命令即可完成，还支持主-从模式及服务器之间的相互复制。复制的主要目标是提供冗余及自动故障转移，而关系型数据库在操作上相对复杂一些，上手难一些。
7. 数据及表关系、结构浏览
MongoDB因为没什么特别好的GUI客户端，所以在数据浏览和表关系、结构浏览上是非常困难和笨拙的，关系型数据库在这方面上优势明显。
8. 数据安全性
MongoDB在数据安全方面比较差，如果稍有不慎或操作不当，很容易造成数据丢失或数据错误，因此在数据维护和操作上，要非常小心。而关系型数据库在这方面上的担心却要少很多。
9. 分布式
MongoDB非常适合由数十或数百台服务器组成的数据库。支持自动分片以支持云级别的伸缩性。其中自动分片功能支持水平的数据库集群，可动态添加额外的机器。关系型数据库在分布式的支持和操作上都要困难些、发杂些。
10. 查询
MongoDB的查询语句与关系型的sql语句有着很大的不同，或者说是两种风格，二者表现都很不错，MongoDB主要体现在灵活易用上，而sql则体现在功能全面强大上。
11. 主外键关联
MongoDB不支持主外键关联，也没有“约束”的概念。
12. 索引
MongoDB同样支持索引
13. 存储过程
MongoDB同样也支持存储过程
四、总结
通过以上对比，我们可以看出MongoDB是以牺牲安全、事务、结构来换取简单、高效、灵活的，所以关系型也好非关系型也好都有他们适用的场合，非关系型数据库的出现，为我们多提供了一条选择的道路，从而在数据维护和存储上给予了我们很大的帮助，让我们在软件开发上能更加得心应手，因此传统保守关系型数据库观念的人们，可以试试体验下非关系型数据库，也许你一下就会迷上他，在关系型数据库大行其道今天，掌握好一门非关系型数据库对你未来的发展也是非常有利的。
那么关于MongoDB的入门简介就先到这里，笔者今后会对MongoDB具体的内容进行较为系统的总结和介绍，希望能帮助需要用到的朋友。
转自：http://www.linuxidc.com/Linux/2015-11/125008.htm
今天记录下MongoDB的基本操作，这只是最基本的，所以是应该掌握的。
数据库
数据库是一个物理容器集合。每个数据库都有自己的一套文件系统上的文件。一个单一的MongoDB服务器通常有多个数据库。
集合
集合是一组MongoDB的文档。它相当于一个RDBMS表。收集存在于一个单一的数据库。集合不执行模式。集合内的文档可以有不同的领域。通常情况下，一个集合中的所有文件是相同或相关的目的。
文档
文档是一组键 - 值对。文件动态模式。动态模式是指，在相同集合中的文档不需要具有相同的字段或结构组的公共字段的集合的文档，可以容纳不同类型的数据。
关系型数据库与MongoDB的对比
看到这个表我想你对MongoDB也一定有自己的认识了。
MongoDB支持许多数据类型的列表下面给出：
- String : 这是最常用的数据类型来存储数据。在MongoDB中的字符串必须是有效的UTF-8。
- Integer : 这种类型是用来存储一个数值。整数可以是32位或64位，这取决于您的服务器。
- Boolean : 此类型用于存储一个布尔值 (true/ false) 。
- Double : 这种类型是用来存储浮点值。
- Min/ Max keys : 这种类型被用来对BSON元素的最低和最高值比较。
- Arrays : 使用此类型的数组或列表或多个值存储到一个键。
- Timestamp : 时间戳。这可以方便记录时的文件已被修改或添加。
- Object : 此数据类型用于嵌入式的文件。
- Null : 这种类型是用来存储一个Null值。
- Symbol : 此数据类型用于字符串相同，但它通常是保留给特定符号类型的语言使用。
- Date : 此数据类型用于存储当前日期或时间的UNIX时间格式。可以指定自己的日期和时间，日期和年，月，日到创建对象。
- Object ID : 此数据类型用于存储文档的ID。
- Binary data : 此数据类型用于存储二进制数据。
- Code : 此数据类型用于存储到文档中的JavaScript代码。
- Regular expression : 此数据类型用于存储正则表达式
下面开始真正的操作MongoDB
show dbs : 查看数据库列表
use 命令 ：该命令将创建一个新的数据库，如果它不存在，否则将返回现有的数据库。
use myMongo (创建的数据库myMongo 列表中是不存在的。要显示的数据库，需要把它插入至少一个文件,如：db.test.insert({name:"张三",age:"18"}))
dropDatabase() 方法 ： db.dropDatabase() 命令是用来删除一个现有的数据库。它将删除选定的数据库。如果还没有选择任何数据库，然后它会删除默认的 ' test' 数据库
createCollection() 方法 ： db.createCollection(name, options) 是用来创建集合. name是集合的名称。options是一个文件，用于指定配置的集合
show collections ： 可以查看创建的集合列表
在MongoDB中，不需要创建集合。当插入一些文件 MongoDB 自动创建的集合。
drop() 方法 ： db.collection.drop() 是用来从数据库中删除一个集合。
drop() 方法将返回 true，如果选择成功收集被丢弃，否则将返回 false
insert() 方法 : 要插入数据到 MongoDB 集合，需要使用 MongoDB 的 insert() 或 save() 方法。
这里用了两种查询方法，下面会介绍的.这里你可以看我我插入了一个数组["MongoDB","python","Hadoop"]
这里 myCollection1是集合的名称。如果集合在数据库中不存在，那么MongoDB 将创建此集合，然后把它插入文档。我们也可以插入数组，道理是一样的，你可以自己试试。
插入文档中，如果我们不指定_id参数，然后MongoDB 本文档分配一个独特的ObjectId。_id 是12个字节的十六进制数，唯一一个集合中的每个文档.
find() 方法 ： 查询集合数据，find() 方法将在非结构化的方式显示所有的文件。pretty() 方法将以格式化的方式显示数据。
上边的例子已经展示了。除了find() 方法外，还有一个 findOne() 法，返回一个文件。
下面做下条件查询：RDBMS Where子句和MongoDB等同语句
AND用法
OR用法
Limit() 方法和skip()方法一般结合使用可用作分页： 要限制 MongoDB 中的记录，需要使用 limit() 方法。 limit() 方法接受一个数字型的参数，这是要显示的文档数。skip()方法也接受数字类型的参数，并使用跳过的文档数
remove() 方法 ： 用于从集合中删除文档。remove() 方法接受两个参数。第一个是删除criteria ，第二是justOne标志：
deletion criteria :（可选）删除标准，根据文件将被删除。
justOne : （可选）如果设置为true或1，然后只删除一个文件。如果有多个记录且要删除的只有第一条记录，那么设置remove()方法中justOne参数
如果不指定删除条件，然后MongoDB将从集合中删除整个文件
Update() 方法 ： 更新文档 ，若要更新多个需要设置参数置'multi' 为true
sort() 方法 ： 接受一个文档，其中包含的字段列表连同他们的排序顺序。要指定排序顺序1和-1。 1用于升序排列，而-1用于降序。请注意，如果不指定排序优先，然后sort() 方法将文档显示在升序排列。
就写到这吧，有时间会写一些深入的。希望大家指教。
更多MongoDB相关内容可以看看以下的有用链接：
MongoDB 3.0 正式版发布下载 http://www.linuxidc.com/Linux/2015-03/114414.htm
CentOS编译安装MongoDB http://www.linuxidc.com/Linux/2012-02/53834.htm
CentOS 编译安装 MongoDB与mongoDB的php扩展 http://www.linuxidc.com/Linux/2012-02/53833.htm
CentOS 6 使用 yum 安装MongoDB及服务器端配置 http://www.linuxidc.com/Linux/2012-08/68196.htm
Ubuntu 13.04下安装MongoDB2.4.3 http://www.linuxidc.com/Linux/2013-05/84227.htm
MongoDB入门必读(概念与实战并重) http://www.linuxidc.com/Linux/2013-07/87105.htm
Ubunu 14.04下MongoDB的安装指南 http://www.linuxidc.com/Linux/2014-08/105364.htm
《MongoDB 权威指南》(MongoDB: The Definitive Guide)英文文字版[PDF] http://www.linuxidc.com/Linux/2012-07/66735.htm
Nagios监控MongoDB分片集群服务实战 http://www.linuxidc.com/Linux/2014-10/107826.htm
基于CentOS 6.5操作系统搭建MongoDB服务 http://www.linuxidc.com/Linux/2014-11/108900.htm
MongoDB 的详细介绍：请点这里
MongoDB 的下载地址：请点这里
本文永久更新链接地址：http://www.linuxidc.com/Linux/2015-11/125008.htm