mongoDB配制及学习

http://blog.csdn.net/zj7758/article/details/7102996
--------------------------------------------------
mongoDB配制及学习
分类：数据库 2011-12-26 14:20 387人阅读评论(0) 收藏举报
第一部分基础篇
第一章走进MongoDB
MongoDB 是一个高性能，开源，无模式的文档型数据库，是当前NoSQL 数据库产品中最热
门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式，MongoDB 使
用C++开发。MongoDB 的官方网站地址是：http://www.mongodb.org/，读者朋友们可以在
此获得更详细的信息。

6 / 91
1.1 为什么要用NoSQL
1.1.1 NoSQL简介
NoSQL，全称是”Not Only Sql”,指的是非关系型的数据库。这类数据库主要有这些特点：非关
系型的、分布式的、开源的、水平可扩展的。原始的目的是为了大规模web 应用，这场全
新的数据库革命运动早期就有人提出，发展至2009 年趋势越发高涨。NoSQL 的拥护者们提
倡运用非关系型的数据存储，通常的应用如：模式自由、支持简易复制、简单的API、最终
的一致性（非ACID）、大容量数据等。NoSQL 被我们用得最多的当数key-value 存储，当然还
有其他的文档型的、列存储、图型数据库、xml 数据库等。相对于目前铺天盖地的关系型数
据库运用，这一概念无疑是一种全新思维的注入。
1.1.2 发展现状
现今的计算机体系结构在数据存储方面要求应用架构具备庞大的水平扩展性，而NoSQL 正
在致力于改变这一现状。目前新浪微博的Redis 和Google 的Bigtable 以及Amazon 的SimpleDB
使用的就是NoSQL 型数据库。
NoSQL 项目的名字上看不出什么相同之处，但是，它们通常在某些方面相同：它们可以处理
超大量的数据。
这场革命目前仍然需要等待。NoSQL 对大型企业来说还不是主流，但是，一两年之后很可能
就会变个样子。在NoSQL 运动的最新一次聚会中，来自世界各地的150 人挤满了CBS
Interactive 的一间会议室。分享他们如何推翻缓慢而昂贵的关系数据库的暴政，怎样使用更
有效和更便宜的方法来管理数据。
关系型数据库给你强加了太多东西。它们要你强行修改对象数据，以满足数据库系统的需要。
在NoSQL 拥护者们来看，基于NoSQL 的数据库替代方案“只是给你所需要的”。
1.1.3 为什么是NoSQL
随着互联网web2.0 网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关

7 / 91
系数据库产品的发展非常迅速，而传统的关系型数据库在应付web2.0 网站，特别是超大规
模和高并发的SNS 类型的web2.0 纯动态网站已经显得力不从心，暴露了很多难以克服的问
题，例如：
1、 High performance - 对数据库高并发读写的需求
web2.0 网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法
使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。
关系型数据库应付上万次SQL 查询还勉强顶得住，但是应付上万次SQL 写数据请求，硬盘
IO 就已经无法承受了，其实对于普通的BBS 网站，往往也存在对高并发写请求的需求。
2、Huge Storage - 对海量数据的高效率存储和访问的需求
对于大型的SNS 网站，每天用户产生海量的用户动态信息，以国外的Friend feed 为例，一
个月就达到了2.5 亿条用户动态，对于关系数据库来说，在一张2.5 亿条记录的表里面进行
SQL 查询，效率是极其低下乃至不可忍受的。再例如大型web 网站的用户登录系统，例如腾
讯，盛大，动辄数以亿计的帐号，关系数据库也很难应付。
3、High Scalability && High Availability - 对数据库的高可扩展性和高可用性的需求
在基于web 的架构当中，数据库是最难进行横向扩展的，当一个应用系统的用户量和访问
量与日俱增的时候，你的数据库却没有办法像web server 和app server 那样简单的通过添加
更多的硬件和服务节点来扩展性能和负载能力。对于很多需要提供24 小时不间断服务的网
站来说，对数据库系统进行升级和扩展是非常痛苦的事情，往往需要停机维护和数据迁移，
可是停机维护随之带来的就是公司收入的减少。
在上面提到的“三高”需求面前，关系数据库遇到了难以克服的障碍，而对于web2.0 网站
来说，关系数据库的很多主要特性却往往无用武之地，例如：
1、数据库事务一致性需求
很多web 实时系统并不要求严格的数据库事务，对读一致性的要求很低，有些场合对写一
致性要求也不高。因此数据库事务管理成了数据库高负载下一个沉重的负担。
2、数据库的写实时性和读实时性需求
对关系数据库来说，插入一条数据之后立刻查询，是肯定可以读出来这条数据的，但是对于
很多web 应用来说，并不要求这么高的实时性。
3、对复杂的SQL查询，特别是多表关联查询的需求
任何大数据量的web 系统，都非常忌讳多个大表的关联查询，以及复杂的数据分析类型的
复杂SQL 报表查询，特别是SNS 类型的网站，从需求以及产品设计角度，就避免了这种情
况的产生。往往更多的只是单表的主键查询，以及单表的简单条件分页查询，SQL 的功能被
极大的弱化了。
因此，关系数据库在这些越来越多的应用场景下显得不那么合适了，为了解决这类问题的
NoSQL 数据库应运而生。
NoSQL 是非关系型数据存储的广义定义。它打破了长久以来关系型数据库与ACID 理论大一
统的局面。NoSQL 数据存储不需要固定的表结构，通常也不存在连接操作。在大数据存取
上具备关系型数据库无法比拟的性能优势，该概念在 2009 年初得到了广泛认同。

8 / 91
当今的应用体系结构需要数据存储在横向伸缩性上能够满足需求。而 NoSQL 存储就是为了
实现这个需求。Google 的BigTable 与Amazon 的Dynamo 是非常成功的商业 NoSQL 实现。
一些开源的 NoSQL 体系，如Facebook 的Cassandra， Apache 的HBase，也得到了广泛认
同。从这些NoSQL 项目的名字上看不出什么相同之处：Hadoop、Voldemort、Dynomite，还
有其它很多，但它们都有一个共同的特点，就是要改变大家对数据库在传统意义上的理解。
1.1.4 NoSQL特点
1、它可以处理超大量的数据
2、它运行在便宜的PC服务器集群上
PC 集群扩充起来非常方便并且成本很低，避免了传统商业数据库“sharding”操作的复杂性
和成本。
3、它击碎了性能瓶颈
NoSQL 的支持者称，通过NoSQL 架构可以省去将Web 或Java 应用和数据转换成SQL 格式的
时间，执行速度变得更快。
“SQL 并非适用于所有的程序代码”，对于那些繁重的重复操作的数据，SQL 值得花钱。但
是当数据库结构非常简单时，SQL 可能没有太大用处。
4、它没有过多的操作
虽然NoSQL 的支持者也承认关系型数据库提供了无可比拟的功能集合，而且在数据完整性
上也发挥绝对稳定，他们同时也表示，企业的具体需求可能没有那么复杂。
5、它的支持者源于社区
因为NoSQL 项目都是开源的，因此它们缺乏供应商提供的正式支持。这一点它们与大多数
开源项目一样，不得不从社区中寻求支持。
NoSQL 发展至今，出现了好几种非关系性数据库，本书就以NoSQL 中目前表现最好的
MongoDB 为例来进行说明。
1.2 初识MongoDB
MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最
丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json 的bjson 格式，因此可
以存储比较复杂的数据类型。MongoDB 最大的特点是他支持的查询语言非常强大，其语法
有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，
而且还支持对数据建立索引。它是一个面向集合的,模式自由的文档型数据库。
1、面向集合（Collenction-Orented）
意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。每个集合在数据库中
都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库

