mongodb的学习-6-命令简单使用

时间 2019-11-09

原文原文链接

1.建立数据库

use DATABASE_NAME

举例说明：前端

> use another //建立了数据库another
switched to db another
> db
another
> show dbs //查看全部数据库，刚建立的数据库 another 没显示，须要插入数据才显示
admin   0.000GB
config  0.000GB
local   0.000GB
> db.another.insert({"name":"hello"}) //往集合another中插入数据，建立了another集合
WriteResult({ "nInserted" : 1 })
> show dbs  //而后就显示了数据库
admin    0.000GB
another  0.000GB
config   0.000GB
local    0.000GB
>

注意: 在 MongoDB 中，集合只有在内容插入后才会建立! 就是说，建立集合(数据表)后要再插入一个文档(记录)，集合才会真正建立。sql

2.删除数据库

db.dropDatabase()

两种方法：mongodb

1)删除集合

> show dbs
admin    0.000GB
another  0.000GB
config   0.000GB
local    0.000GB
> show tables
another
> db.another.drop()
true
> show tables
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB

可见，删除了惟一的tables后，数据库也相应被删除了shell

2)删除数据库

> show dbs
admin    0.000GB
another  0.000GB
config   0.000GB
local    0.000GB
> db.dropDatabase()
{ "dropped" : "another", "ok" : 1 }
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
>

3.建立集合

db.createCollection(name, options)

参数说明：数据库

name: 要建立的集合名称
options: 可选参数, 指定有关内存大小及索引的选项

options 能够是以下参数：json

字段	类型	描述
capped	布尔	（可选）若是为 true，则建立固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会将新添加的文档自动覆盖最先的文档。当该值为 true 时，必须指定 size 参数。
autoIndexId	布尔	（可选）如为 true，自动在 _id 字段建立索引。默认为 false。
size	数值	（可选）为固定集合指定一个最大值（以字节计）。若是 capped 为 true，也须要指定该字段。
max	数值	（可选）指定固定集合中包含文档的最大数量。

在插入文档时，MongoDB 首先检查固定集合的 size 字段，而后检查 max 字段。数组

