mongodb学习笔记

时间 2019-11-11

标签 mongodb 学习笔记栏目 MongoDB 繁體版

原文原文链接

mongodb学习笔记

2017年05月20日 22:03:36 张小秋博客阅读数 2158更多javascript

分类专栏：数据库java

本文连接：https://blog.csdn.net/xqzhang8/article/details/72588278web

启动mongodb

经过mongod启动mongodb服务正则表达式

mongod参数选项mongodb

[root@primary bin]# ./mongod –helpshell

-h [ --help ]         帮助信息
  --version             版本信息
  -f [ --config ] arg   配置文件选项
  -v [ --verbose ]      提升内部报告标准输出或记录到logpath配置的日志文件中
  --port                指定服务端口（默认27017）
  --auth                启用验证
  --noauthrun           不启用验证
  --nohttpinterface     关闭http接口，默认关闭27018端口访问
  --fork                以守护进程的方式运行MongoDB，建立服务器进程（后台运行）
  --bind_ip             绑定服务IP，若绑定127.0.0.1，则只能本机访问（默认本地全部IP）
  --maxConns            最大同时链接数 默认2000
  --logpath             指定MongoDB日志文件，注意是指定文件不是目录
  --logappend           使用追加的方式写日志
  --pidfilepath         PID File 的完整路径，若是没有设置，则没有PID文件（pidfilepath=/path/mongod.pid ）
  --keyFile             集群的私钥的完整路径，只对于Replica Set 架构有效
  --setParameter        设置参数（mongod --setParameter textSearchEnabled=true）
  --nounixsocket        关闭unix socket 监听
  --unixSocketPrefix    UNIX域套接字替代目录,(默认为 /tmp)
  --sysloglog           
  --cpu                 按期显示CPU的CPU利用率和iowait
  --dbpath              指定数据库路径（默认/data/db/）
  --diaglog             选项 0=off 1=W 2=R 3=both 7=W+some reads
  --directoryperdbeach  数据库将存储在一个单独的目录中
  --ipv6                IPV6（默认关闭）
  --journal             启用日志选项，MongoDB的数据操做将会写入到journal文件夹的文件里
  --journalCommitInterval buffer刷新到JournalFile的时间间隔
  --journalOptions      启用日志诊断选项
  --jsonp               容许JSONP形式经过HTTP访问（有安全影响） 
  --nojournal           禁用日志选项
  --noprealloc          不预先分配存储
  --noscripting         禁用脚本引擎
  --notablescan         不容许表扫描
  --nssize arg (=16)    设置信数据库.ns文件大小(MB)
  --profile             档案参数 0=off 1=slow, 2=all
  --quota               将每一个数据库限制到必定数量的文件（8个默认值）
  --quotaFiles          #argnumber of files allowed per db, requires --quota
  --repair              #修复全部db
  --repairpath          指定修复文件路径（defaults to dbpath）
  --rest                开启restful http interface,默认是关闭的(控制restful查询接口)
  --shutdown            关闭服务器进程{db.shutdownServer();}
  --slowms arg (=100)   #value of slow for profile and console log
  --smallfilesuse a     #smaller default file size
  --syncdelay arg (=60) 数据写入磁盘的时间秒数(0=never,不推荐)
  --sysinfo             打印一些诊断系统信息
  --upgrade             若是须要升级数据库

//复制选项:
  --oplogSize arg       设置oplog的大小(MB). default is 5% of disk space 

  主/从参数：
  --master              master mode
  --slave               slave mode
  --source              从节点指定主节点的IP和端口 <server:port>
  --only arg            从库指定单一的数据库复制
  --slavedelay          设置从库同步主库的延迟时间
  --autoresync          若是从库与主库同步数据差得多，自动从新同步


  Replica set(副本集)选项：
  --replSet arg         设置副本集名称，格式 <setname>[/<optionalseedhostlist>]
  --replIndexPrefetch   默认all，secondary副本集的成员将加载全部索引到内存中或只会加载_id索引[none|_id_only|all]

  分片选项:
  --configsvr           声明这是一个集群的config服务,默认端口27019，默认目录/data/configdb
  --shardsvrdeclare     this is a shard db of a cluster; default port 27018

mongod启动服务数据库

/mongodb/mongodb/bin/mongod --dbpath=/mongodb/mongodb/bin/db
/mongodb/mongodb/bin/mongod --dbpath=/mongodb/mongodb/bin/db --rest --port=27017 --fork
说明：
默认端口：27017 
web控制台端口：27017+1000=28017
http://localhost:28017

参数使用json

--config  将配置放到config文件。
建立:
mkdir -p /mongodb/mongodb/config/
mkdir -p /mongodb/mongodb/config/db
cp mongod /mongodb/mongodb/config/
vi c.config
port=27018
dbpath=/mongodb/mongodb/config/db
启动
mongod --config=/mongodb/mongodb/config/c.config
登陆：
mongo 127.0.0.1:27018

关闭mongodb

> use admin
    switched to db admin

    > db.shutdownServer()
    Sun Sep  4 02:33:44.407 DBClientCursor::init call() failed
    server should be down...
    Sun Sep  4 02:33:44.408 trying reconnect to 127.0.0.1:27017
    Sun Sep  4 02:33:44.408 reconnect 127.0.0.1:27017 failed couldn't connect to server 127.0.0.1:27017
    >

client访问mongodb

mongo参数选项api

[root@primary bin]# ./mongo --help
MongoDB shell version: 2.4.9
usage: ./mongo [options] [db address] [file names (ending in .js)]
db address can be:
  foo   
  192.169.0.5/foo   
  192.169.0.5:9999/foo

选项:
  --shell                   从命令行运行完一个 .js 文件后，停留在shell中，而不是结束
  --nodb                    不链接数据库方式启动，稍后可使用 new Mongo() 或 connect() 来创建链接
  --quiet                   安静输出
  --port                    链接端口
  --host                    链接主机
  --eval                    #mongo admin --eval "mongo shell指令“
  -u                        认证用户
  -p                        认证密码
  --authenticationDatabase  //>mongo --authenticationDatabase admin -u testuser -p 
  --authenticationMechanism //(=MONGODB-CR)
  -h [ --help ]             帮助信息
  --version                 //show version information
  --verbose                 -v详细模式，多个v能够增长详细输出，如-vvvv
  --ipv6enable              //IPv6 support (disabled by default)

启动例子

/mongodb/bin/mongo 127.0.0.1:27017
[root@primary bin]# /mongodb/bin/mongo 127.0.0.1:27017/zxq -u zxq -p 1234
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27017/zxq
> 
> show collections
aaa
ddd
system.indexes
system.users
t1
zxq
zxq123
>

用户认证

开启安全认证以前，须要有一个管理员用户（admin数据库中的用户为超级管理员）

进入admin数据库中，分配用户

use admin
db.help()
> db.addUser("root","1234")
{
        "user" : "root",
        "readOnly" : false,
        "pwd" : "fa0450e8c3e5fff6005de2f88559c3d9",
        "_id" : ObjectId("57a4f53cda8f119aa039cf34")
}

进入用户数据库，分配用户

use zxq
db.addUser("zxq","1234")
db.addUser("zxqread","1234",true) //只读用户

> db.addUser("zxq","1234")
{
        "user" : "zxq",
        "readOnly" : false,
        "pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3",
        "_id" : ObjectId("57a4f607da8f119aa039cf35")
}

服务端开启安全检查

中止服务，并安全检查方式启动服务
mongod --dbpath=./db --port=27017 --auth

客户端链接，此时须要认证

[root@primary bin]# ./mongo 127.0.0.1:27017/zxq
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27017/zxq
> show collectionsshow collections
Sat Aug  6 04:26:15.274 error: {
"$err" : "not authorized for query on zxq.system.namespaces",
"code" : 16550
} at src/mongo/shell/query.js:128
> 
此时认证失败
>use zxq
>
> db.auth("zxq","1234")
1
> db.auth("zxq","1234")
1

>use admin
> db.auth("root","1234")
1
> show collections
system.indexes
system.users
> 
认证方式经过，能够进行其它操做

客户端链接，此时须要认证

for:mongod dbname -u uname -p password

[root@primary bin]# ./mongo admin -u root -p 1234
MongoDB shell version: 2.4.9
connecting to: admin

[root@primary bin]# ./mongo zxq -u zxq -p 1234
MongoDB shell version: 2.4.9
connecting to: zxq


**//只读用户测试//**

[root@primary bin]# ./mongo zxq -u readonly -p 1234
MongoDB shell version: 2.4.9
connecting to: zxq
> db.zxq.insert({"zxq":"zxq"})
not authorized for insert on zxq.zxq
>

DB操做命令

db.addUser(userDocument)

//添加用户
    > db.addUser("zxq","1234")
    {
            "user" : "zxq",
            "readOnly" : false,
            "pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3",
            "_id" : ObjectId("57a4f607da8f119aa039cf35")
    }

db.adminCommand(nameOrDocument)

//切换到admin数据库并执行方法中的命令。
    > db.adminCommand({shutdown : 1})
    { "ok" : 0, "errmsg" : "unauthorized" }
    >

db.auth(username, password) //用户认证（用户链接）

> db.auth("zxq","1234")
    1

db.cloneDatabase(fromhost) //从另外一个服务器克隆当前选择的数据库

> db.cloneDatabase("localhost:27017")
    { "clonedColls" : [ "test.zxq", "test.zzz" ], "ok" : 1 }
    > 

    > db
    test
    > show collectionsshow collections
    system.indexes
    zxq
    zzz
    >

db.copyDatabase(fromdb, todb, fromhost)

db.copyDatabase('zxq','zxq1')  //本机zxq库copy至zxq1
    > db.copyDatabase('zxq','zxq1','127.0.0.1:27017')  //其它主机zxq库copy至zxq1
    { "ok" : 1 }

    > show dbsshow dbs
    local   0.078125GB
    test0.203125GB
    zxq10.203125GB

    > use zxq1use zxq1
    switched to db zxq1

    > show collectionsshow collections
    aaa
    ddd
    system.indexes
    system.users
    t1
    zxq
    zxq123
    >

db.createCollection(name, { size : …, capped : …, max : … } )

db.createCollection("log",{size:1024})
    db.createCollection("zxq", {capped:true, size:100000, max:100})
        //capped当于能够指定一个表能够占用空间的最大空间或指定一个表最大可容纳的记录数
        //指定zxq这个表最大记录数为100，当第101条记录进来时，最先的记录会被自动删除
        //限制它的空间大小为1M，若是超过1M的大小，则会删除最先的记录

    > for(var i=1;i<=101;i++){db.zxq2.insert({name:"a"+i,age:1+i})}
    > db.zxq2.find()
    { "_id" : ObjectId("57a599706c11d61f2a14e10a"), "name" : "a2", "age" : 3 } //age:2记录被自动删除
    { "_id" : ObjectId("57a599706c11d61f2a14e10b"), "name" : "a3", "age" : 4 }
    { "_id" : ObjectId("57a599706c11d61f2a14e10c"), "name" : "a4", "age" : 5 }
    { "_id" : ObjectId("57a599706c11d61f2a14e10d"), "name" : "a5", "age" : 6 }
    { "_id" : ObjectId("57a599706c11d61f2a14e10e"), "name" : "a6", "age" : 7 }
    { "_id" : ObjectId("57a599706c11d61f2a14e10f"), "name" : "a7", "age" : 8 }
    { "_id" : ObjectId("57a599706c11d61f2a14e110"), "name" : "a8", "age" : 9 }