9 / 91
（RDBMS）里的表（table），不同的是它不需要定义任何模式（schema)。
2、模式自由（schema-free)
意味着对于存储在MongoDB 数据库中的文件，我们不需要知道它的任何结构定义。提了这
么多次"无模式"或"模式自由"，它到是个什么概念呢？例如，下面两个记录可以存在于同一
个集合里面：
{"welcome" : "Beijing"}
{"age" : 25}
3、文档型
意思是我们存储的数据是键-值对的集合,键是字符串,值可以是数据类型集合里的任意类型,
包括数组和文档. 我们把这个数据格式称作 “BSON” 即 “Binary Serialized dOcument
Notation.”
下面将分别介绍MongoDB 的特点、功能和适用场合。
1.2.1 特点
面向集合存储，易于存储对象类型的数据
模式自由
支持动态查询
支持完全索引，包含内部对象
支持查询
支持复制和故障恢复
使用高效的二进制数据存储，包括大型对象（如视频等）
自动处理碎片，以支持云计算层次的扩展性
支持Python，PHP，Ruby，Java，C，C#，Javascript，Perl 及C++语言的驱动程序，社区
中也提供了对Erlang 及.NET 等平台的驱动程序
文件存储格式为BSON（一种JSON 的扩展）
可通过网络访问
1.2.2 功能
面向集合的存储：适合存储对象及JSON 形式的数据
动态查询：MongoDB 支持丰富的查询表达式。查询指令使用JSON 形式的标记，可轻易
查询文档中内嵌的对象及数组
完整的索引支持：包括文档内嵌对象及数组。MongoDB 的查询优化器会分析查询表达
式，并生成一个高效的查询计划
查询监视：MongoDB 包含一系列监视工具用于分析数据库操作的性能
复制及自动故障转移：MongoDB 数据库支持服务器之间的数据复制，支持主-从模式及
服务器之间的相互复制。复制的主要目标是提供冗余及自动故障转移
高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）
自动分片以支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额

10 / 91
外的机器
1.2.3 适用场合
网站数据：MongoDB 非常适合实时的插入，更新与查询，并具备网站实时数据存储所
需的复制及高度伸缩性
缓存：由于性能很高，MongoDB 也适合作为信息基础设施的缓存层。在系统重启之后，
由MongoDB 搭建的持久化缓存层可以避免下层的数据源过载
大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在
此之前，很多时候程序员往往会选择传统的文件进行存储
高伸缩性的场景：MongoDB 非常适合由数十或数百台服务器组成的数据库。MongoDB
的路线图中已经包含对MapReduce 引擎的内置支持
用于对象及JSON 数据的存储：MongoDB 的BSON 数据格式非常适合文档化格式的存储
及查询
第二章安装和配置
MongoDB 的官方下载站是http://www.mongodb.org/downloads，可以去上面下载最新的安装
程序下来。在下载页面可以看到，它对操作系统支持很全面，如OS X、Linux、Windows、Solaris
都支持，而且都有各自的32 位和64 位版本。目前的稳定版本是1.8.1 版本。
注意:
1. MongoDB 1.8.1 Linux 版要求glibc 必须是2.5 以上，所以需要先确认操作系统的glibc 的版
本，笔者最初用Linux AS 4 安装不上，最后用的是RHEL5 来安装才成功的。
2. 在32 位平台MongoDB 不允许数据库文件（累计总和）超过2G，而64 位平台没有这个
限制。
怎么安装 MongoDB 数据库呢？下面将分别介绍Windows 和Linux 版本的安装方法

11 / 91
2.1 Windows平台的安装
步骤一: 下载MongoDB
url 下载地址: http://downloads.mongodb.org/win32/mongodb-win32-i386-1.8.1.zip
步骤二: 设置MongoDB程序存放目录
将其解压到 c:\，再重命名为mongo，路径为c:\mongo
步骤三: 设置数据文件存放目录
在c:盘建一个db 文件夹，路径c:\db
步骤四: 启动MongoDB服务
进入 cmd 提示符控制台，c:\mongo\bin\mongod.exe --dbpath=c:\db
C:\mongo\bin>C:\mongo\bin\mongod --dbpath=c:\db
Sun Apr 10 22:34:09 [initandlisten] MongoDB starting : pid=5192 port=27017 dbpat
h=d:\data\db 32-bit
** NOTE: when using MongoDB 32 bit, you are limited to about 2 gigabytes of data
** see http://blog.mongodb.org/post/137788967/32-bit-limitations
** with --dur, the limit is lower
……
Sun Apr 10 22:34:09 [initandlisten] waiting for connections on port 27017
Sun Apr 10 22:34:09 [websvr] web admin interface listening on port 28017
MongoDB 服务端的默认监听端口是 27017
步骤五: 将MongoDB作为 Windows 服务随机启动
先创建C:\mongo\logs\mongodb.log 文件，用于存储MongoDB 的日志文件, 再安装系统
服务。
C:\mongo\bin>C:\mongo\bin\mongod --dbpath=c:\ db --logpath=c:\mongo\lo
gs\mongodb.log --install
all output going to: c:\mongo\logs\mongodb.log
Creating service MongoDB.
Service creation successful.
Service can be started from the command line via 'net start "MongoDB"'.
C:\mongo\bin>net start mongodb
Mongo DB 服务已经启动成功。
C:\mongo\bin>
步骤六: 客户端连接验证
新打开一个CMD 输入：c:\mongo\bin\mongo，如果出现下面提示，那么您就可以开始
MongoDB 之旅了
C:\mongo\bin>c:\mongo\bin\mongo
MongoDB shell version: 1.8.1
connecting to: test
>
步骤七: 查看MongoDB日志
查看C:\mongo\logs\mongodb.log 文件，即可对MongoDB 的运行情况进行查看或排错了，
这样就完成了Windows 平台的MongoDB 安装。

12 / 91
2.2 Linux平台的安装
步骤一: 下载MongoDB
下载安装包：curl -O http://fastdl.mongodb.org/linux/mongodb-linux-i686-1.8.1.tgz
步骤二: 设置MongoDB程序存放目录
将其解压到/Apps，再重命名为mongo，路径为/Apps/mongo
步骤三: 设置数据文件存放目录
建立/data/db 的目录, mkdir –p /data/db
步骤四: 启动MongoDB服务
/Apps/mongo/bin/mongod --dbpath=/data/db
[root@localhost ~]# /Apps/mongo/bin/mongod --dbpath=/data/db
Sun Apr 8 22:41:06 [initandlisten] MongoDB starting : pid=13701 port=27017 dbpath=/data/db
32-bit
** NOTE: when using MongoDB 32 bit, you are limited to about 2 gigabytes of data
** see http://blog.mongodb.org/post/137788967/32-bit-limitations
** with --dur, the limit is lower
……
Sun Apr 8 22:41:06 [initandlisten] waiting for connections on port 27017
Sun Apr 8 22:41:06 [websvr] web admin interface listening on port 28017
MongoDB 服务端的默认连接端口是 27017
步骤五: 将MongoDB作为 Linux 服务随机启动
先创建/Apps/mongo/logs/mongodb.log 文件，用于存储MongoDB 的日志文件
vi /etc/rc.local, 使用vi 编辑器打开配置文件，并在其中加入下面一行代码
/Apps/mongo/bin/mongod --dbpath=/data/db --logpath=/Apps/mongo/logs/mongodb.log
步骤六: 客户端连接验证
新打开一个Session 输入：/Apps/mongo/bin/mongo，如果出现下面提示，那么您就可以
开始MongoDB 之旅了
[root@localhost ~]# /Apps/mongo/bin/mongo
MongoDB shell version: 1.8.1
connecting to: test
>
步骤七: 查看MongoDB日志
查看/Apps/mongo/logs/mongodb.log 文件，即可对MongoDB 的运行状况进行查看或分
析了
[root@localhost logs]# ll
总计 0
-rw-r--r-- 1 root root 0 04-08 20:15 mongodb.log
[root@localhost logs]#
以上的几个步骤就OK 了！！这样一个简单的MongoDB 数据库就可以畅通无阻地运行起
来了。