> use test
switched to db test
> db.createCollection("mycollection", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
{
    "note" : "the autoIndexId option is deprecated and will be removed in a future release",
    "ok" : 1
}
> show collections
mycollection
>

在 MongoDB 中，你不须要建立集合。当你插入一些文档时，MongoDB 会自动建立集合,就跟上面的例子同样：安全

> db.another.insert({"name":"hello"})

4.删除集合

db.collection.drop()

举例：服务器

> show collections
mycollection
> db.mycollection.drop()
true
> show collections
>

5.插入文档

文档的数据结构和JSON基本同样。数据结构

全部存储在集合中的数据都是BSON格式。

BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON。

MongoDB 使用 insert() 或 save() 方法向集合中插入文档：

db.COLLECTION_NAME.insert(document)

能够将数据定义为一个变量：

> show collections
> document=({title: 'MongoDB 教程',    //定义成变量document
... description: 'MongoDB 是一个 Nosql 数据库',
... by: '菜鸟教程',
... url: 'http://www.runoob.com',
... tags: ['mongodb', 'database', 'NoSQL'],
... likes: 100
... });
{
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
> db.col.insert(document)   //col集合不在该数据库中， MongoDB 会自动建立该集合并插入文档
WriteResult({ "nInserted" : 1 })
> show collections //可见生成了集合
col
> db.col.find()
{ "_id" : ObjectId("5c0104a3ddb4050db314b810"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
>

插入文档你也可使用 db.col.save(document) 命令。若是不指定 _id 字段 save() 方法相似于 insert() 方法。若是指定 _id 字段，则会更新该 _id 的数据。

6.更新文档

MongoDB 使用 update() 和 save() 方法来更新集合中的文档

1）update() 方法

update() 方法用于更新已存在的文档。语法格式以下：

db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)

参数说明：

query : update的查询条件，相似sql update查询内where后面的。
update : update的对象和一些更新的操做符（如$,$inc...）等，也能够理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，若是不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，若是这个参数为true,就把按条件查出来多条记录所有更新。
writeConcern :可选，抛出异常的级别。

接着上面的例子，经过 update() 方法来更新标题(title):

> db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 }) //输出信息
> db.col.find().pretty()
{
    "_id" : ObjectId("5c0104a3ddb4050db314b810"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
>

以上语句只会修改第一条发现的文档，若是你要修改多条相同的文档，则须要设置 multi 参数为 true

2）save() 方法

save() 方法经过传入的文档来替换已有文档。语法格式以下：

db.collection.save(
   <document>,
   {
     writeConcern: <document>
   }
)

参数说明：

document : 文档数据。
writeConcern :可选，抛出异常的级别。

> db.col.save({
...     "_id" : ObjectId("5c0104a3ddb4050db314b810"),
... "title" : "MongoDB",
... "description" : "MongoDB 是一个 Nosql 数据库",
... "by" : "菜鸟教程",
... "url" : "http://www.runoob.com",
... "tags" : [
... "mongodb",
... "database",
... "NoSQL"
... ],
... "likes" : 120 //将以前生成的文档的likes改为120
... });
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.col.find().pretty()
{
    "_id" : ObjectId("5c0104a3ddb4050db314b810"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 120
}
>

7.删除文档

MongoDB remove()函数是用来移除集合中的数据。

MongoDB数据更新可使用update()函数。

在执行remove()函数前先执行find()命令来判断执行的条件是否正确，这是一个比较好的习惯。

语法

remove() 方法的基本语法格式以下所示：

db.collection.remove(
   <query>,
   <justOne>
)

若是你的 MongoDB 是 2.6 版本之后的，语法格式以下：

db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

参数说明：

query :（可选）删除的文档的条件。
justOne : （可选）若是设为 true 或 1，则只删除一个文档，若是不设置该参数，或使用默认值 false，则删除全部匹配条件的文档。
writeConcern :（可选）抛出异常的级别。

举例：

> db.col.find().pretty()
{
    "_id" : ObjectId("5c0104a3ddb4050db314b810"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 120
}
{
    "_id" : ObjectId("5c0107d4ddb4050db314b811"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
{
    "_id" : ObjectId("5c0107e3ddb4050db314b812"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
{
    "_id" : ObjectId("5c010807ddb4050db314b813"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
> db.col.remove({'title':'MongoDB 教程'},1) //只删除一个，因此下面还剩两个
WriteResult({ "nRemoved" : 1 })
> db.col.find().pretty()
{
    "_id" : ObjectId("5c0104a3ddb4050db314b810"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 120
}
{
    "_id" : ObjectId("5c0107e3ddb4050db314b812"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
{
    "_id" : ObjectId("5c010807ddb4050db314b813"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
> db.col.remove({'title':'MongoDB 教程'}) //删除所有
WriteResult({ "nRemoved" : 2 })
> db.col.find().pretty()
{
    "_id" : ObjectId("5c0104a3ddb4050db314b810"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "菜鸟教程",
    "url" : "http://www.runoob.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 120
}
>

remove() 方法并不会真正释放空间。

须要继续执行 db.repairDatabase() 来回收磁盘空间。

> db.repairDatabase()
或者
> db.runCommand({ repairDatabase: 1 })

⚠️remove() 方法已通过时了，如今官方推荐使用 deleteOne() 和 deleteMany() 方法。

删除 status 等于 A 的所有文档：

db.col.deleteMany({ status : "A" })

删除 status 等于 D 的一个文档：

db.col.deleteOne( { status: "D" } )

8.查询文档(上面的例子)

MongoDB 查询文档使用 find() 方法。

find() 方法以非结构化的方式来显示全部文档。

语法

MongoDB 查询数据的语法格式以下：

db.collection.find(query, projection)

query ：可选，使用查询操做符指定查询条件
projection ：可选，使用投影操做符指定返回的键。查询时返回文档中全部键值，只需省略该参数便可（默认省略）。

若是你须要以易读的方式来读取数据，可使用 pretty() 方法，语法格式以下：

>db.col.find().pretty()

pretty() 方法以格式化的方式来显示全部文档。

MongoDB 与 RDBMS Where 语句比较

若是你熟悉常规的 SQL 数据，经过下表能够更好的理解 MongoDB 的条件语句查询：

操做	格式	范例	RDBMS中的相似语句
等于	`{<key>:<value>`}	`db.col.find({"by":"菜鸟教程"}).pretty()`	`where by = '菜鸟教程'`
小于	`{<key>:{$lt:<value>}}`	`db.col.find({"likes":{$lt:50}}).pretty()`	`where likes < 50`
小于或等于	`{<key>:{$lte:<value>}}`	`db.col.find({"likes":{$lte:50}}).pretty()`	`where likes <= 50`
大于	`{<key>:{$gt:<value>}}`	`db.col.find({"likes":{$gt:50}}).pretty()`	`where likes > 50`
大于或等于	`{<key>:{$gte:<value>}}`	`db.col.find({"likes":{$gte:50}}).pretty()`	`where likes >= 50`
不等于	`{<key>:{$ne:<value>}}`	`db.col.find({"likes":{$ne:50}}).pretty()`	`where likes != 50`

MongoDB AND 条件

MongoDB 的 find() 方法能够传入多个键(key)，每一个键(key)以逗号隔开，即常规 SQL 的 AND 条件。

语法格式以下：

>db.col.find({key1:value1, key2:value2}).pretty()

相似于 WHERE 语句：WHERE key1=value1 AND key2=value2

MongoDB OR 条件

MongoDB OR 条件语句使用了关键字 $or,语法格式以下：

>db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

AND 和 OR 联合使用

如下实例演示了 AND 和 OR 联合使用，相似常规 SQL 语句为： 'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'

>db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}

9.条件操做符

描述

条件操做符用于比较两个表达式并从mongoDB集合中获取数据。

在本章节中，咱们将讨论如何在MongoDB中使用条件操做符。

MongoDB中条件操做符有：

(>) 大于 - $gt
(<) 小于 - $lt
(>=) 大于等于 - $gte
(<= ) 小于等于 - $lte

MongoDB (>) 大于操做符 - $gt

若是你想获取 "col" 集合中 "likes" 大于 100 的数据，你可使用如下命令：

db.col.find({likes : {$gt : 100}})

相似于SQL语句：

Select * from col where likes > 100;

MongoDB（>=）大于等于操做符 - $gte

若是你想获取"col"集合中 "likes" 大于等于 100 的数据，你可使用如下命令：

db.col.find({likes : {$gte : 100}})

相似于SQL语句：

Select * from col where likes >=100;

MongoDB (<) 小于操做符 - $lt

若是你想获取"col"集合中 "likes" 小于 150 的数据，你可使用如下命令：

db.col.find({likes : {$lt : 150}})

相似于SQL语句：

Select * from col where likes < 150;

MongoDB (<=) 小于操做符 - $lte

若是你想获取"col"集合中 "likes" 小于等于 150 的数据，你可使用如下命令：

db.col.find({likes : {$lte : 150}})

相似于SQL语句：

Select * from col where likes <= 150;

MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt

若是你想获取"col"集合中 "likes" 大于100，小于 200 的数据，你可使用如下命令：

db.col.find({likes : {$lt :200, $gt : 100}})

相似于SQL语句：

Select * from col where likes>100 AND  likes<200;

总结：

$gt -------- greater than  >

$gte --------- gt equal  >=

$lt -------- less than  <

$lte --------- lt equal  <=

$ne ----------- not equal  !=

$eq  --------  equal  =

模糊查询

查询 title 包含"教"字的文档：

db.col.find({title:/教/})

查询 title 字段以"教"字开头的文档：

db.col.find({title:/^教/})

查询 titl e字段以"教"字结尾的文档：

db.col.find({title:/教$/})

10.$type 操做符

$type操做符是基于BSON（二进制json）类型来检索集合中匹配的数据类型，并返回结果。

MongoDB 中可使用的类型以下表所示：

类型	数字	备注
Double	1
String	2
Object	3
Array	4
Binary data	5
Undefined	6	已废弃。
Object id	7
Boolean	8
Date	9
Null	10
Regular Expression	11
JavaScript	13
Symbol	14
JavaScript (with scope)	15
32-bit integer	16
Timestamp	17
64-bit integer	18
Min key	255	Query with `-1`.
Max key	127

MongoDB 操做符 - $type 实例

若是想获取 "col" 集合中 title 为 String(数字表示为2) 的数据，你可使用如下命令：

db.col.find({"title" : {$type : 2}})
或
db.col.find({"title" : {$type : 'string'}})

11.Limit与Skip方法

1）MongoDB Limit() 方法

若是你须要在MongoDB中读取指定数量的数据记录，可使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。

语法

limit()方法基本语法以下所示：

>db.COLLECTION_NAME.find().limit(NUMBER)

注：若是大家没有指定limit()方法中的参数则显示集合中的全部数据。

2）MongoDB Skip() 方法

咱们除了可使用limit()方法来读取指定数量的数据外，还可使用skip()方法来跳过指定数量的数据，skip方法一样接受一个数字参数做为跳过的记录条数。

语法

skip() 方法脚本语法格式以下：

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

跳过第一条数据并只读一条数据，即读取第二条数据

12.排序

MongoDB sort() 方法

在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法能够经过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

语法

sort()方法基本语法以下所示：

>db.COLLECTION_NAME.find().sort({KEY:1})

即对集合COLLECTION_NAME中的数据按字段KEY的值升序排序

13.索引

索引一般可以极大的提升查询的效率，若是没有索引，MongoDB在读取数据时必须扫描集合中的每一个文件并选取那些符合查询条件的记录。

这种扫描全集合的查询效率是很是低的，特别在处理大量的数据时，查询能够要花费几十秒甚至几分钟，这对网站的性能是很是致命的。

索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构

createIndex() 方法

MongoDB使用 createIndex() 方法来建立索引。

语法

createIndex()方法基本语法格式以下所示：

>db.collection.createIndex(keys, options)

语法中 Key 值为你要建立的索引字段，1 为指定按升序建立索引，若是你想按降序来建立索引指定为 -1 便可。

实例

> db.mycollection.createIndex({"title":1})
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 2,
    "ok" : 1
}

由于以前有一个默认索引为_id，在这里又添加了一个索引，因此如今索引又两个

客户端查看索引：

> db.mycollection.getIndexes()
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "mydatabase.mycollection"
    },
    {
        "v" : 2,
        "key" : {
            "title" : 1
        },
        "name" : "title_1",
        "ns" : "mydatabase.mycollection"
    }
]

更多索引操做，可看https://blog.csdn.net/salmonellavaccine/article/details/53907535

keys为{"title":1}，即设置title字段为索引字段，并按升序建立

createIndex() 方法中你也能够设置使用多个字段建立索引（关系型数据库中称做复合索引）。

>db.col.createIndex({"title":1,"description":-1})

⚠️在 3.0.0 版本前建立索引方法为 db.collection.ensureIndex()，以后的版本使用了db.collection.createIndex() 方法，ensureIndex() 还能用，但只是 createIndex() 的别名。

createIndex() 接收可选参数options，可选参数列表以下：

Parameter	Type	Description
background	Boolean	建索引过程会阻塞其它数据库操做，background可指定之后台方式建立索引，即增长 "background" 可选参数。 "background" 默认值为false。
unique	Boolean	创建的索引是否惟一。指定为true建立惟一索引。默认值为false.
name	string	索引的名称。若是未指定，MongoDB的经过链接索引的字段名和排序顺序生成一个索引名称。
dropDups	Boolean	3.0+版本已废弃。在创建惟一索引时是否删除重复记录,指定 true 建立惟一索引。默认值为 false.
sparse	Boolean	对文档中不存在的字段数据不启用索引；这个参数须要特别注意，若是设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false.
expireAfterSeconds	integer	指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。
v	index version	索引的版本号。默认的索引版本取决于mongod建立索引时运行的版本。
weights	document	索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其余索引字段的得分权重。
default_language	string	对于文本索引，该参数决定了停用词及词干和词器的规则的列表。默认为英语
language_override	string	对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language.

实例

在后台建立索引：

db.values.createIndex({open: 1, close: 1}, {background: true})

经过在建立索引时加 background:true 的选项，让建立工做在后台执行

14.聚合

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点相似sql语句中的 count(*)。

aggregate() 方法

MongoDB中聚合的方法使用aggregate()。

语法

aggregate() 方法的基本语法格式以下所示：

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

实例

集合中的数据以下：

{
   _id: ObjectId(7df78ad8902c)
   title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
},
{
   _id: ObjectId(7df78ad8902d)
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
},
{
   _id: ObjectId(7df78ad8902e)
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
},

如今咱们经过以上集合计算每一个做者所写的文章数，使用aggregate()计算结果以下：

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "runoob.com",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

即设置返回结果的输出形式为{_id : "", num_tutorial : }，_id设置用于依据分类的字段，而后使用{$sum : 1}计算这些数据的数量纪录在num_tutorial

以上实例相似sql语句：

 select by_user, count(*) from mycol group by by_user

在上面的例子中，咱们经过字段 by_user 字段对数据进行分组，并计算 by_user 字段相同值的总和。

下表展现了一些聚合的表达式:

表达式	描述	实例
$sum	计算总和。	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : "$likes"}}}])
$avg	计算平均值	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$avg : "$likes"}}}])
$min	获取集合中全部文档对应值得最小值。	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$min : "$likes"}}}])
$max	获取集合中全部文档对应值得最大值。	db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$max : "$likes"}}}])
$push	在结果文档中插入值到一个数组中。	db.mycol.aggregate([{$group : {_id : "$by_user", url : {$push: "$url"}}}])
$addToSet	在结果文档中插入值到一个数组中，但不建立副本。	db.mycol.aggregate([{$group : {_id : "$by_user", url : {$addToSet : "$url"}}}])
$first	根据资源文档的排序获取第一个文档数据。	db.mycol.aggregate([{$group : {_id : "$by_user", first_url : {$first : "$url"}}}])
$last	根据资源文档的排序获取最后一个文档数据	db.mycol.aggregate([{$group : {_id : "$by_user", last_url : {$last : "$url"}}}])