db.currentOp()

[root@primary zxq]# ./mongo --port=27018
    MongoDB shell version: 2.4.9
    connecting to: 127.0.0.1:27018/test
    > db.currentOp()  //显示当前的操做
    {
            "inprog" : [
                    {
                            "opid" : 887864,
                            "active" : true,
                            "secs_running" : 0,
                            "op" : "insert",
                            "ns" : "zxq1.zxq3",
                            "insert" : {

                            },
                            "client" : "127.0.0.1:24327",
                            "desc" : "conn2",
                            "threadId" : "0x7fec8fc71700",
                            "connectionId" : 2,
                            "locks" : {
                                    "^" : "w",
                                    "^zxq1" : "W"
                            },
                            "waitingForLock" : false,
                            "numYields" : 0,
                            "lockStats" : {
                                    "timeLockedMicros" : {

                                    },
                                    "timeAcquiringMicros" : {
                                            "r" : NumberLong(0),
                                            "w" : NumberLong(1)
                                    }
                            }
                    }
            ]
    }

db.dropDatabase()

//删除当前链接的数据库
    > use zxq1use zxq1
    switched to db zxq1
    > db.dropDatabase()db.dropDatabase()
    { "dropped" : "zxq1", "ok" : 1 }
    > show dbsshow dbs
    local   0.078125GB
    test    0.203125GB
    >

db.eval(func, args)

利用db.eval函数能够在MongoDB服务器端执行javascript脚本,这个函数先将给定的
    javascript字符串传递给MongoDB服务器,在服务器上执行,而后返回结果.

    > db.eval("function(name){return 'hello,'+name;}",['refactor'])
    hello,refactor

db.fsyncLock()

db.fsyncUnlock()