13 / 91
第三章体系结构
MongoDB 是一个可移植的数据库，它在流行的每一个平台上都可以使用，即所谓的跨平台
特性。在不同的操作系统上虽然略有差别，但是从整体构架上来看，MongoDB 在不同的平
台上是一样的，如数据逻辑结构和数据的存储等等。
一个运行着的MongoDB 数据库就可以看成是一个MongoDB Server，该Server 由实例和数据
库组成，在一般的情况下一个MongoDB Server 机器上包含一个实例和多个与之对应的数据
库，但是在特殊情况下，如硬件投入成本有限或特殊的应用需求，也允许一个Server 机器
上可以有多个实例和多个数据库。
MongoDB 中一系列物理文件（数据文件，日志文件等）的集合或与之对应的逻辑结构（集
合，文档等）被称为数据库，简单的说，就是数据库是由一系列与磁盘有关系的物理文件的
组成。
3.1 数据逻辑结构
很多人在学习MongoDB 体系结构的时候会遇到各种各样的问题，我在这里给大家简单的介
绍一下MongoDB 体系结构之－的逻辑结构。MongoDB 的逻辑结构是一种层次结构。主要由：
文档(document)、集合(collection)、数据库(database)这三部分组成的。逻辑结构是面向用户
的，用户使用MongoDB 开发应用程序使用的就是逻辑结构。
MongoDB 的文档（document），相当于关系数据库中的一行记录。
多个文档组成一个集合（collection），相当于关系数据库的表。
多个集合（collection），逻辑上组织在一起，就是数据库（database）。
一个MongoDB 实例支持多个数据库（database）。
文档(document)、集合(collection)、数据库(database)的层次结构如下图:

14 / 91
对于习惯了关系型数据库的朋友们，我将MongoDB 与关系型数据库的逻辑结构进行了对比，
以便让大家更深刻的理解MongoDB 的逻辑结构
逻辑结构对比
MongoDB 关系型数据库
文档(document) 行(row)
集合(collection) 表(table)
数据库(database) 数据库(database)
3.2 数据存储结构
MongoDB 对国内用户来说比较新, 它就像是一个黑盒子，但是如果对于它内部的数据存储
了解多一些的话，那么将会很快的理解和驾驭MongoDB，让它发挥它更大的作用。
MongoDB 的默认数据目录是/data/db，它负责存储所有的MongoDB 的数据文件。在MongoDB
内部，每个数据库都包含一个.ns 文件和一些数据文件，而且这些数据文件会随着数据量的
增加而变得越来越多。所以如果系统中有一个叫做foo 的数据库，那么构成foo 这个数据库
的文件就会由foo.ns，foo.0，foo.1，foo.2 等等组成，具体如下:

15 / 91
[root@localhost db]# ll /data/db/
总计 196844
-rw------- 1 root root 16777216 04-15 16:33 admin.0
-rw------- 1 root root 33554432 04-15 16:33 admin.1
-rw------- 1 root root 16777216 04-15 16:33 admin.ns
-rw------- 1 root root 16777216 04-21 17:30 foo.0
-rw------- 1 root root 33554432 04-21 17:30 foo.1
-rw------- 1 root root 67108864 04-21 17:30 foo.2
-rw------- 1 root root 16777216 04-21 17:30 foo.ns
-rwxr-xr-x 1 root root 6 04-21 17:16 mongod.lock
-rw------- 1 root root 16777216 04-15 16:30 test.0
-rw------- 1 root root 33554432 04-15 16:30 test.1
-rw------- 1 root root 16777216 04-15 16:30 test.ns
drwxr-xr-x 2 root root 4096 04-21 17:30 _tmp
MongoDB 内部有预分配空间的机制，每个预分配的文件都用0 进行填充，由于有了这个机
制, MongoDB 始终保持额外的空间和空余的数据文件，从而有效避免了由于数据暴增而带来
的磁盘压力过大的问题。
由于表中数据量的增加，数据文件每新分配一次，它的大小都会是上一个数据文件大小的2
倍，每个数据文件最大2G。这样的机制有利于防止较小的数据库浪费过多的磁盘空间，同
时又能保证较大的数据库有相应的预留空间使用。
数据库的每张表都对应一个命名空间，每个索引也有对应的命名空间。这些命名空间的元数
据都集中在*.ns 文件中。
在下图中，foo 这个数据库包含3 个文件用于存储表和索引数据，foo.2 文件属于预分配的空
文件。foo.0 和foo.1 这两个数据文件被分为了相应的盘区对应不同的名字空间。

16 / 91
上图显示了命名空间和盘区的关系。每个命名空间可以包含多个不同的盘区，这些盘区并不
是连续的。与数据文件的增长相同，每一个命名空间对应的盘区大小的也是随着分配的次数
不断增长的。这样做的目的是为了平衡命名空间浪费的空间与保持某一个命名空间中数据的
连续性。上图中还有一个需要注意的命名空间：$freelist，这个命名空间用于记录不再使用
的盘区（被删除的Collection 或索引）。每当命名空间需要分配新的盘区的时候，都会先查
看$freelist 是否有大小合适的盘区可以使用，这样就回收空闲的磁盘空间。
第四章快速入门
MongoDB Shell 是MongoDB 自带的交互式Javascript shell，用来对MongoDB 进行操作和管理
的交互式环境。
使用 "./mongo --help" 可查看相关连接参数，下面将从常见的操作，如插入，查询，修改，
删除等几个方面阐述MongoDB shell 的用法。
4.1 启动数据库
MongoDB 安装、配置完后，必须先启动它，然后才能使用它。怎么启动它呢？下面分别展
示了3 种方式来启动实例。
4.1.1 命令行方式启动
MongoDB 默认存储数据目录为/data/db/ (或者 c:\data\db), 默认端口27017，默认HTTP 端