管道的概念

管道在Unix和Linux中通常用于将当前命令的输出结果做为下一个命令的参数。

MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操做是能够重复的。

表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

这里咱们介绍一下聚合框架中经常使用的几个操做：

$project：修改输入文档的结构。能够用来重命名、增长或删除域，也能够用于建立计算结果以及嵌套文档。
$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操做。
$limit：用来限制MongoDB聚合管道返回的文档数。
$skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind：将文档中的某一个数组类型字段拆分红多条，每条包含数组中的一个值。
$group：将集合中的文档分组，可用于统计结果。
$sort：将输入文档排序后输出。
$geoNear：输出接近某一地理位置的有序文档。

管道操做符实例

一、$project实例

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );

这样的话结果中就只还有_id,tilte和author三个字段了，默认状况下_id字段是被包含的，若是要想不包含_id话能够这样:

db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

2.$match实例

db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );

$match用于获取分数大于70小于或等于90记录，而后将符合条件的记录送到下一阶段$group管道操做符进行处理。

3.$skip实例

db.article.aggregate(
    { $skip : 5 });

通过$skip管道操做符处理后，前五个文档被"过滤"掉。

15.复制（副本集）

MongoDB复制是将数据同步在多个服务器的过程。

复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提升了数据的可用性，并能够保证数据的安全性。

