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 選項。