17 / 91
口28017。当然你也可以修改成不同目录,只需要指定dbpath 参数: /Apps/mongo/bin/mongod
--dbpath=/data/db
[root@localhost ~]# /Apps/mongo/bin/mongod --dbpath=/data/db
Sun Apr 8 22:41:06 [initandlisten] MongoDB starting : pid=13701 port=27017 dbpath=/data/db
32-bit
……
Sun Apr 8 22:41:06 [initandlisten] waiting for connections on port 27017
Sun Apr 8 22:41:06 [websvr] web admin interface listening on port 28017
4.1.2 配置文件方式启动
如果是一个专业的DBA，那么实例启动时会加很多的参数以便使系统运行的非常稳定，这样
就可能会在启动时在mongod 后面加一长串的参数，看起来非常混乱而且不好管理和维护，
那么有什么办法让这些参数有条理呢？MongoDB 也支持同mysql 一样的读取启动配置文件
的方式来启动数据库，配置文件的内容如下:
[root@localhost bin]# cat /etc/mongodb.cnf
dbpath=/data/db/
启动时加上”-f”参数，并指向配置文件即可
[root@localhost bin]# ./mongod -f /etc/mongodb.cnf
Mon May 28 18:27:18 [initandlisten] MongoDB starting : pid=18481 port=27017
dbpath=/data/db/ 32-bit
……
Mon May 28 18:27:18 [initandlisten] waiting for connections on port 27017
Mon May 28 18:27:18 [websvr] web admin interface listening on port 28017
4.1.3 Daemon方式启动
大家可以注意到上面的两种方式都慢在前台启动MongoDB 进程，但当启动MongoDB 进程
的session 窗口不小心关闭时，MongoDB 进程也将随之停止，这无疑是非常不安全的，幸好
MongoDB 提供了一种后台Daemon 方式启动的选择，只需加上一个”--fork”参数即可，这
就使我们可以更方便的操作数据库的启动，但如果用到了”--fork”参数就必须也启用”
--logpath”参数，这是强制的
[root@localhost ~]# /Apps/mongo/bin/mongod --dbpath=/data/db --fork
--fork has to be used with --logpath
[root@localhost ~]# /Apps/mongo/bin/mongod --dbpath=/data/db --logpath=/data/log/r3.log
--fork
all output going to: /data/log/r3.log
forked process: 19528
[root@localhost ~]#

18 / 91
4.1.4 mongod参数说明
最简单的，通过执行mongod 即可以启动MongoDB 数据库服务，mongod 支持很多的参数，
但都有默认值，其中最重要的是需要指定数据文件路径，或者确保默认的/data/db 存在并且
有访问权限，否则启动后会自动关闭服务。Ok，那也就是说，只要确保dbpath 就可以启动
MongoDB 服务了
mongod 的主要参数有：
dbpath:
数据文件存放路径，每个数据库会在其中创建一个子目录，用于防止同一个实例多次运
行的mongod.lock 也保存在此目录中。
logpath
错误日志文件
logappend
错误日志采用追加模式（默认是覆写模式）
bind_ip
对外服务的绑定ip，一般设置为空，及绑定在本机所有可用ip 上，如有需要可以单独
指定
port
对外服务端口。Web 管理端口在这个port 的基础上+1000
fork
以后台Daemon 形式运行服务
journal
开启日志功能，通过保存操作日志来降低单机故障的恢复时间，在1.8 版本后正式加入，
取代在1.7.5 版本中的dur 参数。
syncdelay
系统同步刷新磁盘的时间，单位为秒，默认是60 秒。
directoryperdb
每个db 存放在单独的目录中，建议设置该参数。与MySQL 的独立表空间类似
maxConns
最大连接数
repairpath
执行repair 时的临时目录。在如果没有开启journal，异常down 机后重启，必须执行repair
操作。
在源代码中，mongod 的参数分为一般参数，windows 参数，replication 参数，replica set 参
数，以及隐含参数。上面列举的都是一般参数。如果要配置replication，replica set 等，还需
要设置对应的参数，这里先不展开，后续会有专门的章节来讲述。执行mongod --help 可以
看到对大多数参数的解释，但有一些隐含参数，则只能通过看代码来获得(见db.cpp
po::options_description hidden_options(“Hidden options”);)，隐含参数一般要么是还在开发
中，要么是准备废弃，因此在生产环境中不建议使用。
可能你已经注意到，mongod 的参数中，没有设置内存大小相关的参数，是的，MongoDB 使

19 / 91
用os mmap 机制来缓存数据文件数据，自身目前不提供缓存机制。这样好处是代码简单，
mmap 在数据量不超过内存时效率很高。但是数据量超过系统可用内存后，则写入的性能可
能不太稳定，容易出现大起大落，不过在最新的1.8 版本中，这个情况相对以前的版本已经
有了一定程度的改善。
这么多参数，全面写在命令行中则容易杂乱而不好管理。因此，mongod 支持将参数写入到
一个配置文本文件中，然后通过config 参数来引用此配置文件：
./mongod --config /etc/mongo.cnf
4.2 停止数据库
MongoDB 提供的停止数据库命令也非常丰富，如果Control-C、发送shutdownServer()指令及
发送Unix 系统中断信号等
4.2.1 Control-C
如果处理连接状态，那么直接可以通过Control-C 的方式去停止MongoDB 实例，具体如下:
[root@localhost ~]# /Apps/mongo/bin/mongo --port 28013
MongoDB shell version: 1.8.1
connecting to: 127.0.0.1:28013/test
> use test
switched to db test
> ^C[root@localhost ~]#
4.2.2 shutdownServer()指令
如果处理连接状态，那么直接可以通过在admin 库中发送db.shutdownServer()指令去停止
MongoDB 实例，具体如下:
[root@localhost ~]# /Apps/mongo/bin/mongo --port 28013
MongoDB shell version: 1.8.1
connecting to: 127.0.0.1:28013/test
> use admin
switched to db admin
> db.shutdownServer()
Thu May 31 23:22:00 DBClientCursor::init call() failed
Thu May 31 23:22:00 query failed : admin.$cmd { shutdown: 1.0 } to: 127.0.0.1:28013
server should be down...
Thu May 31 23:22:00 trying reconnect to 127.0.0.1:28013
Thu May 31 23:22:00 reconnect 127.0.0.1:28013 failed couldn't connect to server
127.0.0.1:28013
Thu May 31 23:22:00 Error: error doing query: unknown shell/collection.js:150
>

20 / 91
4.2.3 Unix系统指令
在找到实例的进程后，可能通过发送kill -2 PID 或kill -15 PID 来停止进程
[root@localhost ~]# ps aux|grep mongod
root 19269 0.3 1.3 76008 3108 Sl 23:24 0:00 /Apps/mongo/bin/mongod --fork
--port 28013
[root@localhost ~]# kill -2 19269
注意:
不要用kill -9 PID 来杀死MongoDB 进程，这样可以会导致MongoDB 的数据损坏
4.3 连接数据库
现在我们就可以使用自带的MongoDB shell 工具来操作数据库了. (我们也可以使用各种编程
语言的驱动来使用MongoDB, 但自带的MongoDB shell 工具可以方便我们管理数据库)。
新打开一个Session 输入：/Apps/mongo/bin/mongo，如果出现下面提示，那么您就说明连接
上数据库了，可以进行操作了
[root@localhost ~]# /Apps/mongo/bin/mongo
MongoDB shell version: 1.8.1
connecting to: test
>
默认 shell 连接的是本机localhost 上面的 test 库，"connecting to:" 这个会显示你正在使用
的数据库的名称. 想换数据库的话可以用”use mydb”来实现。
4.4 插入记录
下面我们来建立一个test 的集合并写入一些数据. 建立两个对象j 和t , 并保存到集合中去.
在例子里 “>” 来表示是 shell 输入提示符
> j = { name : "mongo" };
{"name" : "mongo"}
> t = { x : 3 };
{ "x" : 3 }
> db.things.save(j);
> db.things.save(t);
> db.things.find();
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
{ "_id" : ObjectId("4c2209fef3924d31102bd84b"), "x" : 3 }
>
有几点需要注意一下:
不需要预先创建一个集合. 在第一次插入数据时候会自动创建.