复制还容许您从硬件故障和服务中断中恢复数据。

什么是复制?

保障数据的安全性
数据高可用性 (24*7)
灾难恢复
无需停机维护（如备份，重建索引，压缩）
分布式读取数据

MongoDB复制原理

mongodb的复制至少须要两个节点。其中一个是主节点，负责处理客户端请求，其他的都是从节点，负责复制主节点上的数据。

mongodb各个节点常见的搭配方式为：一主一从、一主多从。

主节点记录在其上的全部操做oplog，从节点按期轮询主节点获取这些操做，而后对本身的数据副本执行这些操做，从而保证从节点的数据与主节点一致。

副本集特征：

N 个节点的集群
任何节点可做为主节点
全部写入操做都在主节点上
自动故障转移
自动恢复

MongoDB副本集设置

在本教程中咱们使用同一个MongoDB来作MongoDB主从的实验，操做步骤以下：

一、关闭正在运行的MongoDB服务器。

如今咱们经过指定 --replSet 选项来启动mongoDB。--replSet 基本语法格式以下：

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"

实例

mongod --port 27017 --dbpath "/data/db" --replSet rs0

以上实例会启动一个名为rs0的MongoDB实例，其端口号为27017的服务器。

启动后打开命令提示框，运行mongo命令来链接上mongoDB服务器。