复制数据文件方式数据库：
    直接拷贝数据目录下的一切文件。可是在拷贝过程当中必须阻止数据文件发生更改。
    所以须要对数据库加锁，以防止数据写入。

    > db.fsyncLock()
        {
                "info" : "now locked against writes, use db.fsyncUnlock() to unlock",
                "seeAlso" : "http://dochub.mongodb.org/core/fsynccommand",
                "ok" : 1
        }
        > 
    上面的命令将阻塞写入操做，并将脏数据刷新到磁盘上，确保数据一致。
    而后，拷贝数据文件到备份目录下

    而后，拷贝数据文件到备份目录下
    cp -R /data/db/* /backup

    文件复制完成后，对数据库进行解锁，容许写操做
    > db.fsyncUnlock()
    > 

    注意： 在执行db.fsyncLock()和db.fsyncUnlock()时，
    不能关闭当前的shell窗口，不然可能没法链接而须要从新启动mongod服务。

    恢复时，确保mongod没有运行，清空数据目录，将备份的数据拷贝到数据目录下，
    而后启动mongod
    # cp -R /backup/* /data/db/
    # mongod -f mongod.conf

db.getCollection(cname)

//获取文档名称
    > db.getCollection("zxq")
    zxq.zxq

    //文档重命名
    > db.getCollection('zxq').renameCollection('zxqzxq')
    { "ok" : 1 }
    > show collectionsshow collections
    aaa
    ddd
    system.indexes
    system.users
    t1
    zxq123
    zxqzxq

db.getCollectionNames()

> db.getCollectionNames()
    [
            "aaa",
            "ddd",
            "system.indexes",
            "system.users",
            "t1",
            "zxq123",
            "zxqzxq"
    ]

    //等同于show collections
    > show collections
    aaa
    ddd
    system.indexes
    system.users
    t1
    zxq123
    zxqzxq
    >

db.getLastError()

db.getLastErrorObj()

//db.getLastError()返回上一次错误-若是没有错误则为空
    //db.getLastErrorObj()查看完整的错误结果。
      在没有错误的状况下，db.getLastErrorObj().err应该为空。

    > db.getLastError()
    null

    > db.getLastErrorObj()
    { "n" : 0, "connectionId" : 3, "err" : null, "ok" : 1 }

    > db.getLastErrorObj().err
    null

db.getMongo()

> db.getMongo()db.getMongo()
    connection to 127.0.0.1
    >

db.getMongo().setSlaveOk()

对于replica set 中的secondary 节点默认是不可读的。在写多读少的应用中，
    使用Replica Sets来实现读写分离。经过在链接时指定或者在主库指定slaveOk，
    由Secondary来分担读的压力，Primary只承担写操做。
    若是经过shell访问mongo，要在secondary进行查询。会出现以下错误：
    imageSet:SECONDARY> db.fs.files.find()
    error: { "$err" : "not master and slaveOk=false", "code" : 13435 }

    有两种方法实现从机的查询：
    第一种方法：db.getMongo().setSlaveOk();
    第二种方法：rs.slaveOk();
    可是这种方式有一个缺点就是，下次再经过mongo进入实例的时候，查询仍然会报错，为此能够经过下列方式
    vi ~/.mongorc.js
    增长一行rs.slaveOk();
    这样的话之后每次经过mongo命令进入均可以查询了


    //若是是经过java访问secondary的话则会报下面的异常
    com.mongodb.MongoException: not talking to master and retries used up
    解决的办法不少:
    第一种方法：在java代码中调用dbFactory.getDb().slaveOk();

    第二种方法：在java代码中调用
    dbFactory.getDb().setReadPreference(ReadPreference.secondaryPreferred());
    //在复制集中优先读secondary，若是secondary访问不了的时候就从master中读
    或
    dbFactory.getDb().setReadPreference(ReadPreference.secondary());
    //只从secondary中读，若是secondary访问不了的时候就不能进行查询

    第三种方法：在配置mongo的时候增长slave-ok="true"也支持直接从secondary中读
    <mongo:mongo id="mongo" host="${mongodb.host}" port="${mongodb.port}">
            <mongo:options slave-ok="true"/> 
    </mongo:mongo>

db.getName()

> db.getName()
    zxq
    //等同db
    > db
    zxq

db.getPrevError()

查询以前的错误信息
    > db.getPrevError();
    { "err" : null, "n" : 0, "nPrev" : -1, "ok" : 1 }
    > 
    清除错误记录
    > db.resetError();
    { "ok" : 1 }

db.getProfilingLevel()

mongodb能够经过profile来监控数据，进行优化
    查看当前是否开启profile功能用命令
    返回level等级，值为0|1|2，分别表明意思：
    0表明关闭，1表明记录慢命令，2表明所有
    开始profile功能:
    db.setProfilingLevel(level);  
    #level等级，值同上
    level为1的时候，执行较慢命令默认值为100ms，更改成
    db.setProfilingLevel(level,slowms)
    如db.setProfilingLevel(1,50)这样就更改成50毫秒

    > db.system.profile.find({millis:{$gt:500}}) //所花时间大于500毫秒
    >  
    { "ts" : ISODate("2011-07-23T02:50:13.941Z"), 
    "info" : "query order.order reslen:11022 nscanned:672230  \nquery: { status: 1.0 } nreturned:101
     bytes:11006 640ms", "millis" : 640 }  
    { "ts" : ISODate("2011-07-23T02:51:00.096Z"), 
    "info" : "query order.order reslen:11146 nscanned:672302  \nquery: { status: 1.0, user.uid: 
    { $gt: 1663199.0 } }  nreturned:101 bytes:11130 647ms", "millis" : 647 }  

    注释：
    ts：命令执行时间
    info：命令的内容
        query：表明查询
        order.order： 表明查询的库与集合
        reslen：返回的结果集大小，byte数
        nscanned：扫描记录数量
        nquery：后面是查询条件
        nreturned：返回记录数及用时
        millis：所花时间

db.setProfilingLevel(level,) 0=off 1=slow 2=all

db.getProfilingStatus()

> db.getProfilingStatus()db.getProfilingStatus()
    { "was" : 0, "slowms" : 100 }

    > db.setProfilingLevel(1,50)
    { "was" : 0, "slowms" : 100, "ok" : 1 }

    > db.getProfilingStatus()
    { "was" : 1, "slowms" : 50 }

db.getReplicationInfo()

获取当前数据库集群的复制集信息。

db.getSiblingDB(name)

> db.getSiblingDB("zxq")
    zxq

db.hostInfo()

> db.hostInfo()
    {
            "system" : {
                    "currentTime" : ISODate("2016-08-06T09:42:13.512Z"),
                    "hostname" : "primary",
                    "cpuAddrSize" : 64,
                    "memSizeMB" : 2910,
                    "numCores" : 1,
                    "cpuArch" : "x86_64",
                    "numaEnabled" : false
            },
            "os" : {
                    "type" : "Linux",
                    "name" : "",
                    "version" : ""
            },
            "extra" : {
                    "versionString" : "Linux version 2.6.32-358.el6.x86_64 
                    (mockbuild@x86-022.build.eng.bos.redhat.com) 
                    (gcc version 4.4.7 20120313 
                    (Red Hat 4.4.7-3) (GCC) ) #1 SMP Tue Jan 29 11:47:41 EST 2013",
                    "libcVersion" : "2.12",
                    "kernelVersion" : "2.6.32-358.el6.x86_64",
                    "cpuFrequencyMHz" : "2497.522",
                    "cpuFeatures" : "fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca 
                    cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx rdtscp lm constant_tsc up 
                    rep_good xtopology nonstop_tsc unfair_spinlock pni pclmulqdq monitor ssse3 cx16 
                    sse4_1 sse4_2 popcnt aes xsave avx rdrand hypervisor lahf_lm",
                    "pageSize" : NumberLong(4096),
                    "numPages" : 745116,
                    "maxOpenFiles" : 1024
            },
            "ok" : 1
    }
    >

db.isMaster()

//主库状态
    > db.isMaster()
    {
            "ismaster" : true,
            "maxBsonObjectSize" : 16777216,
            "maxMessageSizeBytes" : 48000000,
            "localTime" : ISODate("2016-08-06T09:45:54.651Z"),
            "ok" : 1
    }

db.killOp(opid)

中止（杀死）在当前库的当前操做，能够用来杀掉长查询

    //诊断1（返回全部与写有关的操做）
    db.currentOp(
       {
         "waitingForLock" : true,
         $or: [
            { "op" : { "$in" : [ "insert", "update", "remove" ] } },
            { "query.findandmodify": { $exists: true } }
        ]
       }
    )


    //诊断2（返回正在运行的操做）
    db.currentOp(
       {
         "active" : true,
         "numYields" : 0,
         "waitingForLock" : false
       }
    )

    //诊断3（在zxq数据库上运行时长超过3S的操做）
    db.currentOp(
       {
         "active" : true,
         "secs_running" : { "$gt" : 3 },
         "ns" : /^zxq\./
       }
    )

    //诊断4（返回建立索引的操做）        
    db.currentOp(
        {
          $or: [
            { op: "query", "query.createIndexes": { $exists: true } },
            { op: "insert", ns: /\.system\.indexes\b/ }
          ]
        }
    )


    //db.currentOp(true) //显示全部会话操做，包括空闲
    > db.currentOp(true)
    {
            "inprog" : [
                    {
                            "opid" : 1526256,
                            "active" : true,
                            "secs_running" : 0,
                            "op" : "insert",
                            "ns" : "zxq.zzzz",
                            "insert" : {

                            },
                            "client" : "127.0.0.1:12599",
                            "desc" : "conn4",
                            "threadId" : "0x7ff3135bd700",
                            "connectionId" : 4,
                            "locks" : {
                                    "^" : "w"
                            },
                            "waitingForLock" : false,
                            "numYields" : 0,
                            "lockStats" : {
                                    "timeLockedMicros" : {
                                            "r" : NumberLong(0),
                                            "w" : NumberLong(57)
                                    },
                                    "timeAcquiringMicros" : {
                                            "r" : NumberLong(0),
                                            "w" : NumberLong(7)
                                    }
                            }
                    }
            ]
    }

    //杀掉操做
    > db.killOp(1526256)
    { "info" : "attempting to kill op" }
    >

db.listCommands()

来看当前MongoDB支持的全部命令
    一样可经过运行命令db.runCommand({"listCommands" :1})来查询全部命令

db.loadServerScripts()

加载在system.js集合中的额全部脚本

db.logout()

//退出

db.printCollectionStats()

//显示文档信息
    zzzz
    {
            "ns" : "zxq.zzzz",
            "count" : 8044831,
            "size" : 450510504,
            "avgObjSize" : 55.99999602229059,
            "storageSize" : 582864896,
            "numExtents" : 18,
            "nindexes" : 1,
            "lastExtentSize" : 153874432,
            "paddingFactor" : 1,
            "systemFlags" : 1,
            "userFlags" : 0,
            "totalIndexSize" : 261157792,
            "indexSizes" : {
                    "_id_" : 261157792
            },
            "ok" : 1
    }

db.printReplicationInfo()

db.printShardingStatus()

db.printSlaveReplicationInfo()

显示复制相关信息

db.removeUser(username)

//删除用户
    > db.system.users.find()
    { "_id" : ObjectId("57a4f607da8f119aa039cf35"), 
    "user" : "zxq", "readOnly" : false, "pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3" }
    { "_id" : ObjectId("57a4f81edb4b33684ccac174"), 
    "user" : "readonly", "readOnly" : true, "pwd" : "853f224e6274e549814cd58e9248293e" }

    > db.removeUser("readonly")
    > db.system.users.find()
    { "_id" : ObjectId("57a4f607da8f119aa039cf35"), 
    "user" : "zxq", "readOnly" : false, "pwd" : "3e7c9de5121b9c6b4c6c289b9c61c8f3" }

db.repairDatabase()

//dbrepairDatabase,不只能整理碎片还能够回收磁盘空间
    > db.repairDatabase()
    > db.runCommand({repairDatabase :1})
    > 期间会产生锁，建议关闭应用后再进行此操做
    > 所须要的磁盘剩余空间需求很大
    > 最后一点，这命令能不用最好别用

db.resetError()

清除错误记录

db.runCommand(cmdObj)

> db.runCommand({repairDatabase :1})

db.serverStatus()

//服务器信息
    //修改服务器最大链接数
    > db.serverStatus().connectionsdb
    { "current" : 1, "available" : 818, "totalCreated" : NumberLong(6) }

    修改系统参数：
    vi /etc/rc.local
    ulimit -n 30000

    vi /etc/profile
    ulimit -n 30000
    [root@primary ~]# ulimit -a
    core file size          (blocks, -c) 0
    data seg size           (kbytes, -d) unlimited
    scheduling priority             (-e) 0
    file size               (blocks, -f) unlimited
    pending signals                 (-i) 22892
    max locked memory       (kbytes, -l) 64
    max memory size         (kbytes, -m) unlimited
    open files                      (-n) 30000    //已经生效
    pipe size            (512 bytes, -p) 8
    POSIX message queues     (bytes, -q) 819200
    real-time priority              (-r) 0
    stack size              (kbytes, -s) 10240
    cpu time               (seconds, -t) unlimited
    max user processes              (-u) 22892
    virtual memory          (kbytes, -v) unlimited
    file locks                      (-x) unlimited
    [root@primary ~]# 
    配置文件
    bpath=/mongodb/db/
    logpath=/mongodb/logs/mongod.log
    port=27017
    logappend=true
    fork = true
    directoryperdb=true
    #auth=true
    maxConns=30000
    或
    [root@primary bin]# ./mongod --dbpath=./db --maxConns=20000
    查看服务器最大链接数
    > db.serverStatus().connections;
    { "current" : 2, "available" : 19998, "totalCreated" : NumberLong(3) }
    >

db.shutdownServer()

//关闭服务
    > use admin
    switched to db admin
    > db.shutdownServer()
    Sat Aug  6 18:53:47.539 DBClientCursor::init call() failed
    server should be down...
    Sat Aug  6 18:53:47.548 trying reconnect to 127.0.0.1:27017
    Sat Aug  6 18:53:47.548 reconnect 127.0.0.1:27017 failed couldn't connect to server 127.0.0.1:27017

db.stats()

//显示当前DB信息
    > db.stats()
    {
            "db" : "test",
            "collections" : 4,
            "objects" : 101,
            "avgObjSize" : 54.53465346534654,
            "dataSize" : 5508,
            "storageSize" : 32768,
            "numExtents" : 5,
            "indexes" : 2,
            "indexSize" : 16352,
            "fileSize" : 201326592,
            "nsSizeMB" : 16,
            "dataFileVersion" : {
                    "major" : 4,
                    "minor" : 5
            },
            "ok" : 1
    }

db.version()

//显示当前版本
    > db.version()
    2.4.9
    >

增、删、改、查

隐式文档建立（文档若是存在，则插入键值，若是不存在，建立文档并插入键值

> db.zxq.insert({id:1,name:"zxq"})

    //查询文档内容
    > db.zxq.find() 
    { "_id" : ObjectId("57c1c2818ee7bef4894d54b0"), "id" : 1, "name" : "zxq" }

    //求文档条数
    > db.zxq.count()
    1
    > 

    //3.2 新版功能
    db.zxq.insertOne(
       {
          name: "sue",
          age: 19,
          status: "P"
       }
    )

    //插入多条数据
    db.zxq.insertMany(
       [
         { name: "bob", age: 42, status: "A", },
         { name: "ahn", age: 22, status: "A", },
         { name: "xi", age: 34, status: "D", }
       ]
    )
    //例子
    > db.zxq.find()
    > db.zxq.insertMany(
    ...    [
    ...      { name: "bob", age: 42, status: "A", },
    ...      { name: "ahn", age: 22, status: "A", },
    ...      { name: "xi", age: 34, status: "D", }
    ...    ]
    ... )
    {
        "acknowledged" : true,
        "insertedIds" : [
            ObjectId("57c2b637b854b5b8198eebd3"),
            ObjectId("57c2b637b854b5b8198eebd4"),
            ObjectId("57c2b637b854b5b8198eebd5")
        ]
    }
    > db.zxq.find()
    { "_id" : ObjectId("57c2b637b854b5b8198eebd3"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2b637b854b5b8198eebd4"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2b637b854b5b8198eebd5"), "name" : "xi", "age" : 34, "status" : "D" }


    //多个条件查询
    > db.zxq.find({age:{$in:[42,22,34]}})
    { "_id" : ObjectId("57c2b637b854b5b8198eebd3"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2b637b854b5b8198eebd4"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2b637b854b5b8198eebd5"), "name" : "xi", "age" : 34, "status" : "D" }
    { "_id" : ObjectId("57c2b7eeb854b5b8198eebd6"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2b7eeb854b5b8198eebd7"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2b7eeb854b5b8198eebd8"), "name" : "xi", "age" : 34, "status" : "D" }
    > 

    > db.zxq.find({_id:{$in:[1,2,3]}})
    { "_id" : 1, "highScore" : 800, "lowScore" : 150 }
    { "_id" : 2, "zxq" : 100 }
    { "_id" : 3, "zxq" : 200

查询记录

//查询全部的内容
    > db.users.find( {} )
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7d"), "name" : "xi", "age" : 34, "status" : "D" }
    > db.users.find()
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7d"), "name" : "xi", "age" : 34, "status" : "D" }

    //单项查询
    > db.users.find({age:42})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }

    //多条件查询
    > db.users.find({age:{$in:[42,22]}})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    >

$lt 小于

> db.users.find({age:{$lt:30}})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    >

$or 或条件

> db.users.find({$or:[{name:"bob" },{age:{$lt:30}}]})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    >

与条件

> db.users.find({name:"ahn","age" : 22})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }

    > db.users.find({name:"ahn",$or:[{age:{$lt:30}},{status:"A"}]})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    >

$gt 大于

> db.users.find({age:{$gt:15,$lt:35}})
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7d"), "name" : "xi", "age" : 34, "status" : "D" }

查询值为Null或不存在的字段

db.users.insert(
       [
          { "_id" : 900, "name" : null },
          { "_id" : 901 }
       ]
    )

    > db.users.find()
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7d"), "name" : "xi", "age" : 34, "status" : "D" }
    { "_id" : 900, "name" : null }
    { "_id" : 901 }
    > 

    > db.users.find( { name: null } )
    { "_id" : 900, "name" : null }
    { "_id" : 901 }
    >

类型筛查（包含值是 null 的 name 字段的文档,亦即条目字段的值是BSON类型中的Null(即 10 ):

> db.users.find( { name : { $type: 10 } } )
    { "_id" : 900, "name" : null }

存在性筛查

> db.users.find({name:{$exists:false}})
    { "_id" : 901 }

$where

> db.zxq.find()
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebdd"), "id" : 2, "name" : "b" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebde"), "id" : 3, "name" : "c" }

    > db.zxq.find({$where:function(){return this.id==3 && this.name=="c"}})
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebde"), "id" : 3, "name" : "c" }
    > 

    > db.zxq.find({$where:function(){ var i=1; return (this.id/i)==3 }})
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebde"), "id" : 3, "name" : "c" }


    > db.zxq.find({$where:function(){return (this.id/1)==3 }})
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebde"), "id" : 3, "name" : "c" }


    >  db.zxq.find({$where:function(){return ( this.id>1&& this.id<3);}})
    { "_id" : ObjectId("57c2d006b854b5b8198eebdd"), "id" : 2, "name" : "b" }
    >

含有ltltlte gtgtgte $eq
< <= > >= =

> db.zzz.find();
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579eacf9d3b6760862b1b5c5"), "id" : 2, "name" : "b" }
    { "_id" : ObjectId("579ead08d3b6760862b1b5c6"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("579ead24d3b6760862b1b5c7"), "id" : 3, "name" : "c" }

    范围查找案例：
    db.zzz.find({id:{$gte:1,$lte:2}})

    > db.zzz.find({id:{$gte:1,$lte:2}})
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579eacf9d3b6760862b1b5c5"), "id" : 2, "name" : "b" }

OR查询：
ininnin $or

> var id={"id":{"$in":[1,2]}}
    > db.zzz.find(id)

    $in查询
    > var id={"id":{"$in":[1,2]}}
    > db.zzz.find(id)
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579eacf9d3b6760862b1b5c5"), "id" : 2, "name" : "b" }

    $nin查询
    > db.zzz.find({id:{"$nin":[1,2]}})
    { "_id" : ObjectId("579ead08d3b6760862b1b5c6"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("579ead24d3b6760862b1b5c7"), "id" : 3, "name" : "c" }

    $OR查询
    > var id={"$or":[{"id":1},{"id":2}]}
    > db.zzz.find(id)

    > db.zzz.find({"$or":[{"id":1},{"id":2}]})
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579eacf9d3b6760862b1b5c5"), "id" : 2, "name" : "b" }
    >

正则表达式：(相似like)
db.zzz.find({“name”:/a/})

> db.zzz.find()db.zzz.find()
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579eacf9d3b6760862b1b5c5"), "id" : 2, "name" : "b" }
    { "_id" : ObjectId("579ead08d3b6760862b1b5c6"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("579ead24d3b6760862b1b5c7"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("579ebb3ee7e548e1d8ec6e22"), "id" : 4, "name" : "aa" }
    { "_id" : ObjectId("579ebb51e7e548e1d8ec6e23"), "id" : 5, "name" : "abc" }

    > db.zzz.find({"name":/a/})  --带有a的 
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579ebb3ee7e548e1d8ec6e22"), "id" : 4, "name" : "aa" }
    { "_id" : ObjectId("579ebb51e7e548e1d8ec6e23"), "id" : 5, "name" : "abc" }

    > db.zzz.find({"name":/a$/}) ---以a开头的
    { "_id" : ObjectId("579ea974a40cd03459b6ac27"), "id" : 1, "name" : "a" }
    { "_id" : ObjectId("579ebb3ee7e548e1d8ec6e22"), "id" : 4, "name" : "aa" }
    >

查询数组

> var single={"name":"jack",address:["anhui","shanghai","beijing"]}
    > db.mytest.insert(single)
    > db.mytest.find()

    { "_id" : ObjectId("567632624163f2ea4dd06e96"), "name" : "jack", "address" : [  "anhui",  "shanghai",  "beijing" ] }

all操做（检索数组中须要包含多个元素，all操做（检索数组中须要包含多个元素，all数组中必须同时包含的条件）

> db.mytest.find({"address":{"$all":["anhui","shanghai"]}})

    { "_id" : ObjectId("567632624163f2ea4dd06e96"), "name" : "jack", "address" : [  "anhui",  "shanghai",  "beijing" ] }

    > db.mytest.find({"address":{"$all":["anhui","s"]}})

size操做（能够经过size操做（能够经过size获取数组的长度，可是$size不能和比较操做符联合使用）

> db.mytest.find({"address":{"$size":2}})
    > db.mytest.find({"address":{"$size":3}})
    { "_id" : ObjectId("567632624163f2ea4dd06e96"), "name" : "jack", "address" : [  "anhui",  "shanghai",  "beijing" ] }

slice操做（经过slice操做（经过slice返回数组中的部分数据。”$slice”:2表示数组中的前两个元素）

> db.mytest.find({"name":"jack"},{"address":{"$slice":1}})
    { "_id" : ObjectId("567632624163f2ea4dd06e96"), "name" : "jack", "address" : [  "anhui" ] }

    > db.mytest.find({"name":"jack"},{"address":{"$slice":2}})
    { "_id" : ObjectId("567632624163f2ea4dd06e96"), "name" : "jack", "address" : [  "anhui",  "shanghai" ] }

更新记录

$set 用来指定一个键并更新键值，若键不存在并建立。

$unset 用来删除键

inc修改器inc修改器inc能够对文档的某个值为数字型（只能为知足要求的数字）的键进行增减的操做

$push 向文档的某个数组类型的键添加一个数组元素，不过滤重复的数据。添加时键存在，要求键值类型必须是数组；键不存在，则建立数组类型的键

$pushAll 指定多个

$addToSet 往一个数组里插入记录

$pop 删除数组内的一个值

$pull 从数组field内删除一个等于value值

pullAll同pullAll同pull,能够一次删除数组内的多个值

$rename 修改键值名称

$mul 乘

$min

$max

$currentDate

> var single=db.zxq.findOne();
    > single
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "zxq" }
    > single.name="zxq3"
    zxq3
    >  db.zxq.update({name:"zxq"},single)；
    >  db.zxq.find(); 
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2, "name" : "zxq1" }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "zxq3" }

    //update更新：
    db.zxq.update(parm1,parm2,parm3,parm4)
    parm1:须要更新的条件
    parm2：更新的对象
    parm3：若是没有符合条件的对象，是否新增一条记录，1（新增），默认值为0
    parm4：若是有多个符合条件的记录，是否所有更新，默认0，若是所有更新取值1 
    语法：
    db.zxq.update({name:"a"},{$set:{age:20}},0,1)  ---更新age键值为20
    db.zxq.update({name:"a"},{$unset:{age:1}},1,1)  ---删除age键
    db.zxq.update({name:"a"},{$inc:{age:1}},0,1)  ---age数据加1
    db.zxq.update({name:"a"},{$inc:{age:-1}},0,1) ---age数据减1

    例如:

set 【语法：db.collection.update( { field: value1 }, {set 【语法：db.collection.update( { field: value1 }, {set: { field1: value2 } } );]

> db.zxq.update({name:"a"},{$set:{age:20}},0,1)  //0表示没有符合条件的不进行增长
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2, "name" : "zxq1" }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "zxq3" }

    > db.zxq.update({name:"a"},{$set:{age:20}},1,1)  //1表示没有符合条件的进行增长1行
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2, "name" : "zxq1" }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "zxq3" }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    >

$unset

> db.zxq.update({id:1},{$unset:{name:1}},0,1)
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }

$inc

> db.zxq.update({name:"zxqzxq"},{$inc:{id:1}},0,1)   //0表示没有符合条件的不进行增长
    > 
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }

    > db.zxq.update({name:"zxqzxq"},{$inc:{id:1}},1,1)  //1表示没有符合条件的进行增长
    > 
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 1, "name" : "zxqzxq" }
    > 

    > db.zxq.update({name:"zxqzxq"},{$inc:{id:1}},1,1)  //有符合条件的id:1进行增长1
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 2, "name" : "zxqzxq" }

    upsert 参数的更新与parm4=1效果同样，在没有符合条件的状况下增长一条记录

    > db.zxq.find({id:6})
    > db.zxq.update({id:6},{$set:{name:"xxxx"}})
    > db.zxq.find({id:6})
    > db.zxq.update({id:6},{$set:{name:"xxxx"}},{upsert:true})
    > db.zxq.find({id:6})
    { "_id" : ObjectId("57c1cebad7f41e4ad2dad410"), "id" : 6, "name" : "xxxx" }


    > db.zxq.update({name:"zxqzxq"},{$inc:{id:2}},1,1)  //有符合条件的id:2进行增长2
    > 
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 4, "name" : "zxqzxq" }

    > db.zxq.update({name:"zxqzxq"},{$inc:{id:-2}})   //有符合条件的id:-2进行减小2
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 4, "name" : "zxqzxq" }

    同时更新多条记录
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1 }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 1, "name" : "zxqzxq" }
    //准备更新id:1的全部记录
    > db.zxq.update({id:1},{$set:{name:"zxq"}})
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "zxq" }  //被更新了，增长了键值
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 1, "name" : "zxqzxq" } //未被更新
    //发现只更新了1条记录

    > db.zxq.update({id:1},{$set:{name:"aaa"}},0,1)  //1表示，若是存在多条，则同时被更新
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "aaa" }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 1, "name" : "aaa" }

    //{multi:true}一样达到更新多条目的
    > db.zxq.update({id:1},{$set:{name:"xxxx"}},{multi:true})
    > db.zxq.find()
    { "_id" : ObjectId("57c1c4ea8ee7bef4894d54b2"), "id" : 2 }
    { "_id" : ObjectId("57c1c4368ee7bef4894d54b1"), "id" : 1, "name" : "xxxx" }
    { "_id" : ObjectId("57c1c77cd7f41e4ad2dad40d"), "age" : 20, "name" : "a" }
    { "_id" : ObjectId("57c1c843d7f41e4ad2dad40e"), "id" : 3, "name" : "aa" }
    { "_id" : ObjectId("57c1c98ad7f41e4ad2dad40f"), "id" : 1, "name" : "xxxx" }

$push

> db.a.find()
    { "_id" : ObjectId("57c1d3f155a4d399ca642249"), "id" : 1, "size" : "a" }
    { "_id" : ObjectId("57c1d3f555a4d399ca64224a"), "id" : 1, "size" : { "a" : 1, "b" : 2 } }
    { "_id" : ObjectId("57c1d2b7be0a1dfd5217d814"), "id" : 1, "name" : "a", "size" : { "c" : [  3 ] } }
    { "_id" : ObjectId("57c1d4c321b1ed73ff5c2968"), "id" : 2, "size" : { "c" : [  3 ] } }
    > 
    > db.a.update({id:2},{$push:{"size.a":1}})
    > db.a.find()
    { "_id" : ObjectId("57c1d3f155a4d399ca642249"), "id" : 1, "size" : "a" }
    { "_id" : ObjectId("57c1d3f555a4d399ca64224a"), "id" : 1, "size" : { "a" : 1, "b" : 2 } }
    { "_id" : ObjectId("57c1d2b7be0a1dfd5217d814"), "id" : 1, "name" : "a", "size" : { "c" : [  3 ] } }
    { "_id" : ObjectId("57c1d4c321b1ed73ff5c2968"), "id" : 2, "size" : { "a" : [  1 ], "c" : [  3 ] } }  //数组类型的键添加一个数组元素

    > db.a.find({id:1})
    { "_id" : ObjectId("57c1d3f155a4d399ca642249"), "id" : 1, "size" : "a" }
    { "_id" : ObjectId("57c1d3f555a4d399ca64224a"), "id" : 1, "size" : { "a" : 1, "b" : 2 } }
    { "_id" : ObjectId("57c1d2b7be0a1dfd5217d814"), "id" : 1, "name" : "a", "size" : { "c" : [  3 ] } }  //向数组中增长元素
    > db.a.update({id:1,name:"a"},{$push:{"size.d":4}},1,0)
    > db.a.find({id:1})
    { "_id" : ObjectId("57c1d3f155a4d399ca642249"), "id" : 1, "size" : "a" }
    { "_id" : ObjectId("57c1d3f555a4d399ca64224a"), "id" : 1, "size" : { "a" : 1, "b" : 2 } }
    { "_id" : ObjectId("57c1d2b7be0a1dfd5217d814"), "id" : 1, "name" : "a", "size" : { "c" : [  3 ], "d" : [  4 ] } }

pushAll 【语法：{pushAll 【语法：{pushAll: { : [ , , … ] } } 】指定多个值

> db.a.update({id:1,name:"a"},{$pushAll:{"size.e":[5,6,7]}})
    > db.a.find({id:1})
    { "_id" : ObjectId("57c1d3f155a4d399ca642249"), "id" : 1, "size" : "a" }
    { "_id" : ObjectId("57c1d3f555a4d399ca64224a"), "id" : 1, "size" : { "a" : 1, "b" : 2 } }
    { "_id" : ObjectId("57c1d2b7be0a1dfd5217d814"), "id" : 1, "name" : "a", "size" : { "c" : [  3 ], "d" : [  4 ], "e" : [  5,  6,  7 ] } }
    >

addToSet 语法：{addToSet 语法：{addToSet: { : , … } }

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  10,  20 ] }
    > db.a.update({ id:1 },{ $addToSet: {size: [ 30,40] } })
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  10,  20,  [  30,  40 ] ] }
    >

addToSet和addToSet和each 是往一个数组里插入每一个记录，并保证元素惟一

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1 }
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 1, 2, 1]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  1,  2 ] }



    //测试数组操做
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2,  3,  4,  5,  6,  7 ] ] }
    > db.a.update({id : 1}, {$addToSet : {size : [1, 2, 1, 2, 3,4,5,6,7]}})
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2,  3,  4,  5,  6,  7 ] ] }
    > db.a.update({id : 1}, {$addToSet : {size : [1, 2, 1, 2, 3,4,5,6,7,8]}})
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [    [   1,  2,  1,  2,  3,  4,  5, 6,   7 ],    

    [   1,  2,  1,  2,  3,  4,  5,  6,  7,  8 ] ] }
    > 


    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1 }
    > db.a.update({id : 1}, {$addToSet : {size : [1, 2, 1, 2]}})
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2 ] ] }
    > 
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 1, 2, 1]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2 ],  1,  2 ] }
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 1, 2, 1]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2 ],  1,  2 ] }
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 1, 2, 1,3,4,5]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  [  1,  2,  1,  2 ],  1,  2,  3,  4,  5 ] }
    > 

    //测试数组操做
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 3,4]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  1,  2,  3,  4 ] }
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [ 1, 2, 3,4,5,6,7]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  1,  2,  3,  4,  5,  6,  7 ] }
    > db.a.update({id : 1}, {$addToSet : {size : {$each : [8,9,10]}}}, true)
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  1,  2,  3,  4,  5,  6,  7,  8,  9,  10 ] }

$pop 只能删除一个值，也就是说只能用1或-1

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  1,  2 ] }
    > db.a.update( { id:1} , { $pop : { "size": -1 } } );
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  2 ] }
    > 

    >  db.a.update( { id:1} , { $pop : { "size": -1 } } );  //-1从前面删除1个值
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  2,  3,  4,  5,  6,  7,  8,  9,  10 ] }
    > db.a.update( { id:1} , { $pop : { "size": 1 } } );    //1从后面删除1个值
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  2,  3,  4,  5,  6,  7,  8,  9 ] }
    > db.a.update( { id:1} , { $pop : { "size": 2 } } );    //其它值和1或-1效果同样
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  2,  3,  4,  5,  6,  7,  8 ] }
    > db.a.update( { id:1} , { $pop : { "size": -2 } } );   //其它值和1或-1效果同样
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  3,  4,  5,  6,  7,  8 ] }

$pull

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  4,  5,  6,  7,  8 ] }
    > db.a.update( { "id" : 1 } , { $pull : { "size":6} } );
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  4,  5,  7,  8 ] }
    >

$pullAll

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  4,  5,  7,  8 ] }
    > db.a.update({id:1},{$pull:{size:[4,8]}});
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  4,  5,  7,  8 ] }
    > db.a.update({id:1},{$pullAll:{size:[4,8]}});
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  5,  7 ] }
    >

rename 语法：{rename 语法：{rename: { : , : , … } }

> db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size1" : [  5,  7 ] }
    > db.a.update({id:1},{$rename:{"size1":"size"}});
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  5,  7 ] }
    > 

    > db.a.insert({id:2,"name": { "first" : "george", "last" : "washington" }})
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  5,  7 ] }
    { "_id" : ObjectId("57c27c713b5e3ba4c68d0d78"), "id" : 1 }
    { "_id" : ObjectId("57c27c963b5e3ba4c68d0d79"), "id" : 2, "name" : { "first" : "george", "last" : "washington" } }

    > db.a.update({id:2}, {$rename: { "name.first": "name.fname"}})
    > db.a.find()
    { "_id" : ObjectId("57c273813b5e3ba4c68d0d77"), "id" : 1, "size" : [  5,  7 ] }
    { "_id" : ObjectId("57c27c713b5e3ba4c68d0d78"), "id" : 1 }
    { "_id" : ObjectId("57c27c963b5e3ba4c68d0d79"), "id" : 2, "name" : { "fname" : "george", "last" : "washington" } }

$mul

{ _id: 1, item: "ABC", price: 10.99 }

    db.zxq.update(
       { _id: 1 },
       { $mul: { price: 1.25 } }
    )

    { _id: 1, item: "ABC", price: 13.7375 }

$min

> db.zxq.insert({ _id: 1, highScore: 800, lowScore: 200 })
    WriteResult({ "nInserted" : 1 })
    > db.zxq.find()
    { "_id" : 1, "highScore" : 800, "lowScore" : 200 }
    > db.zxq.update( { _id: 1 }, { $min: { lowScore: 150 } } )
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
    > db.zxq.find()
    { "_id" : 1, "highScore" : 800, "lowScore" : 150 }
    > db.zxq.update( { _id: 1 }, { $min: { lowScore: 250 } } )
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
    > db.zxq.find()
    { "_id" : 1, "highScore" : 800, "lowScore" : 150 }
    >

$max

> db.zxq.find()
    { "_id" : 1, "highScore" : 800, "lowScore" : 150 }
    > db.zxq.update( { _id: 1 }, { $max: { highScore: 950 } } )
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
    > db.zxq.find()
    { "_id" : 1, "highScore" : 950, "lowScore" : 150 }
    > db.zxq.update( { _id: 1 }, { $max: { highScore: 870 } } )
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
    > db.zxq.find()
    { "_id" : 1, "highScore" : 950, "lowScore" : 150 }


    > db.a.insert({_id: 1,desc: "crafts",dateEntered: ISODate("2013-10-01 05:00:00"),dateExpired: ISODate("2013-10-01 16:38:16.16")})
    WriteResult({ "nInserted" : 1 })
    > db.a.find()
    { "_id" : 1, "desc" : "crafts", "dateEntered" : ISODate("2013-10-01T05:00:00Z"), "dateExpired" : ISODate("2013-10-01T16:38:16.160Z") }

    > db.a.update({ _id: 1 },{ $max: { dateExpired: new Date("2013-09-30") } })
    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
    > db.a.find()
    { "_id" : 1, "desc" : "crafts", "dateEntered" : ISODate("2013-10-01T05:00:00Z"), "dateExpired" : ISODate("2013-10-01T16:38:16.160Z") }
    >

$currentDate

> db.b.insert({ _id: 1, status: "a", lastModified: ISODate("2013-10-02 01:11:18") })
    WriteResult({ "nInserted" : 1 })

    >  db.b.find()
    { "_id" : 1, "status" : "a", "lastModified" : ISODate("2013-10-02T01:11:18Z") }
    > 

    > db.b.update({ _id: 1 }, { $currentDate: { lastModified: true, "cancellation.date": { $type: "timestamp" }  }, 


    $set: { status: "D", "cancellation.reason": "user request"  }})

    WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

    > db.b.find()
    { "_id" : 1, "status" : "D", "lastModified" : ISODate("2016-08-28T06:55:58.745Z"), "cancellation" : 

    { "date" : Timestamp(1472367358, 1), "reason" : "user request" } }
    > 

    > db.b.find()
    { "_id" : 2, "lastModified" : ISODate("2016-08-28T08:47:21.837Z") }

    > db.b.update({ _id:1}, { $currentDate: { lastModified: true}},1,1)
    WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : 1 })
    > db.b.find()
    { "_id" : 2, "lastModified" : ISODate("2016-08-28T08:47:21.837Z") }
    { "_id" : 1, "lastModified" : ISODate("2016-08-28T08:48:01.274Z") }
    >

索引，执行计划

for (var i=0;i<10000;i++){db.ccc.insert({"name":"a"+i,"age":i+1})}

    > db.ccc.count()
    214069
    > db.ccc.find({age:100})
    { "_id" : ObjectId("57c2e2c56da14df0c2b1cc85"), "name" : "a99", "age" : 100 }

建立B-tree索引

> db.ccc.ensureIndex({age:1}) 

    > db.ccc.find({age:100}).explain()

    {
        "cursor" : "BtreeCursor age_1",
        "isMultiKey" : false,
        "n" : 1,
        "nscannedObjects" : 1,
        "nscanned" : 1,
        "nscannedObjectsAllPlans" : 1,
        "nscannedAllPlans" : 1,
        "scanAndOrder" : false,
        "indexOnly" : false,
        "nYields" : 0,
        "nChunkSkips" : 0,
        "millis" : 0,
        "indexBounds" : {
            "age" : [
                [
                    100,
                    100
                ]
            ]
        },
        "server" : "linux:27017"
    }

建立符合索引（1:表明升序， -1：表明降序）

> db.ccc.ensureIndex({age:1,name:1})
      db.ccc.ensureIndex({"age":1,"name":-1})


    > db.ccc.find({name:"a0"})
    { "_id" : ObjectId("57c2e2c56da14df0c2b1cc22"), "name" : "a0", "age" : 1 }
    > db.ccc.find({name:"a0"}).explain()
    {
        "cursor" : "BtreeCursor name_1",
        "isMultiKey" : false,
        "n" : 1,
        "nscannedObjects" : 1,
        "nscanned" : 1,
        "nscannedObjectsAllPlans" : 1,
        "nscannedAllPlans" : 1,
        "scanAndOrder" : false,
        "indexOnly" : false,
        "nYields" : 0,
        "nChunkSkips" : 0,
        "millis" : 0,
        "indexBounds" : {
            "name" : [
                [
                    "a0",
                    "a0"
                ]
            ]
        },
        "server" : "linux:27017"
    }

惟一索引

> db.ccc.ensureIndex({"age":1},{"unique":true})
    >

查看索引

> db.ccc.getIndexes()
    [
        {
            "v" : 1,
            "key" : {
                "_id" : 1
            },
            "ns" : "test.ccc",
            "name" : "_id_"
        },
        {
            "v" : 1,
            "key" : {
                "age" : 1
            },
            "ns" : "test.ccc",
            "name" : "age_1"
        },
        {
            "v" : 1,
            "key" : {
                "name" : 1
            },
            "ns" : "test.ccc",
            "name" : "name_1"
        },
        {
            "v" : 1,
            "key" : {
                "age" : 1,
                "name" : 1
            },
            "ns" : "test.ccc",
            "name" : "age_1_name_1"
        }
    ]
    > 



    > db.system.indexes.find()  //查看全部索引
    { "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.zxq", "name" : "_id_" }
    { "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.a", "name" : "_id_" }
    { "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.users", "name" : "_id_" }
    { "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.ccc", "name" : "_id_" }
    { "v" : 1, "key" : { "age" : 1 }, "ns" : "test.ccc", "name" : "age_1" }
    { "v" : 1, "key" : { "name" : 1 }, "ns" : "test.ccc", "name" : "name_1" }
    { "v" : 1, "key" : { "age" : 1, "name" : 1 }, "ns" : "test.ccc", "name" : "age_1_name_1" }
    >

删除索引

删除集合全部索引
    db.ccc.dropIndexes();

    删除特定索引 (删除id字段升序的索引)
    db.ccc.dropIndex({"id":1})
    > db.ccc.dropIndex({"age" : 1})
    { "nIndexesWas" : 2, "ok" : 1 }

    查看索引：
    db.ccc.getIndexes()
    db.system.indexes.find()

    重构索引(慎用)
    db.articles.reIndex();
    注意：索引排序规则升序：1，降序-1

聚合函数

count

> db.zxq.count()
    1000

distinct

> db.runCommand({"distinct":"zxq","key":"name"})    

            "a997",
            "a998",
            "a999",
            "a1000"
        ],
        "stats" : {
            "n" : 1000,
            "nscanned" : 1000,
            "nscannedObjects" : 1000,
            "timems" : 2,
            "cursor" : "BasicCursor"
        },
        "ok" : 1
    }


    distinct使用

    db.xxx.distinct("age")
    > db.zzz.distinct("id")
    [ 1, 2, 3, 4, 5 ]

group

select a,b,sum(c) csum from coll where active=1 group by a,b;

    db.coll.group({
        'key':{
            'a':true,
            'b':true
        },
        'cond':{ 'active':1 },
        'reduce': function(obj, prev)
        {
            prev.csum ++
        },
        'initial':{'csum': 0}
    })


    db.zxq.group({
        'key':{
            'id':true,
            'name':true
        },
        'cond':{ 'id':1 },  //cond用于筛选条件
        'reduce': function(obj, prev) //obj用于扫描行，prev用于输出结果
        {
            prev.csum ++
        },
        'initial':{'csum': 0}   //设定初始值
    })


    //以下案例
    > db.zxq.find({id:1})
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f6"), "id" : 1, "name" : "a1" }
    { "_id" : ObjectId("57cbc9a0c2993ede6eb62ade"), "id" : 1, "name" : "a1" }
    { "_id" : ObjectId("57cbc9a2c2993ede6eb62ec6"), "id" : 1, "name" : "a1" }
    { "_id" : ObjectId("57cbc9a5c2993ede6eb632ae"), "id" : 1, "name" : "a1" }

    > db.zxq.group({ 'key':{ 'id':true,'name':true },'cond':{'id':1},'initial':{'csum': 0},'reduce': function(obj, prev) { prev.csum ++ } })
    [ { "id" : 1000, "name" : "a1000", "csum" : 4 } ]

    //写法二，runCommand
    db.runCommand({group:
        {
            ns:"zxq",
            key:{id:true,name:true},
            initial:{num:0},
            $reduce:function(doc,prev){
            prev.num++}
        }
    });


    //添加筛选条件
    db.zxq.group({key:{id:true,name:true},initial:{num:0},$reduce:function(doc,prev){
        prev.num++
    },
    condition:{id:{$gt:990}}
    });


    //写法二，添加筛选条件
    db.runCommand({group:
        {
            ns:"zxq",
            key:{id:true,name:true},
            initial:{num:0},
            $reduce:function(doc,prev){
            prev.num++},
            condition:{id:{$gt:998}}
        }
    });

    //使用函数返回值分组
    > db.zxq.group({$keyf:function(doc){return {name:doc.name};},initial:{num:0},$reduce:function(doc,prev){ prev.num++ }, condition:{id:{$gt:997}} });
    [
        {
            "name" : "a998",
            "num" : 4
        },
        {
            "name" : "a999",
            "num" : 4
        },
        {
            "name" : "a1000",
            "num" : 4
        }
    ]
    > 


    //写法二
    db.runCommand({group:
        {
            ns:"zxq",
            $keyf:function(doc){return {name:doc.name};},
            initial:{num:0},
            $reduce:function(doc,prev){
            prev.num++}
        }
    });


    //使用终结器
    db.zxq.group({$keyf:function(doc){return {name:doc.name};},initial:{num:0},$reduce:function(doc,prev){
        prev.num++
    },condition:{id:{$gt:997}},
    finalize: function(doc){ doc.count=doc.num;delete doc.num; }
    });

    [
        {
            "name" : "a998",
            "count" : 4
        },
        {
            "name" : "a999",
            "count" : 4
        },
        {
            "name" : "a1000",
            "count" : 4
        }
    ]
    > 

    //写法二
    db.runCommand({group:
        {
            ns:"zxq",
            $keyf:function(doc){return {name:doc.name};},
            initial:{num:0},
            $reduce:function(doc,prev){
            prev.num++},condition:{id:{$gt:997}},
            finalize: function(doc){ doc.count=doc.num;delete doc.num; }
        }
    });

    {
        "retval" : [
            {
                "name" : "a998",
                "count" : 4
            },
            {
                "name" : "a999",
                "count" : 4
            },
            {
                "name" : "a1000",
                "count" : 4
            }
        ],
        "count" : 12,
        "keys" : 3,
        "ok" : 1
    }

MapReduce

能完成count、distinct、group的全部功能

db.runCommand(
    {
        mapreduce:'zxq',
        map:function(){emit(this.name.substr(0,3),this);},
        reduce:function(key,vals){return vals[0];},  //注意：vals是一个Object对象而不是数组
        out:'wq'
    });


    {
        "result" : "wq",
        "timeMillis" : 124,
        "counts" : {
            "input" : 4000,
            "emit" : 4000,
            "reduce" : 387,
            "output" : 99
        },
        "ok" : 1
    }


    注意：
    1.mapreduce是根据map函数里调用的emit函数的第一个参数来进行分组的
    2.仅当根据分组键分组后一个键匹配多个文档，才会将key和文档集合交由reduce函数处理。

    db.runCommand(
    {
        mapreduce:'zxq',
        map:function(){emit(this.name.substr(0,3),this);},
        reduce:function(key,vals){return 'wq';}, 
        out:'wq'
    }); 
    //查看wq表数据

    > show collections
    a
    ccc
    system.indexes
    users
    wq
    zxq

    > db.wq.find()
    { "_id" : "a1", "value" : "wq" }
    { "_id" : "a10", "value" : "wq" }
    { "_id" : "a11", "value" : "wq" }
    { "_id" : "a12", "value" : "wq" }
    { "_id" : "a13", "value" : "wq" }
    { "_id" : "a14", "value" : "wq" }
    { "_id" : "a15", "value" : "wq" }
    { "_id" : "a16", "value" : "wq" }
    { "_id" : "a17", "value" : "wq" }
    { "_id" : "a18", "value" : "wq" }
    { "_id" : "a19", "value" : "wq" }
    { "_id" : "a2", "value" : "wq" }
    { "_id" : "a20", "value" : "wq" }
    { "_id" : "a21", "value" : "wq" }
    { "_id" : "a22", "value" : "wq" }
    { "_id" : "a23", "value" : "wq" }
    { "_id" : "a24", "value" : "wq" }
    { "_id" : "a25", "value" : "wq" }
    { "_id" : "a26", "value" : "wq" }
    { "_id" : "a27", "value" : "wq" }
    Type "it" for more

    //案例二：group的功能
    > map = function() { for (var key in this) { emit(key, {count : 1}); }};

    > reduce = function(key, emits) { total = 0; for (var i in emits) { total += emits[i].count; } return {"count" : total}; }

    > db.runCommand({"mapreduce" : "zxq", "map" : map, "reduce" : reduce,"out":"result"})
    {
        "result" : "result",
        "timeMillis" : 307,
        "counts" : {
            "input" : 4000,
            "emit" : 12000,
            "reduce" : 120,
            "output" : 3
        },
        "ok" : 1
    }

    //结果集
    > db.result.find()
    { "_id" : "_id", "value" : { "count" : 4000 } }
    { "_id" : "id", "value" : { "count" : 4000 } }
    { "_id" : "name", "value" : { "count" : 4000 } }

删除记录

> db.zxq.remove({id:1})
    > db.zxq.find()

    > db.zxq.deleteOne({id:2})
    { "acknowledged" : true, "deletedCount" : 1 }
    > db.zxq.find({})
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    > 

    > db.zxq.deleteMany({"name" : "a"})
    { "acknowledged" : true, "deletedCount" : 1 }
    > db.zxq.find({})
    { "_id" : ObjectId("57c2ce75b854b5b8198eebdb"), "id" : 3, "name" : "c" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebdd"), "id" : 2, "name" : "b" }
    { "_id" : ObjectId("57c2d006b854b5b8198eebde"), "id" : 3, "name" : "c" }
    >

游标

建立测试表

> for (i=1;i<=1000;i++){db.zxq.insert({id:i,name:"a"+i})}

定义游标

var cursor = db.zxq.find();
    while (cursor.hasNext()){obj=cursor.next();print(obj.id);}

    //增长函数
    > db.zxq.find().limit(3)   //显示前面3行
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f6"), "id" : 1, "name" : "a1" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f7"), "id" : 2, "name" : "a2" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f8"), "id" : 3, "name" : "a3" }

    > db.zxq.find().skip(3).limit(3)  //跳过前面3行，显示3行
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f9"), "id" : 4, "name" : "a4" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626fa"), "id" : 5, "name" : "a5" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626fb"), "id" : 6, "name" : "a6" }

    > db.zxq.find().limit(3).sort({id:-1}) //降序排序
    { "_id" : ObjectId("57cbbbe7c2993ede6eb62add"), "id" : 1000, "name" : "a1000" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb62adc"), "id" : 999, "name" : "a999" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb62adb"), "id" : 998, "name" : "a998" }

    > db.zxq.find().limit(3).sort({id:1}) //升序排序
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f6"), "id" : 1, "name" : "a1" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f7"), "id" : 2, "name" : "a2" }
    { "_id" : ObjectId("57cbbbe7c2993ede6eb626f8"), "id" : 3, "name" : "a3" }

    //分页处理
    var cursor1 = db.zxq.find().limit(100);
    var cursor2 = db.zxq.find().skip(100).limit(100);
    var cursor3 = db.zxq.find().skip(200).limit(100);
    while (cursor1.hasNext()){obj=cursor1.next();print(obj.id);}
    while (cursor2.hasNext()){obj=cursor2.next();print(obj.id);}
    while (cursor3.hasNext()){obj=cursor3.next();print(obj.id);}

手动迭代游标

> var myCursor = db.users.find({status:"A"});
    > myCursor
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"), "name" : "bob", "age" : 42, "status" : "A" }
    { "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"), "name" : "ahn", "age" : 22, "status" : "A" }
    > 

    > var myCursor = db.users.find({status:"A"});
    > myCursor.hasNext()
    true

    > print(tojson(myCursor.next()))
    {
        "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"),
        "name" : "bob",
        "age" : 42,
        "status" : "A"
    }
    > print(tojson(myCursor.next()))
    {
        "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"),
        "name" : "ahn",
        "age" : 22,
        "status" : "A"
    }
    > print(tojson(myCursor.next()))
    Sun Aug 28 04:28:24.382 error hasNext: false at src/mongo/shell/query.js:124
    > 

    //游标2
    > var myCursor = db.users.find({status:"A"});
    > printjson(myCursor.next())
    {
        "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7b"),
        "name" : "bob",
        "age" : 42,
        "status" : "A"
    }
    > printjson(myCursor.next())
    {
        "_id" : ObjectId("57c2ba213b5e3ba4c68d0d7c"),
        "name" : "ahn",
        "age" : 22,
        "status" : "A"
    }

GridFs

数据库中存放二进制文件超过16M时，使用GridFs，GridFS在数据库中，默认使用fs.chunks和fs.files来存储文件。其中fs.files集合存放文件的信息，fs.chunks存放文件数据。

[root@linux bin]# echo "zxq is good" >zxq.txt  //建立文件
    [root@linux bin]# cat zxq.txt 
    zxq is good

    [root@linux bin]# ./mongofiles put zxq.txt    //文件传输到数据库中
    connected to: 127.0.0.1
    added file: { _id: ObjectId('57cc32ac747f6865ca501e58'), filename: "zxq.txt", chunkSize: 262144, uploadDate: new Date(1473000108668), md5: "39c87dd1241d8ab74494d88439b7ad9a", length: 12 }
    done!
    [root@linux bin]# 


    > show collections      //查看数据库中文档
    a
    ccc
    fs.chunks
    fs.files
    result
    system.indexes
    users
    wq
    zxq
    > db.fs.files.find()   //查看表中的文件信息
    { "_id" : ObjectId("57cc32ac747f6865ca501e58"), "filename" : "zxq.txt", "chunkSize" : 262144, "uploadDate" : ISODate("2016-09-04T14:41:48.668Z"), "md5" : "39c87dd1241d8ab74494d88439b7ad9a", "length" : 12 }


    [root@linux bin]# rm zxq.txt    //删除原始文件
    rm: remove regular file `zxq.txt'? yes
    [root@linux bin]# cat zxq.txt
    cat: zxq.txt: No such file or directory
    [root@linux bin]# 

    [root@linux bin]# ./mongofiles list  //查看数据库中文件
    connected to: 127.0.0.1
    zxq.txt 12
    [root@linux bin]# 


    [root@linux bin]# ./mongofiles get zxq.txt  //从数据库中取出文件
    connected to: 127.0.0.1
    done write to: zxq.txt
    [root@linux bin]# ls
    bsondump  mongod       mongofiles   mongoperf     mongosniff  zxq.txt
    db        mongodump    mongoimport  mongorestore  mongostat
    mongo     mongoexport  mongooplog   mongos        mongotop
    [root@linux bin]# cat zxq.txt 
    zxq is good
    [root@linux bin]# 

    //传入第二个文件
    [root@linux bin]# ./mongofiles put zxq1.txt 
    connected to: 127.0.0.1
    added file: { _id: ObjectId('57cc33e4d3e1c4b92d0e0374'), filename: "zxq1.txt", chunkSize: 262144, uploadDate: new Date(1473000420571), md5: "39c87dd1241d8ab74494d88439b7ad9a", length: 12 }
    done!

    [root@linux bin]# ./mongofiles list
    connected to: 127.0.0.1
    zxq.txt 12
    zxq1.txt    12

    > db.fs.files.find()  //查看数据库中文件信息
    { "_id" : ObjectId("57cc32ac747f6865ca501e58"), "filename" : "zxq.txt", "chunkSize" : 262144, "uploadDate" : ISODate("2016-09-04T14:41:48.668Z"), "md5" : "39c87dd1241d8ab74494d88439b7ad9a", "length" : 12 }
    { "_id" : ObjectId("57cc33e4d3e1c4b92d0e0374"), "filename" : "zxq1.txt", "chunkSize" : 262144, "uploadDate" : ISODate("2016-09-04T14:47:00.571Z"), "md5" : "39c87dd1241d8ab74494d88439b7ad9a", "length" : 12 }

    //查找带有zxq的文件
    [root@linux bin]# ./mongofiles search zxq
    connected to: 127.0.0.1
    zxq.txt 12
    zxq1.txt    12
    [root@linux bin]# ./mongofiles search zxq.txt
    connected to: 127.0.0.1
    zxq.txt 12
    [root@linux bin]# 


    Mongofiles参数说明：
    –d 指定数据库 ，默认是fs，Mongofiles list –d testGridfs
    -u –p 指定用户名，密码
    -h  指定主机
    -port 指定主机端口
    -c 指定集合名，默认是fs
    -t 指定文件的MIME类型，默认会忽略

journal工做原理

journal文件在MongoDB中的做用至关于redo日志文件在oracle中的做用，
它能够在即便服务器意外宕机的状况下，将数据库操做进行重演
在64位的机器上，2.0以上版本默认是开启了journal的，
可是在32位机器上，或者2.0如下的版本中，默认是不开启journal

默认状况下mongodb每100毫秒往journal文件中flush一次数据，
不过这是在数据文件和journal文件处于同一磁盘卷上的状况，而
若是数据文件和journal文件不在同一磁盘卷上时，默认刷新输出
时间是30毫秒。不过这个毫秒值是能够修改的，可修改范围是2~300，
值越低，刷新输出频率越高，数据安全度也就越高，但磁盘性能上的开销也更高。

   journal文件是以“j._”开头命名的，且是append only的，若是1
个journal文件满了1G大小，mongodb就会新建立一个journal文件来
使用，一旦某个journal文件所记载的写操做都被使用过了，mongodb就
会把这个journal文件删除。一般在journal文件所在的文件夹下，只会
存在2~3个journal文件，除非你使用mongodb每秒都写入大量的数据。
而使用 smallfiles 这个运行时选项能够将journal文件大小减至128M大小。

[root@primary journal]# pwd
/mongodb/bin/db/journal
[root@primary journal]# ls -l
total 3145740
-rw------- 1 root root 1073741824 Aug  6 19:03 j._0
-rw------- 1 root root 1073741824 Aug  4 08:01 prealloc.1
-rw------- 1 root root 1073741824 Aug  4 08:01 prealloc.2

首先要知道在这个原理中，存在着两个file，两个view。两个file是 data file 
和 journal file，两个view是 shared view 和 private view。
两个file是对磁盘而言的，而两个view是对内存而言的，下面以图解
的方式解释：

启动服务前

启动服务后，MongoDB请求操做系统将Data file映射到Shared view，此时操做系统只管
映射这个动做，并不将数据加载到Shared view中，而是由MongoDB在须要时再将数据进行加载到Shared view。

而后，MongoDB再请求操做系统将Shared view映射到Private view，
以后MongDB对数据的读写操做都是直接操做的Private view

若是发生了写操做

Private view变脏之后，根据journalCommitInterval的设置，
将在必定时间后将写操做往Journal file中复制，这个过程称为“group commit”：

Journal file中记录的是原生的操做（raw operation），这些原生的操做能够
使MongoDB完成如下操做：
    对文档的插入/更新（document insertion/updates）
    对索引的修改（index modifications）
    对命名空间文件的修改（changes to the namespace files）
这些原生操做告诉了Journal file数据变化发生在Data file的什么位置。
至此，MongoDB上发生的写事件能够被认为是安全的了，由于这些写操做已
经被记录在了Journal file上，即便服务器掉电了，在下次启动MongoDB时，
Journal file上的写操做将会被重演。

接下来，Journal file中记录的写操做会应用在Shared view上：

默认每隔60秒，MongoDB请求操做系统将Shared view刷新输出到Data file：

数据就被写入到数据文件了。这时MongoDB还会将Journal file
中已输出到Data file的写操做删除掉（因为MongoDB在将Journal 
file中写操做放到Shared view时，是经过了一个前指针和一个后
指针来操做的，因此MongoDB知道哪些写操做是被放到Shared view了的，哪些没有）。

最后，MongoDB还会例行地如一开始同样，将Shared view映射
到Private view，以保持一致性（也是防止Private view变得太过于脏了）。

MongoDB 作内存数据库使用

[root@primary bin]# mkdir /mongodata
    [root@primary bin]# mount -t tmpfs -o size=2048M tmpfs /mongodata
    [root@primary bin]# df -h
    Filesystem            Size  Used Avail Use% Mounted on
    /dev/mapper/rootvg-rootlv 93G   53G   36G  60% /
    tmpfs                 1.5G   72K  1.5G   1% /dev/shm
    /dev/sda1             194M   34M  151M  18% /boot
    tmpfs                 2.0G     0  2.0G   0% /mongodata

    mongodb参数文件
    dbpath=/mongodata
    //能够减小开销
    nojournal = true
    smallFiles = true
    noprealloc = true

    使用
    > show dbs
    local   0.078125GB
    test    (empty)
    > use zxquse zxq
    switched to db zxq
    > db.zxq.insert({name:"a"})> 
    > 
    > db.zxq.find()db.zxq.find()
    { "_id" : ObjectId("57a5c68ea9475fc6e6d4cb77"), "name" : "a" }
    >

数据导出方式备份

建立测试表

for(var i=1;i<1000;i++){db.t1.insert({name:"a"+i,age:i+1})}

导出表数据

mongoexport -h 192.168.111.111:27017 -d zxq -c t1 -o /mongodb/backup/t1.txt
connected to: 192.168.111.111:27017
exported 999 records

删除测试数据文档

[root@primary bin]# > use zxq
[root@primary bin]# > db.t1.drop()
[root@primary bin]# ./mongoimport -h 192.168.111.111:27017 -d zxq -c t1 /mongodb/backup/t1.txt
connected to: 192.168.111.111:27017
Thu Aug  4 19:51:02.880 check 9 999
Thu Aug  4 19:51:02.943 imported 999 objects

验证数据是否恢复

[root@primary bin]#> db.t1.count()
[root@primary bin]#> 999

搭建主从备份

开启master服务器

[administrator@localhost ~]$ ./mongod --dbpath=/mongodb/master/db 
--master -port 27017 --logpath=/mongodb/master/logs/mongodb.log --fork
   --master  标记本身是master服务器。
   --port    指定本身的端口，默认是27017
   --fork    后台运行启动进程

开启slave服务器

[administrator@localhost ~]$ 
./mongod --dbpath=/mongodb/slave/db --slave --source=127.0.0.1:27017 
--port 27018 --logpath=/mongodb/slave/logs/mongodb.log --fork
   --slave：   标记本身是slave服务器
   --source：  标记我须要同步的服务器是谁？ 指定的ip。
   --port：     开启本身的端口，千万不能和master重复。
   --fork      后台运行启动进程

副本集=>双机热备

配置参数及启动主从库

master上

配置文件master.conf
port=27017
dbpath=/mongodb/master/db
replSet=zxq/127.0.0.1:27018 (zxq为副本名称)
启动：
[root@primary master]# ./mongod --config=/mongodb/master/master.conf --fork

standby上

配置文件standby.conf
port=27018
dbpath=/mongodb/standby/db
replSet=zxq/127.0.0.1:27017 (zxq为副本名称)
启动：
[root@primary standby]# ./mongod --config=/mongodb/standby/standby.conf 

注：
//若是有第三台
port=27019
dbpath=/mongodb/standby/db
replSet=zxq/127.0.0.1:27017,127.0.0.1:27018 (zxq为副本名称)

配置主从同步

建立过程

//链接到主admin库
[root@primary master]# ./mongo 127.0.0.1:27017/admin
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27017/admin
> 
//运行主从同步配置命令
db.runCommand({"replSetInitiate":{ "_id":"zxq", "members":
[ {"_id":1,"host":"127.0.0.1:27017"}, {"_id":2,"host":"127.0.0.1:27018"} ]}})

注：
                 zxq  //副本名称
    "_id":1和"_id":2  //两个节点的节点ID，不能冲突

启动过程日志信息

主节点日志
Thu Aug  4 11:29:11.348 [rsStart] trying to contact 127.0.0.1:27018
Thu Aug  4 11:29:11.385 [rsStart] replSet I am 127.0.0.1:27017     //提示本节点信息
Thu Aug  4 11:29:11.385 [rsStart] replSet STARTUP2
Thu Aug  4 11:29:11.388 [rsMgr] replSet total number of votes is even - add arbiter or give one member an extra vote
Thu Aug  4 11:29:11.390 [rsHealthPoll] replSet member 127.0.0.1:27018 is up  //提示从节点启动 
Thu Aug  4 11:29:12.387 [rsSync] replSet SECONDARY
//从节点日志
Thu Aug  4 11:29:11.408 [rsStart] replSet I am 127.0.0.1:27018
Thu Aug  4 11:29:11.408 [rsStart] replSet got config version 1 from a remote, saving locally
Thu Aug  4 11:29:11.408 [rsStart] replSet info saving a newer config version to local.system.replset
Thu Aug  4 11:29:11.412 [rsStart] replSet saveConfigLocally done
Thu Aug  4 11:29:11.412 [rsStart] replSet STARTUP2
Thu Aug  4 11:29:11.413 [rsMgr] replSet total number of votes is even - add arbiter or give one member an extra vote
Thu Aug  4 11:29:11.467 [rsSync] ******
Thu Aug  4 11:29:11.467 [rsSync] creating replication oplog of size: 2289MB...
Thu Aug  4 11:29:11.467 [FileAllocator] allocating new datafile /mongodb/standby/db/local.1, filling with zeroes...
Thu Aug  4 11:29:11.500 [FileAllocator] done allocating datafile /mongodb/standby/db/local.1, size: 2047MB,  took 0.033 secs 
//从节点接收到主节点的数据
Thu Aug  4 11:29:11.501 [FileAllocator] allocating new datafile /mongodb/standby/db/local.2, filling with zeroes...
Thu Aug  4 11:29:11.531 [FileAllocator] done allocating datafile /mongodb/standby/db/local.2, size: 2047MB,  took

检查主备节点是否生效

> rs.status()
{
"set" : "zxq",
"date" : ISODate("2016-08-04T03:31:25Z"),
"myState" : 1, 
"members" : [
{
"_id" : 1,  //站点ID
"name" : "127.0.0.1:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",  //主节点
"uptime" : 415,
"optime" : Timestamp(1470281344, 1),
"optimeDate" : ISODate("2016-08-04T03:29:04Z"),
"self" : true
},
{
"_id" : 2, //站点ID
"name" : "127.0.0.1:27018",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY", //从节点
"uptime" : 134,
"optime" : Timestamp(1470281344, 1),
"optimeDate" : ISODate("2016-08-04T03:29:04Z"),
"lastHeartbeat" : ISODate("2016-08-04T03:31:25Z"),
"lastHeartbeatRecv" : ISODate("2016-08-04T03:31:25Z"),
"pingMs" : 0,
"syncingTo" : "127.0.0.1:27017"
}
],
"ok" : 1
}

//备用节点
[root@primary standby]# ./mongo 127.0.0.1:27018
MongoDB shell version: 2.4.9
connecting to: 127.0.0.1:27018/test
zxq:SECONDARY> 
zxq:SECONDARY>  //已是备用节点信息

添加仲裁节点

建立vote目录，复制mongod、mongo到目录，并建立db目录

//建立仲裁节点的配置问题
[root@primary vote]# vi vote.conf 
port=27019
dbpath=/mongodb/vote/db

//启动仲裁节点
[root@primary vote]# ./mongod --config=./vote.conf --fork

//在主节点上执行添加仲裁节点的命令
rs.addArb("127.0.0.1:27019")  //告诉主从27019是仲裁节点

仲裁添加完成后日志信息

27019上日志(仲裁节点)
Thu Aug  4 11:41:28.291 [conn3] end connection 127.0.0.1:27460 (2 connections now open)
Thu Aug  4 11:41:28.418 [rsHealthPoll] replSet member 127.0.0.1:27017 is up
Thu Aug  4 11:41:28.418 [rsHealthPoll] replSet member 127.0.0.1:27017 is now in state PRIMARY
//27017为PRIMARY
Thu Aug  4 11:41:28.422 [rsHealthPoll] replSet member 127.0.0.1:27018 is up
Thu Aug  4 11:41:28.422 [rsHealthPoll] replSet member 127.0.0.1:27018 is now in state SECONDARY
//27018为SECONDARY

主库上日志
Thu Aug  4 11:41:28.270 [rsHealthPoll] replset info 127.0.0.1:27019 thinks that we are down
Thu Aug  4 11:41:28.270 [rsHealthPoll] replSet member 127.0.0.1:27019 is up
Thu Aug  4 11:41:28.272 [rsHealthPoll] replSet member 127.0.0.1:27019 is now in state STARTUP2
Thu Aug  4 11:41:30.273 [rsHealthPoll] replSet member 127.0.0.1:27019 is now in state ARBITER
//27019已经正常

切换测试(中止主库)

//关闭主节点服务器进程
Thu Aug  4 11:49:05.375 [rsMgr] replSet info electSelf 2
Thu Aug  4 11:49:05.564 [rsMgr] replSet PRIMARY
Thu Aug  4 11:49:07.287 [rsHealthPoll] replset info 127.0.0.1:27017 heartbeat failed, retrying
Thu Aug  4 11:49:09.291 [rsHealthPoll] replset info 127.0.0.1:27017 heartbeat failed, retrying

//从库变主库
zxq:SECONDARY> 
zxq:PRIMARY> 
zxq:PRIMARY> 

//从库变主库,能够接管业务
zxq:SECONDARY> db.zxq.find()
error: { "$err" : "not master and slaveOk=false", "code" : 13435 }
zxq:PRIMARY> db.zxq.find()
db.zxq.find()
{ "_id" : ObjectId("57a2931b90d8e955cf551d2c"), "name" : "a", "age" : "10" }
{ "_id" : ObjectId("57a293fe90d8e955cf551d2d"), "name" : "b", "age" : "11" }
{ "_id" : ObjectId("57a2bd7106e8981bb7d168ea"), "name" : "c", "age" : "12" }

分片

mongodb采用将集合进行拆分，而后将拆分的数据均摊到几个片上的一种解决方案

mongos就是一个路由服务器，它会根据管理员设置的“片键”将数据分摊到本身管理的mongod集群
数据和片的对应关系以及相应的配置信息保存在”config服务器”上
全部的client请求咱们都是由 mongos去转向的,自己不存留数据

mongod: 一个普通的数据库实例，若是不分片的话，咱们会直接连上mongod。

127.0.0.1:27017  做为 mongos服务器
127.0.0.1:27018  做为 config 服务器
127.0.0.1:28000  做为一个sharing1服务器
127.0.0.1:28001  做为一个sharing2服务器

配置基本服务

开启config服务器

其实就是一个普通的mongod服务。
/mongodb/config/mongod --port=27018 --dbpath=/mongodb/config/db

开启mongos服务

/mongodb/master/mongos --port=27017 configdb=127.0.0.1:27018

开启两个片键

/mongodb/s1/mongod --port=28000 --dbpath=/mongodb/s1/db
/mongodb/s2/mongod --port=28001 --dbpath=/mongodb/s2/db

初始化配置

将要做为“片”的机器放到mongos的config配置中

登陆到mongos
/mongodb/bin/mongo 127.0.0.1:27017
connecting to: 127.0.0.1:27017/test

mongos> use admin
switched to db admin

mongos> db.runCommand({"addshard":"127.0.0.1:28000","allowLocal":true})
    { "shardAdded" : "shard0000", "ok" : 1 }
mongos> db.runCommand({"addshard":"127.0.0.1:28001","allowLocal":true})
    { "shardAdded" : "shard0001", "ok" : 1 }

准备分片文档

必定要在分片以前建立 “片键” 的索引

mongos> use test
switched to db test
mongos>db.zxq.insert({"name":"jack","age":1})
mongos> db.zxq.createIndex({"age":1})
循环插入数据：
for(var i=1;i<10000;i++){db.zxq.insert({"name":"jack"+i,"age":i})}

激活并建立分片

mongos> use admin
switched to db admin
mongos> db.runCommand({"enablesharding":"test"})
mongos> db.runCommand({"shardcollection":"test.zxq","key":{"age":1}})
{ "collectionsharded" : "test.zxq", "ok" : 1 }

查看分片
```
db.shards.find()
```