21 / 91
在文档中其实可以存储任何结构的数据, 当然在实际应用我们存储的还是相同类型文
档的集合. 这个特性其实可以在应用里很灵活, 你不需要类似alter table 语句来修改你
的数据结构
每次插入数据时候集合中都会有一个ID, 名字叫 _id.
下面再加点数据:
> for( var i = 1; i < 10; i++ ) db.things.save( { x:4, j:i } ); > db.things.find();
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}
请注意一下, 这里循环次数是10, 但是只显示到第8 条, 还有2 条数据没有显示. 如果想继
续查询下面的数据只需要使用”it”命令, 就会继续显示下面的数据:
{ "_id" : ObjectId("4c220a42f3924d31102bd866"), "x" : 4, "j" : 17 }
{ "_id" : ObjectId("4c220a42f3924d31102bd867"), "x" : 4, "j" : 18 }
has more
> it
{ "_id" : ObjectId("4c220a42f3924d31102bd868"), "x" : 4, "j" : 19 }
{ "_id" : ObjectId("4c220a42f3924d31102bd869"), "x" : 4, "j" : 20 }
从技术上讲 find() 返回一个游标对象. 但在上面的例子里, 并没有拿到一个游标的变量. 所
以 shell 自动遍历游标, 返回一个初始化的set, 并允许我们继续用 it 迭代输出.
当然我们也可以直接用游标来输出, 不过这个是”游标”部分的内容了.
4.5 _id key
MongoDB 支持的数据类型中，_id 是其自有产物，下面对其做些简单的介绍。
存储在MongoDB 集合中的每个文档（document）都有一个默认的主键_id，这个主键名称是
固定的，它可以是MongoDB 支持的任何数据类型，默认是ObjectId。在关系数据库schema
设计中，主键大多是数值型的，比如常用的int 和long，并且更通常的是主键的取值由数据
库自增获得，这种主键数值的有序性有时也表明了某种逻辑。反观MongoDB，它在设计之
初就定位于分布式存储系统，所以它原生的不支持自增主键。
_id key 举例说明 :
当我们在往一个集合中写入一条文档时，系统会自动生成一个名为_id 的key.如：
> db.c1.find()
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }

22 / 91
这里多出了一个类型为ObjectId 的key ,在插入时并没有指定，这有点类似Oracle 的rowid
的信息，属于自动生成的。
在MongoDB 中，每一个集合都必须有一个叫做_id 的字段,字段类型默认是ObjectId ,换句话
说，字段类型可以不是ObjectId,例如:
> db.c1.find()
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
{ "_id" : 3, "name" : "Bill", "age" : 55 }
虽然_id 的类型可以自由指定,但是在同一个集合中必须唯一，如果插入重复的值的话，系统
将会抛出异常，具体如下:
> db.c1.insert({_id:3, name:"Bill_new", age:55})
E11000 duplicate key error index: test.c1.$_id_ dup key: { : 3.0 }
>
因为前面已经插入了一条_id=3 的记录，所以再插入相同的文档就不允许了。
4.6 查询记录
4.6.1 普通查询
在没有深入查询之前, 我们先看看怎么从一个查询中返回一个游标对象. 可以简单的通过
find() 来查询, 他返回一个任意结构的集合. 如果实现特定的查询稍后讲解.
实现上面同样的查询, 然后通过 while 来输出:
> var cursor = db.things.find();
> while (cursor.hasNext()) printjson(cursor.next());
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
{ "_id" : ObjectId("4c2209fef3924d31102bd84b"), "x" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd856"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4c220a42f3924d31102bd857"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4c220a42f3924d31102bd858"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd859"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4c220a42f3924d31102bd85a"), "x" : 4, "j" : 5 }
上面的例子显示了游标风格的迭代输出. hasNext() 函数告诉我们是否还有数据, 如果有则
可以调用 next() 函数.
当我们使用的是 JavaScript shell, 可以用到JS 的特性, forEach 就可以输出游标了. 下面的例
子就是使用 forEach() 来循环输出: forEach() 必须定义一个函数供每个游标元素调用.
> db.things.find().forEach(printjson);
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
{ "_id" : ObjectId("4c2209fef3924d31102bd84b"), "x" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd856"), "x" : 4, "j" : 1 }

23 / 91
{ "_id" : ObjectId("4c220a42f3924d31102bd857"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4c220a42f3924d31102bd858"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd859"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4c220a42f3924d31102bd85a"), "x" : 4, "j" : 5 }
在 MongoDB shell 里, 我们也可以把游标当作数组来用:
> var cursor = db.things.find();
> printjson(cursor[4]);
{ "_id" : ObjectId("4c220a42f3924d31102bd858"), "x" : 4, "j" : 3 }
使用游标时候请注意占用内存的问题, 特别是很大的游标对象, 有可能会内存溢出. 所以应
该用迭代的方式来输出. 下面的示例则是把游标转换成真实的数组类型:
> var arr = db.things.find().toArray();
> arr[5];
{ "_id" : ObjectId("4c220a42f3924d31102bd859"), "x" : 4, "j" : 4 }
请注意这些特性只是在MongoDB shell 里使用, 而不是所有的其他应用程序驱动都支持.
MongoDB 游标对象不是没有快照，如果有其他用户在集合里第一次或者最后一次调用
next(), 你可能得不到游标里的数据. 所以要明确的锁定你要查询的游标.
4.6.2 条件查询
到这里我们已经知道怎么从游标里实现一个查询并返回数据对象, 下面就来看看怎么根据
指定的条件来查询.
下面的示例就是说明如何执行一个类似SQL 的查询, 并演示了怎么在 MongoDB 里实现. 这
是在MongoDB shell 里查询, 当然你也可以用其他的应用程序驱动或者语言来实现:
SELECT * FROM things WHERE name="mongo"
> db.things.find({name:"mongo"}).forEach(printjson);
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
SELECT * FROM things WHERE x=4
> db.things.find({x:4}).forEach(printjson);
{ "_id" : ObjectId("4c220a42f3924d31102bd856"), "x" : 4, "j" : 1 }
{ "_id" : ObjectId("4c220a42f3924d31102bd857"), "x" : 4, "j" : 2 }
{ "_id" : ObjectId("4c220a42f3924d31102bd858"), "x" : 4, "j" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd859"), "x" : 4, "j" : 4 }
{ "_id" : ObjectId("4c220a42f3924d31102bd85a"), "x" : 4, "j" : 5 }
查询条件是 { a:A, b:B, … } 类似 “where a==A and b==B and …”.
上面显示的是所有的元素, 当然我们也可以返回特定的元素, 类似于返回表里某字段的值,
只需要在 find({x:4}) 里指定元素的名字
SELECT j FROM things WHERE x=4
> db.things.find({x:4}, {j:true}).forEach(printjson);

24 / 91
{ "_id" : ObjectId("4c220a42f3924d31102bd856"), "j" : 1 }
{ "_id" : ObjectId("4c220a42f3924d31102bd857"), "j" : 2 }
{ "_id" : ObjectId("4c220a42f3924d31102bd858"), "j" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd859"), "j" : 4 }
{ "_id" : ObjectId("4c220a42f3924d31102bd85a"), "j" : 5 }
4.6.3 findOne()语法
为了方便考虑, MongoDB shell 避免游标可能带来的开销, 提供一个findOne() 函数. 这个函
数和 find() 函数一样, 不过它返回的是游标里第一条数据, 或者返回null，即空数据.
作为一个例子, name=”mongo” 可以用很多方法来实现, 可以用 next() 来循环游标或者当
做数组返回第一个元素.
但是用 findOne() 方法则更简单和高效:
> printjson(db.things.findOne({name:"mongo"}));
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
4.6.4 通过limit限制结果集数量
如果需要限制结果集的长度, 那么可以调用 limit 方法.
这是强烈推荐解决性能问题的方法, 就是通过限制条数来减少网络传输, 例如:
> db.things.find().limit(3);
{ "_id" : ObjectId("4c2209f9f3924d31102bd84a"), "name" : "mongo" }
{ "_id" : ObjectId("4c2209fef3924d31102bd84b"), "x" : 3 }
{ "_id" : ObjectId("4c220a42f3924d31102bd856"), "x" : 4, "j" : 1 }
4.7 修改记录
将name 是mongo 的记录的name 修改为mongo_new
> db.things.update({name:"mongo"},{$set:{name:"mongo_new"}});
我们来查询一下是否改过来了
> db.things.find();
{ "_id" : ObjectId("4faa9e7dedd27e6d86d86371"), "x" : 3 }
{ "_id" : ObjectId("4faa9e7bedd27e6d86d86370"), "name" : "mongo_new" }
4.8 删除记录
将用户name 是mongo_new 的记录从集合things 中删除

25 / 91
> db.things.remove({name:"mongo_new"});
> db.things.find();
{ "_id" : ObjectId("4faa9e7dedd27e6d86d86371"), "x" : 3 }
经验证，该记录确实被删除了
4.9常用工具集
MongoDB 在bin 目录下提供了一系列有用的工具，这些工具提供了MongoDB 在运维管理上
的方便。
bsondump: 将bson 格式的文件转储为json 格式的数据
mongo: 客户端命令行工具，其实也是一个js 解释器，支持js 语法
mongod: 数据库服务端，每个实例启动一个进程，可以fork 为后台运行
mongodump/ mongorestore: 数据库备份和恢复工具
mongoexport/ mongoimport: 数据导出和导入工具
mongofiles: GridFS 管理工具，可实现二制文件的存取
mongos: 分片路由，如果使用了sharding 功能，则应用程序连接的是mongos 而不是
mongod
mongosniff: 这一工具的作用类似于tcpdump，不同的是他只监控MongoDB 相关的包请
求，并且是以指定的可读性的形式输出
mongostat: 实时性能监控工具
4.10 客户端GUI 工具
看一个产品是否得到认可,可以从一个侧面看其第三方工具的数量和成熟程度,下面我们就来
细数一下MongoDB 常用的GUI 管理工具。
4.10.1 MongoVUE
主页：http://www.mongovue.com/
一个桌面程序，提供了对MongoDB 数据库的基本操作，如查看、查询、更新、删除等，简
单易用，但是功能还比较弱，以后发展应该不错。

26 / 91
4.10.2 RockMongo
主页：http://code.google.com/p/rock-php/
RockMongo 是一个PHP5 写的MongoDB 管理工具。
主要特征:
使用宽松的New BSD License 协议
速度快，安装简单
支持多语言（目前提供中文、英文、日文、巴西葡萄牙语、法语、德语）
系统可以配置多个主机，每个主机可以有多个管理员，需要管理员密码才能登入操作，确保
数据库的安全性

27 / 91
服务器信息 (WEB 服务器, PHP, PHP.ini 相关指令 ...)状态
数据查询，创建和删除
执行命令和Javascript 代码
4.10.3 MongoHub
主页：https://github.com/bububa/MongoHub
MongoHub 是一个针对Mac 平台的MongoDB 图形管理客户端，可用来管理MongoDB 数据
的应用程序。
第二部分应用篇
本章将结合实际应用，重点阐述一些实际工作中最常用的方法。
第五章高级查询
面向文档的NoSQL 数据库主要解决的问题不是高性能的并发读写，而是保证海量数据存储
的同时，具有良好的查询性能。
MongoDB 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语
言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

28 / 91
最后由于MongoDB 可以支持复杂的数据结构，而且带有强大的数据查询功能，因此非常受
到欢迎，很多项目都考虑用MongoDB 来替代MySQL 等传统数据库来实现不是特别复杂的
Web 应用。由于数据量实在太大，所以迁移到了MongoDB 上面，数据查询的速度得到了非
常显著的提升。
下面将介绍一些高级查询语法:
5.1 条件操作符
5.1 条件操作符
<, <=, >, >= 这个操作符就不用多解释了，最常用也是最简单的
db.collection.find({ "field" : { $gt: value } } ); // 大于: field > value
db.collection.find({ "field" : { $lt: value } } ); // 小于: field < value
db.collection.find({ "field" : { $gte: value } } ); // 大于等于: field >= value
db.collection.find({ "field" : { $lte: value } } ); // 小于等于: field <= value
如果要同时满足多个条件，可以这样做
db.collection.find({ "field" : { $gt: value1, $lt: value2 } } ); // value1 < field < value
5.2 $all匹配所有
这个操作符跟SQL 语法的in 类似，但不同的是, in 只需满足( )内的某一个值即可, 而$all 必
须满足[ ]内的所有值，例如:
db.users.find({age : {$all : [6, 8]}});
可以查询出 {name: 'David', age: 26, age: [ 6, 8, 9 ] }
但查询不出 {name: 'David', age: 26, age: [ 6, 7, 9 ] }
5.3 $exists判断字段是否存在
查询所有存在age 字段的记录
db.users.find({age: {$exists: true}});
查询所有不存在name 字段的记录
db.users.find({name: {$exists: false}});
举例如下:
C1 表的数据如下:
> db.c1.find();
{ "_id" : ObjectId("4fb4a773afa87dc1bed9432d"), "age" : 20, "length" : 30 }
{ "_id" : ObjectId("4fb4a7e1afa87dc1bed9432e"), "age_1" : 20, "length_1" : 30 }

29 / 91
查询存在字段age 的数据
> db.c1.find({age:{$exists:true}});
{ "_id" : ObjectId("4fb4a773afa87dc1bed9432d"), "age" : 20, "length" : 30 }
可以看出只显示出了有age 字段的数据，age_1 的数据并没有显示出来
5.4 Null值处理
Null 值的处理稍微有一点奇怪，具体看下面的样例数据：
> db.c2.find()
{ "_id" : ObjectId("4fc34bb81d8a39f01cc17ef4"), "name" : "Lily", "age" : null }
{ "_id" : ObjectId("4fc34be01d8a39f01cc17ef5"), "name" : "Jacky", "age" : 23 }
{ "_id" : ObjectId("4fc34c1e1d8a39f01cc17ef6"), "name" : "Tom", "addr" : 23 }
其中”Lily”的age 字段为空，Tom 没有age 字段，我们想找到age 为空的行，具体如下：
> db.c2.find({age:null})
{ "_id" : ObjectId("4fc34bb81d8a39f01cc17ef4"), "name" : "Lily", "age" : null }
{ "_id" : ObjectId("4fc34c1e1d8a39f01cc17ef6"), "name" : "Tom", "addr" : 23 }
奇怪的是我们以为只能找到”Lily”，但”Tom”也被找出来了，所以”null”不仅能找到它自身，
连不存在age 字段的记录也找出来了。那么怎么样才能只找到”Lily”呢?我们用exists 来限制
一下即可:
> db.c2.find({age:{"$in":[null], "$exists":true}})
{ "_id" : ObjectId("4fc34bb81d8a39f01cc17ef4"), "name" : "Lily", "age" : null }
这样如我们期望一样，只有”Lily”被找出来了。
5.5 $mod取模运算
查询age 取模10 等于0 的数据
db.student.find( { age: { $mod : [ 10 , 1 ] } } )
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
查询age 取模6 等于1 的数据
> db.c1.find({age: {$mod : [ 6 , 1 ] } })
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
可以看出只显示出了age 取模6 等于1 的数据，其它不符合规则的数据并没有显示出来

30 / 91
5.6 $ne不等于
查询x 的值不等于3 的数据
db.things.find( { x : { $ne : 3 } } );
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
查询age 的值不等于7 的数据
> db.c1.find( { age : { $ne : 7 } } );
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
可以看出只显示出了age 等于7 的数据，其它不符合规则的数据并没有显示出来
5.7 $in包含
与sql 标准语法的用途是一样的，即要查询的是一系列枚举值的范围内
查询x 的值在2,4,6 范围内的数据
db.things.find({x:{$in: [2,4,6]}});
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
查询age 的值在7,8 范围内的数据
> db.c1.find({age:{$in: [7,8]}});
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
可以看出只显示出了age 等于7 或8 的数据，其它不符合规则的数据并没有显示出来
5.8 $nin不包含
与sql 标准语法的用途是一样的，即要查询的数据在一系列枚举值的范围外
查询x 的值在2,4,6 范围外的数据
db.things.find({x:{$nin: [2,4,6]}});
举例如下:

31 / 91
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
查询age 的值在7,8 范围外的数据
> db.c1.find({age:{$nin: [7,8]}});
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
可以看出只显示出了age 不等于7 或8 的数据，其它不符合规则的数据并没有显示出来
5.9 $size数组元素个数
对于{name: 'David', age: 26, favorite_number: [ 6, 7, 9 ] }记录
匹配db.users.find({favorite_number: {$size: 3}});
不匹配db.users.find({favorite_number: {$size: 2}});
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb4af85afa87dc1bed94330"), "age" : 7, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af89afa87dc1bed94331"), "age" : 8, "length_1" : 30 }
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
查询age 的值在7,8 范围外的数据
> db.c1.find({age:{$nin: [7,8]}});
{ "_id" : ObjectId("4fb4af8cafa87dc1bed94332"), "age" : 6, "length_1" : 30 }
可以看出只显示出了age 不等于7 或8 的数据，其它不符合规则的数据并没有显示出来
5.10 正则表达式匹配
查询不匹配name=B*带头的记录
db.users.find({name: {$not: /^B.*/}});
举例如下:
C1 表的数据如下:
> db.c1.find();
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
查询name 不以T 开头的数据
> db.c1.find({name: {$not: /^T.*/}});
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
可以看出只显示出了name=Tony 的数据，其它不符合规则的数据并没有显示出来

32 / 91
5.11 Javascript查询和$where查询
查询a 大于3 的数据，下面的查询方法殊途同归
db.c1.find( { a : { $gt: 3 } } );
db.c1.find( { $where: "this.a > 3" } );
db.c1.find("this.a > 3");
f = function() { return this.a > 3; } db.c1.find(f);
5.12 count查询记录条数
count 查询记录条数
db.users.find().count();
以下返回的不是5，而是user 表中所有的记录数量
db.users.find().skip(10).limit(5).count();
如果要返回限制之后的记录数量，要使用count(true)或者count(非0)
db.users.find().skip(10).limit(5).count(true);
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
查询c1 表的数据量
> db.c1.count()
2
可以看出表中共有2 条数据
5.13 skip限制返回记录的起点
从第3 条记录开始，返回5 条记录(limit 3, 5)
db.users.find().skip(3).limit(5);
举例如下:
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
查询c1 表的第2 条数据
> db.c1.find().skip(1).limit(1)
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
可以看出表中第2 条数据被显示了出来

33 / 91
5.14 sort排序
以年龄升序asc
db.users.find().sort({age: 1});
以年龄降序desc
db.users.find().sort({age: -1});
C1 表的数据如下:
> db.c1.find()
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
查询c1 表按age 升序排列
> db.c1.find().sort({age: 1});
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
第1 条是age=10 的，而后升序排列结果集
查询c1 表按age 降序排列
> db.c1.find().sort({age: -1});
{ "_id" : ObjectId("4fb5faaf6d0f9d8ea3fc91a8"), "name" : "Tony", "age" : 20 }
{ "_id" : ObjectId("4fb5fab96d0f9d8ea3fc91a9"), "name" : "Joe", "age" : 10 }
第1 条是age=20 的，而后降序排列结果集
5.2 游标
象大多数数据库产品一样，MongoDB 也是用游标来循环处理每一条结果数据，具体语法如
下：
> for( var c = db.t3.find(); c.hasNext(); ) {
... printjson( c.next());
... }
{ "_id" : ObjectId("4fb8e4838b2cb86417c9423a"), "age" : 1 }
{ "_id" : ObjectId("4fb8e4878b2cb86417c9423b"), "age" : 2 }
{ "_id" : ObjectId("4fb8e4898b2cb86417c9423c"), "age" : 3 }
{ "_id" : ObjectId("4fb8e48c8b2cb86417c9423d"), "age" : 4 }
{ "_id" : ObjectId("4fb8e48e8b2cb86417c9423e"), "age" : 5 }
MongoDB 还有另一种方式来处理游标
> db.t3.find().forEach( function(u) { printjson(u); } );
{ "_id" : ObjectId("4fb8e4838b2cb86417c9423a"), "age" : 1 }
{ "_id" : ObjectId("4fb8e4878b2cb86417c9423b"), "age" : 2 }
{ "_id" : ObjectId("4fb8e4898b2cb86417c9423c"), "age" : 3 }
{ "_id" : ObjectId("4fb8e48c8b2cb86417c9423d"), "age" : 4 }

34 / 91
{ "_id" : ObjectId("4fb8e48e8b2cb86417c9423e"), "age" : 5 }
>
5.3 存储过程
MongoDB 为很多问题提供了一系列的解决方案，针对于其它数据库的特性，它仍然毫不示
弱，表现的非比寻常。
MongoDB 同样支持存储过程。关于存储过程你需要知道的第一件事就是它是用javascript 来
写的。也许这会让你很奇怪，为什么它用javascript 来写，但实际上它会让你非常满意，
MongoDB 存储过程是存储在db.system.js 表中的，我们想象一个简单的sql 自定义函数如下：
function addNumbers( x , y ) {
return x + y;
}
下面我们将这个sql 自定义函数转换为MongoDB 的存储过程:
> db.system.js.save({_id:"addNumbers", value:function(x, y){ return x + y; }});
存储过程可以被查看，修改和删除，所以我们用find 来查看一下是否这个存储过程已经被
创建上了。
> db.system.js.find()
{ "_id" : "addNumbers", "value" : function cf__1__f_(x, y) {
return x + y;
} }
>
这样看起来还不错，下面我看来实际调用一下这个存储过程:
> db.eval('addNumbers(3, 4.2)');
7.2
>
这样的操作方法简直太简单了，也许这就是MongoDB 的魅力所在。
db.eval()是一个比较奇怪的东西，我们可以将存储过程的逻辑直接在里面并同时调用，而无
需事先声明存储过程的逻辑。
> db.eval( function() { return 3+3; } );
6
>
从上面可以看出，MongoDB 的存储过程可以方便的完成算术运算，但其它数据库产品在存
储过程中可以处理数据库内部的一些事情，例如取出某张表的数据量等等操作，这些
MongoDB 能做到吗？答案是肯定的，MongoDB 可以轻而易举的做到，看下面的实例吧:
> db.system.js.save({_id:"get_count", value:function(){ return db.c1.count(); }});
> db.eval('get_count()')
2

35 / 91
可以看到存储过程可以很轻松的在存储过程中操作表
第六章 Capped Collection
6.1 简单介绍
capped collections 是性能出色的有着固定大小的集合，以LRU(Least Recently Used 最近最少
使用)规则和插入顺序进行age-out(老化移出)处理，自动维护集合中对象的插入顺序，在创
建时要预先指定大小。如果空间用完，新添加的对象将会取代集合中最旧的对象。
6.2 功能特点
可以插入及更新，但更新不能超出collection 的大小，否则更新失败。不允许删除，但是可
以调用drop() 删除集合中的所有行，但是drop 后需要显式地重建集合。在32 位机上，一
个capped collection 的最大值约为482.5M，64 位上只受系统文件大小的限制。
6.3 常见用处
1、 logging
MongoDB 中日志机制的首选，MongoDB 没有使用日志文件，而是把日志事件存储在数
据库中。在一个没有索引的capped collection 中插入对象的速度与在文件系统中记录日
志的速度相当。
2、 cache
缓存一些对象在数据库中，比如计算出来的统计信息。这样的需要在collection 上建立
一个索引，因为使用缓存往往是读比写多。
3、 auto archiving
可以利用capped collection 的age-out 特性，省去了写cron 脚本进行人工归档的工作。
6.4 推荐用法
1、为了发挥capped collection 的最大性能，如果写比读多，最好不要在上面建索引，否则
插入速度从"log speed"降为"database speed"。
2、使用"nature ordering"可以有效地检索最近插入的元素，因为capped collection 能够保证
自然排序就是插入时的顺序，类似于log 文件上的tail 操作。
6.5 注意事项
1、可以在创建capped collection 时指定collection 中能够存放的最大文档数。但这时也要指
定size，因为总是先检查size 后检查maxRowNumber。可以使用validate()查看一个collection

36 / 91
已经使用了多少空间，从而决定size 设为多大。如：
db.createCollection("mycoll", {capped:true, size:100000, max:100});
db.mycoll.validate();
max=1 时会往collection 中存放尽量多的documents。
2 、上述的createCollection 函数也可以用来创建一般的collection ，还有一个参数
"autoIndexID"，值可以为"true"和"false"来决定是否需要在"_id"字段上自动创建索引，如：
db.createCollection("mycoll", {size:10000000, autoIndexId:false})。
默认情况下对一般的collection 是创建索引的，但不会对capped collection 创建。
第七章 GridFS
GridFS 是一种将大型文件存储在MongoDB 数据库中的文件规范。所有官方支持的驱动均实
现了GridFS 规范。
7.1 为什么要用GridFS
由于MongoDB 中BSON 对象大小是有限制的，所以GridFS 规范提供了一种透明的机制，可
以将一个大文件分割成为多个较小的文档，这样的机制允许我们有效的保存大文件对象，特
别对于那些巨大的文件，比如视频、高清图片等。
7.2 如何实现海量存储
为实现这点，该规范指定了一个将文件分块的标准。每个文件都将在文件集合对象中保存一
个元数据对象，一个或多个chunk 块对象可被组合保存在一个chunk 块集合中。大多数情况
下，你无需了解此规范中细节，而可将注意力放在各个语言版本的驱动中有关GridFS API 的
部分或是如何使用mongofiles 工具上。
7.3 语言支持
GridFS 对Java, Perl, PHP, Python, Ruby 等程序语言均支持，且提供了良好的API 接口。
7.4 简单介绍
GridFS 使用两个表来存储数据：
files 包含元数据对象
chunks 包含其他一些相关信息的二进制块
为了使多个GridFS 命名为一个单一的数据库，文件和块都有一个前缀，默认情况下，前缀
是fs，所以任何默认的GridFS 存储将包括命名空间fs.files 和fs.chunks。各种第三方语言的
驱动有权限改变这个前缀，所以你可以尝试设置另一个GridFS 命名空间用于存储照片，它
的具体位置为:photos.files 和photos.chunks。下面我们看一下实际的例子吧。

37 / 91
7.5 命令行工具
mongofiles 是从命令行操作GridFS 的一种工具，例如我们将”mongosniff”这个文件存到库里
面，具体用法如下：
[root@localhost bin]# ./mongofiles put testfile
connected to: 127.0.0.1
added file: { _id: ObjectId('4fc60175c714c5d960fff76a'), filename: "testfile", chunkSize: 262144,
uploadDate: new Date(1338376565745), md5: "8addbeb77789ae6b2cb75deee30faf1a", length:
16 }
done!
下面我们查一下看库里有哪些GridFS 文件，在”mongofiles”后加一个参数”list”即可
[root@localhost bin]# ./mongofiles list
connected to: 127.0.0.1
testfile 16
接下来我们进库里看一下是否有新的东西
[root@localhost bin]# ./mongo
MongoDB shell version: 1.8.1
connecting to: test
> show collections
fs.chunks --上文提到的fs.chunks
fs.files --上文提到的fs.files
system.indexes
system.js
>
我们继续查看fs.files 中的内容
> db.fs.files.find()
{ "_id" : ObjectId("4fc60175c714c5d960fff76a"), "filename" : "testfile", "chunkSize" : 262144,
"uploadDate" : ISODate("2012-05-30T11:16:05.745Z"), "md5" :
"8addbeb77789ae6b2cb75deee30faf1a", "length" : 16 }
字段说明:
Filename: 存储的文件名
chunkSize: chunks 分块的大小
uploadDate: 入库时间
md5: 此文件的md5 码
length: 文件大小, 单位”字节”
看来fs.files 中存储的是一些基础的元数据信息
我们继续查看fs.chunks 中的内容
> db.fs.chunks.find()
{ "_id" : ObjectId("4fc60175cf1154905d949336"), "files_id" :

38 / 91
ObjectId("4fc60175c714c5d960fff76a"), "n" : 0, "data" :
BinData(0,"SGVyZSBpcyBCZWlqaW5nCg==") }
其中比较重要的字段是”n”，它代表的是chunks 的序号，此序号从0 开始，看来fs.chunks
中存储的是一些实际的内容数据信息
我们即然能将此文件存进去，我们就应该有办法将其取出来，下面看一下实例:
[root@localhost bin]# rm testfile
rm：是否删除一般文件 “testfile”? y --先删文件
[root@localhost bin]# ./mongofiles get testfile --将其从库里取出来
connected to: 127.0.0.1
done write to: testfile
[root@localhost bin]# md5sum testfile --校验md5，结果跟库里相同
8addbeb77789ae6b2cb75deee30faf1a testfile
[root@localhost bin]#
7.6 索引
db.fs.chunks.ensureIndex({files_id:1, n:1}, {unique: true});
这样，一个块就可以利用它的files_id 和 n 的值进行检索。注意，GridFS 仍然可以用findOne
得到第一个块，如下：
db.fs.chunks.findOne({files_id: myFileID, n: 0});
第八章 MapReduce
MongoDB 的MapReduce 相当于Mysql 中的"group by"，所以在MongoDB 上使用 Map/Reduce
进行并行"统计"很容易。
使用MapReduce 要实现两个函数 Map 函数和Reduce 函数，Map 函数调用emit(key, value)，
遍历collection中所有的记录，将key与value传递给Reduce 函数进行处理。Map函数和Reduce
函数可以使用JavaScript 来实现，可以通过db.runCommand 或mapReduce 命令来执行一个
MapReduce 的操作：
db.runCommand(
{ mapreduce : ,
map : ,
reduce :
[, query : ]
[, sort : emit key for fewer reduces>]
[, limit : ]
[, out : ]

39 / 91
[, keeptemp: ]
[, finalize : ]
[, scope :

mongoDB配制及学习

你可能感兴趣的:(数据库,shell,javascript,ViewUI)