在Mongo客户端使用命令rs.initiate()来启动一个新的副本集。

咱们可使用rs.conf()来查看副本集的配置

查看副本集状态使用 rs.status() 命令

副本集添加成员

添加副本集的成员，咱们须要使用多台服务器来启动mongo服务。进入Mongo客户端，并使用rs.add()方法来添加副本集的成员。

语法

rs.add() 命令基本语法格式以下：

>rs.add(HOST_NAME:PORT)

实例

假设你已经启动了一个名为mongod1.net，端口号为27017的Mongo服务。在客户端命令窗口使用rs.add() 命令将其添加到副本集中，命令以下所示：

>rs.add("mongod1.net:27017")
>

MongoDB中你只能经过主节点将Mongo服务添加到副本集中

判断当前运行的Mongo服务是否为主节点可使用命令db.isMaster()

⚠️MongoDB的副本集与咱们常见的主从有所不一样，主从在主机宕机后全部服务将中止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的状况。

16.分片

在Mongodb里面存在另外一种集群，就是分片技术,能够知足MongoDB数据量大量增加的需求。

当MongoDB存储海量的数据时，一台机器可能不足以存储数据，也可能不足以提供可接受的读写吞吐量。这时，咱们就能够经过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。

为何使用分片

复制全部的写入操做到主节点
延迟的敏感数据会在主节点查询
单个副本集限制在12个节点
当请求量巨大时会出现内存不足。
本地磁盘不足
垂直扩展价格昂贵

MongoDB分片

下图展现了在MongoDB中使用分片集群结构分布：

上图中主要有以下所述三个主要组件：

Shard:
用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障
Config Server:
mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。
Query Routers:
前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用能够透明使用。

分片实例

分片结构端口分布以下：

Shard Server 1：27020 //4个分片，存储数据
Shard Server 2：27021
Shard Server 3：27022
Shard Server 4：27023
Config Server ：27100 //服务器配置
Route Process：40000 //路由

步骤一：启动Shard Server

[root@100 /]# mkdir -p /www/mongoDB/shard/s0
[root@100 /]# mkdir -p /www/mongoDB/shard/s1
[root@100 /]# mkdir -p /www/mongoDB/shard/s2
[root@100 /]# mkdir -p /www/mongoDB/shard/s3
[root@100 /]# mkdir -p /www/mongoDB/shard/log
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
....
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork

步骤二：启动Config Server

[root@100 /]# mkdir -p /www/mongoDB/shard/config
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork

注意：这里咱们彻底能够像启动普通mongodb服务同样启动，不须要添加—shardsvr和configsvr参数。由于这两个参数的做用就是改变启动端口的，因此咱们自行指定了端口就能够。

步骤三：启动Route Process

/usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500

mongos启动参数中，chunkSize这一项是用来指定chunk的大小的，单位是MB，默认大小为200MB.

步骤四：配置Sharding

接下来，咱们使用MongoDB Shell登陆到mongos（路由器，经过路由器来连接数据库），而后将四个Shard节点添加进来

[root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
MongoDB shell version: 2.0.7
connecting to: 127.0.0.1:40000/admin
mongos> db.runCommand({ addshard:"localhost:27020" })
{ "shardAdded" : "shard0000", "ok" : 1 }
......
mongos> db.runCommand({ addshard:"localhost:27029" })
{ "shardAdded" : "shard0009", "ok" : 1 }
mongos> db.runCommand({ enablesharding:"test" }) #设置分片存储的数据库
{ "ok" : 1 }
mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})
{ "collectionsharded" : "test.log", "ok" : 1 }

步骤五：程序代码内无需太大更改，直接按照链接普通的mongo数据库那样，将数据库链接接入接口40000

另外一个例子（有空测一下）：

1. 建立Sharding复制集 rs0

# mkdir /data/log
# mkdir /data/db1
# nohup mongod --port 27020 --dbpath=/data/db1 --logpath=/data/log/rs0-1.log --logappend --fork --shardsvr --replSet=rs0 &

# mkdir /data/db2
# nohup mongod --port 27021 --dbpath=/data/db2 --logpath=/data/log/rs0-2.log --logappend --fork --shardsvr --replSet=rs0 &

1.1 复制集rs0配置

# mongo localhost:27020 > rs.initiate({_id: 'rs0', members: [{_id: 0, host: 'localhost:27020'}, {_id: 1, host: 'localhost:27021'}]}) 
> rs.isMaster() #查看主从关系

2. 建立Sharding复制集 rs1

# mkdir /data/db3
# nohup mongod --port 27030 --dbpath=/data/db3 --logpath=/data/log/rs1-1.log --logappend --fork --shardsvr --replSet=rs1 &
# mkdir /data/db4
# nohup mongod --port 27031 --dbpath=/data/db4 --logpath=/data/log/rs1-2.log --logappend --fork --shardsvr --replSet=rs1 &

2.1 复制集rs1配置

# mongo localhost:27030
> rs.initiate({_id: 'rs1', members: [{_id: 0, host: 'localhost:27030'}, {_id: 1, host: 'localhost:27031'}]})
> rs.isMaster() #查看主从关系

3. 建立Config复制集 conf

# mkdir /data/conf1
# nohup mongod --port 27100 --dbpath=/data/conf1 --logpath=/data/log/conf-1.log --logappend --fork --configsvr --replSet=conf &
# mkdir /data/conf2
# nohup mongod --port 27101 --dbpath=/data/conf2 --logpath=/data/log/conf-2.log --logappend --fork --configsvr --replSet=conf &

3.1 复制集conf配置

# mongo localhost:27100
> rs.initiate({_id: 'conf', members: [{_id: 0, host: 'localhost:27100'}, {_id: 1, host: 'localhost:27101'}]})
> rs.isMaster() #查看主从关系

4. 建立Route

# nohup mongos --port 40000 --configdb conf/localhost:27100,localhost:27101 --fork --logpath=/data/log/route.log --logappend &

4.1 设置分片

# mongo localhost:40000
> use admin
> db.runCommand({ addshard: 'rs0/localhost:27020,localhost:27021'})
> db.runCommand({ addshard: 'rs1/localhost:27030,localhost:27031'})
> db.runCommand({ enablesharding: 'test'})
> db.runCommand({ shardcollection: 'test.user', key: {name: 1}})

17.备份(mongodump)与恢复(mongorestore)

1）MongoDB数据备份

在Mongodb中咱们使用mongodump命令来备份MongoDB数据。该命令能够导出全部数据到指定目录中。

mongodump命令能够经过参数指定导出的数据量级转存的服务器。

语法

mongodump命令脚本语法以下：

>mongodump -h dbhost -d dbname -o dbdirectory

-h：
MongDB所在服务器地址，例如：127.0.0.1，固然也能够指定端口号：127.0.0.1:27017
-d：
须要备份的数据库实例，例如：test
-o：
备份的数据存放位置，例如：c:\data\dump，固然该目录须要提早创建，在备份完成后，系统自动在dump目录下创建一个test目录，这个目录里面存放该数据库实例的备份数据。

mongodump 命令可选参数列表以下所示：

语法	描述	实例
mongodump --host HOST_NAME --port PORT_NUMBER	该命令将备份全部MongoDB数据	mongodump --host runoob.com --port 27017
mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY		mongodump --dbpath /data/db/ --out /data/backup/
mongodump --collection COLLECTION --db DB_NAME	该命令将备份指定数据库的集合。	mongodump --collection mycol --db test

2）MongoDB数据恢复

mongodb使用 mongorestore 命令来恢复备份的数据。

语法

mongorestore命令脚本语法以下：

>mongorestore -h <hostname><:port> -d dbname <path>

--host <:port>, -h <:port>：
MongoDB所在服务器地址，默认为： localhost:27017
--db , -d ：
须要恢复的数据库实例，例如：test，固然这个名称也能够和备份时候的不同，好比test2
--drop：
恢复的时候，先删除当前数据，而后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，慎用哦！
<path>：
mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。

你不能同时指定 <path> 和 --dir 选项，--dir也能够设置备份目录。
--dir：
指定备份的目录

你不能同时指定 <path> 和 --dir 选项。

18.监控

在你已经安装部署并容许MongoDB服务后，你必需要了解MongoDB的运行状况，并查看MongoDB的性能。这样在大流量得状况下能够很好的应对并保证MongoDB正常运做。

MongoDB中提供了mongostat 和 mongotop 两个命令来监控MongoDB的运行状况。

1）mongostat 命令

mongostat是mongodb自带的状态检测工具，在命令行下直接使用。

它会间隔固定时间获取mongodb的当前运行状态，并输出。若是你发现数据库忽然变慢或者有其余问题的话，你第一手的操做就考虑采用mongostat来查看mongo的状态。

2）mongotop 命令

mongotop也是mongodb下的一个内置工具，mongotop提供了一个方法，用来跟踪一个MongoDB的实例，查看哪些大量的时间花费在读取和写入数据，在命令行下直接使用

mongotop提供每一个集合的水平的统计数据。默认状况下，mongotop每一秒返回一次数据。

>mongotop 10

后面的10是<sleeptime>参数，能够不使用，等待的时间长度，以秒为单位，即mongotop没10秒返回数据

mongotop --locks

报告每一个数据库的锁的使用

输出结果字段说明：

ns：
包含数据库命名空间，后者结合了数据库名称和集合。
db：

包含数据库的名称。名为 . 的数据库针对全局锁定，而非特定数据库。
total：

mongod花费的时间工做在这个命名空间提供总额。
read：

提供了大量的时间，这mongod花费在执行读操做，在此命名空间。
write：

提供这个命名空间进行写操做，这mongod花了大量的时间。

mongodb的学习-6-命令简单使用

1.建立数据库

2.删除数据库

1)删除集合

2)删除数据库

3.建立集合

4.删除集合

5.插入文档

6.更新文档

1）update() 方法

2）save() 方法

更多实例

7.删除文档

语法

8.查询文档(上面的例子)

语法

MongoDB 与 RDBMS Where 语句比较

MongoDB AND 条件

MongoDB OR 条件

AND 和 OR 联合使用

9.条件操做符

描述

MongoDB (>) 大于操做符 - $gt

MongoDB（>=）大于等于操做符 - $gte

MongoDB (<) 小于操做符 - $lt

MongoDB (<=) 小于操做符 - $lte

MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt

10.$type 操做符

MongoDB 操做符 - $type 实例

11.Limit与Skip方法

1）MongoDB Limit() 方法

语法

2）MongoDB Skip() 方法

语法

12.排序

MongoDB sort() 方法

语法

13.索引

createIndex() 方法

语法

实例

实例

14.聚合

aggregate() 方法

语法

实例

管道的概念

管道操做符实例

15.复制（副本集）

什么是复制?

MongoDB复制原理

副本集特征：

MongoDB副本集设置

实例

副本集添加成员

语法

实例

16.分片

为何使用分片

MongoDB分片

分片实例

另外一个例子（有空测一下）：

17.备份(mongodump)与恢复(mongorestore)

1）MongoDB数据备份

语法

2）MongoDB数据恢复

语法

18.监控

1）mongostat 命令

2）mongotop 命令