1. MongoDB中數據查詢的方法
（1）find函數的使用；
（2）條件操作符；
（3）distinct找出給定鍵所有不同的值；
（4）group分組；
（5）游標；
（6）存儲過程。
文檔查找
1.數據准備，find函數（）
var persons = [{
name:"jim",
age:25,
email:"75431457@qq.com",
c:89,m:96,e:87,
country:"USA",
books:["JS","C++","EXTJS","MONGODB"],
address:{city:"beijing",street:"861 Park Street"}
}......
數組中有12個文檔(文檔中有很多類型)
persons
show collections --查詢集合中有沒有student
db.student.drop() --先刪除
db.student.insert(persons) --再添加
db.student.count()
2.查詢所有的記錄
db.student.find()
db.student.find({})
find()的語法介紹
db.collection.find(query, projection)
query ：可選，使用查詢操作符指定查詢條件
projection ：可選，使用投影操作符指定返回的鍵。查詢時返回文檔中所有鍵值， 只需省略該參數即可（默認省略）。
3.投影操作,即是列的操作
db.student.find({},{_id:0}) 0代表是不顯示 1代表顯示
db.student.find({},{_id:0,name:1})
db.student.find({},{_id:0,name:1,age:1})
要么寫想要的字段，要么寫不想要的字段，最好不要混合寫
db.student.find({},{name:1,age:1})
db.student.find({},{_id:0,name:0,age:0})
db.student.find({},{age:0,name:1}) --混合寫出錯
db.student.find({},{_id:1,name:0}) --混合寫出錯
- 條件操作符；
MongoDB中條件操作符有：
(>) 大於 - $gt
(<) 小於 - $lt
(>=) 大於等於 - $gte
(<= ) 小於等於 - $lte
查詢出年齡在25到27歲之間的學生
db.student.find({age:{$gte:25,$lte:27}})
db.student.find({age:{$gte:25,$lte:27}},{_id:0,name:1,age:1})
II.查詢出所有不是韓國籍的學生
db.student.find({country:{$ne:"Korea"}})
db.student.find({country:{$ne:"Korea"}},{_id:0,name:1,country:1})
（2）包含或不包含
$in或$nin
I.查詢國籍是中國或美國的學生信息
db.student.find({country:{$in:["USA","China"]}},{_id:0,name:1,country:1})
II.查詢國籍不是中國或美國的學生信息
db.student.find({country:{$nin:["USA","China"]}},{_id:0,name:1,country:1})
5.邏輯運算符
$and
I.查詢語文成績大於85並且英語大於90的學生信息
db.student.find({$and:[{c:{$gte:85}},{e:{$gte:90}}]})
$or
II.查詢語文成績大於85或者英語大於90的學生信息
db.student.find({$or:[{c:{$gte:85}},{e:{$gte:90}}]})
$not的使用
III.查詢出名字中不存在”li”的學生的信息
db.student.find({name:{$not:/li/i}},{_id:0,name:1})
可先查詢名字的值為li並不區分大小寫
db.student.find({name:/li/i})
6.元素查詢操作符
$exists
I.查詢地址存在的學生信息
db.student.find({address:{$exists:true}})
db.student.find({address:{$exists:false}})無地址
II.查詢年齡為空值的學生信息
db.student.find({age:null})或
db.student.find({age:{$type:10}})
7.內嵌文檔查詢
db.student.find({address:{city:"beijing",street:"861 Park Street"}})
db.student.find({"address.city":"beijing"})
8.數組查詢
db.student.find({books:["JS","C#","EXTJS","MONGODB"]})
db.student.find({books:"JS"}) 只要books中有JS
db.student.find({"books.3":"PHP"}) books第三個元素的值為PHP
db.student.find({books:{$all:["PHP","JS"]}}) 只要books中有PHP和JS
db.student.find({},{books:{$slice:[1,2]}}) --跳過數組里面的第一個元素，返回兩個元素
- distinct找出給定鍵所有不同的值，並以數組形式返回
語法：
db.collection_name.distinct(field,query,options)
field -----指定要返回的字段(string)
query-----條件查詢(document)
options-----其他的選項(document)
options
{ collation: <document> }
collation: {
locale: <string>,
caseLevel: <boolean>,
caseFirst: <string>,
strength: <int>,
numericOrdering: <boolean>,
alternate: <string>,
maxVariable: <string>,
backwards: <boolean>
}
示例集合與文檔：
> db.inventory.distinct(“dept”) //獲取dept字段的不重復值
> db.inventory.distinct(“item.sku”) //獲取item子字段sku的不重復值
>db.inventory.distinct(“sizes”) //獲取數組格式字段的不重復值
>db.inventory.distinct(“item.sku”,{dept:”A”}) //滿足dept為A數據的item字段的子字段的不重復值
4 group分組；
MongoDB中聚合(aggregate)主要用於處理數據(諸如統計平均值,求和等)，並返回計算后的數據結果。有點類似sql語句中的 count(*)
語法：
>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
數據准備：
var info = [{
title: 'MongoDB Overview',
description: 'MongoDB is no sql database',
by_user: 'runoob.com',
url: 'http://www.runoob.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
},
{
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
},
{
title: 'Neo4j Overview',
description: 'Neo4j is no sql database',
by_user: 'Neo4j',
url: 'http://www.neo4j.com',
tags: ['neo4j', 'database', 'NoSQL'],
likes: 750
}]
一些聚合表達式：
| 表達式 |
描述 |
實例 |
| $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：輸出接近某一地理位置的有序文檔。
管道操作符實例
1、$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管道操作符處理后，前五個文檔被"過濾"掉。
5游標；
游標查詢
var cursor = db.student.find({})
cursor.count()
cursor.hasNext()
cursor.next()
cursor.toArray()
循環遍歷
while(cursor.hasNext()){
printjson(cursor.next())
}
10.模糊查詢
使用正則表達式
db.student.find({name:{$regex:/l/}},{_id:0,name:1})
db.student.find({name:{$regex:/l/i}},{_id:0,name:1})
db.student.find({name:{$regex:/^l/i}},{_id:0,name:1})
db.student.find({name:/^l/i},{_id:0,name:1})
11.查詢結果排序
db.student.find({},{_id:0,name:1,age:1}).sort({age:1}) age升序
db.student.find({},{_id:0,name:1,age:1}).sort({age:-1}) age降序
db.student.find({},{_id:0,name:1,age:1}).sort({name:-1,age:1})name降序age升序
12.limit 返回結果集中的前幾個
db.student.find({},{_id:0,name:1,age:1}) 查所有的
a.使用第三個參數
db.student.find({},{_id:0,name:1,age:1},2) 只顯示前兩行
b.使用limit()函數
db.student.find({},{_id:0,name:1,age:1}).limit(2) 只顯示前兩行
13.skip 跳過一定數量
a.使用第四個參數
db.student.find({},{_id:0,name:1,age:1},2,3) 跳過前三行，顯示前兩行
b.使用skip()函數
db.student.find({},{_id:0,name:1,age:1},2).skip(3) 跳過前三行，顯示前兩行
*利用limit()和skip()實現分頁技術
db.student.find({},{_id:0,name:1,age:1})
第一頁 db.student.find({},{_id:0,name:1,age:1}).limit(3).skip(0)
第二頁 db.student.find({},{_id:0,name:1,age:1}).limit(3).skip(3)
第三頁 db.student.find({},{_id:0,name:1,age:1}).limit(3).skip(6)
第四頁 db.student.find({},{_id:0,name:1,age:1}).limit(3).skip(9)
每頁三行
6存儲過程。
MongoDB支持存儲過程的使用，它的存儲過程是用javascript實現的，被存在於system.js表中，可以接收和輸出參數，返回執行存儲過程的狀態值，也可以嵌套調用。
所以我理解的MongoDB的存儲過程就是：
把javascript變量，存儲到MongoDB的數據庫的特殊集合:system.js表中,然后這些變量可以在何MongoDB的javascript上下文中調用,包括"$where"子句,db.eval調用,MapReduce作業。
2. MongoDB中索引及其創建；
（1）基礎索引、文檔索引；
（3）組合索引；
（4）唯一索引；
（5）強制使用索引；
（6）擴展索引；
（7）刪除索引；
（8）explain執行計划。
一、索引
為什么使用索引？
索引（Index）是幫助數據庫高效獲取數據的數據結構。
建立索引的目的：用來加快查詢速度，提高查詢效率。
例：db.person.insert({name:"jack",age:19})
db.person.insert({name:"rose",age:20})
db.person.insert({name:"jack",age:18})
db.person.insert({name:"tony",age:21})
db.person.insert({name:"adam",age:18})
db.person.find()查詢person集合下的所有文檔
當往某各個集合插入多個文檔后，每個文檔在經過底層的存儲引擎持久化后，會有一個位置信息，通過這個位置信息，就能從存儲引擎里讀出該文檔。比如上面的例子里，person集合里包含插入了5個文檔，假設其存儲后位置信息如下(為方便描述，文檔省去_id字段)
位置信息 文檔
pos1 {“name” : “jack”, “age” : 19 }
pos2 {“name” : “rose”, “age” : 20 }
pos3 {“name” : “jack”, “age” : 18 }
pos4 {“name” : “tony”, “age” : 21}
pos5 {“name” : “adam”, “age” : 18}
假設現在有個查詢 db.person.find({age: 18}), 查詢所有年齡為18歲的人，這時需要遍歷所有的文檔（『全表掃描』），根據位置信息讀出文檔，對比age字段是否為18。當然如果只有4個文檔，全表掃描的開銷並不大，但如果集合文檔數量到百萬、甚至千萬上億的時候，對集合進行全表掃描開銷是非常大的，一個查詢耗費數十秒甚至幾分鍾都有可能。
如果想加速 db.person.find({age: 18}），就可以考慮對person表的age字段建立索引。方法為：db.person.createIndex({age: 1}) // 按age字段創建升序索引
建立索引后，MongoDB會額外存儲一份按age字段升序排序的索引數據，索引結構類似如下，索引通常采用類似btree的結構持久化存儲，以保證從索引里快速（O(logN)的時間復雜度）找出某個age值對應的位置信息，然后根據位置信息就能讀取出對應的文檔。
AGE 位置信息
18 pos3
18 pos5
19 pos1
20 pos2
21 pos4
簡單的說，索引就是將文檔按照某個（或某些）字段順序組織起來，以便能根據該字段高效的查詢。有了索引，至少能優化如下場景的效率：
(1)查詢，比如查詢年齡為18的所有人
(2)更新/刪除，將年齡為18的所有人的信息更新或刪除，因為更新或刪除時，需要根據條件先查詢出所有符合條件的文檔，所以本質上還是在優化查詢
(3)排序，將所有人的信息按年齡排序，如果沒有索引，需要全表掃描文檔，然后再對掃描的結果進行排序
眾所周知，MongoDB默認會為插入的文檔生成_id字段（如果應用本身沒有指定該字段），_id是文檔唯一的標識，為了保證能根據文檔id快遞查詢文檔，MongoDB默認會為集合創建_id字段的索引。
db.person.getIndexes() // 查詢集合的索引信息
[
{
"v" : 2, // 索引版本
"key" : { // 索引的字段及排序方向
"_id" : 1 // 根據_id字段升序索引
},
"name" : "_id_" // 索引的名稱
"ns" : "test.person", // 集合名
}
]
索引操作：
1.查看索引
語法：db.collection.getIndexes()
例：db.person.getIndexes()
2.創建索引
從3.0版本后使用 db.collection.createIndex()代替db.collection.ensureIndex()
語法：db.collection.createIndex(key, option)
參數說明：
（1） key: {字段名:1或-1}: 1標識索引升序，-1降序
（2） option: 設置索引選項，如設置名稱、設置成為唯一索引
例：db.person.createIndex({age: 1}) // 按age字段創建升序索引
執行成功后可以看到返回的numIndexesAfter比numIndexesBefore大
db.person.getIndexes()
例：db.person.createIndex({age: -1},{name:"AgeIndex"}) // 按age字段創建降序索引，且索引的名字為AgeIndex
db.person.getIndexes()
3.刪除索引
db.person.getIndexes()
（1）刪除指定索引
db.person.dropIndex("age_1") 傳索引的名字
db.person.dropIndex({age:-1}) 傳文檔的參數
（2）刪除所有索引
db.person.dropIndexes()
注：不能刪除_id索引，即自動創建索引不能刪除。
4.修改索引
Mongodb沒有單獨的修改索引的方法，如果需要修改某個索引，需要先刪除舊有的索引，再創建新的索引
5.重建索引
如果您需要重建集合中的索引，您可以使用 db.person.reIndex() ，一條操作就可以重建這個集合上的所有索引。它會刪除所有索引，包括 _id 索引 ，然后重建所有索引。
6.查詢索引大小
db.person.totalIndexSize() --單位：字節
7.索引類別
a.默認索引
MongoDB每個collection都會有一個默認主鍵_id，不能刪除
db.student.dropIndex("_id_")
db.student.dropIndex({_id:1})
b.單列索引
如2.所述
c.組合索引
db.person.createIndex({name:1,age:-1}) --兩個字段組合或多個字段組合
d.內嵌文檔索引
db.student.createIndex({address:1}) --在address整個列上創建索引
db.student.createIndex({"address.city":1}) --在address列的city上創建索引
e.唯一索引
db.student.dropIndex({name:1})
db.student.createIndex({name:1},{unique:true}) --創建唯一索引
db.student.find({},{_id:0,name:1})
第一種情況：插入重復項，則報錯（唯一索引建立后不允許插入重復值）
db.student.insert({name:"lisi"})
db.student.insert({name:"a"})不報錯
第二種情況：插入的文檔中不包含name屬性，則name的值默認為null，反復插入也會報錯
db.student.insert({school:"nyist"})
db.student.insert({school:"nyist"})報錯
db.student.insert({university:"nyist"})報錯
第三種情況：如果在創建唯一索引時已經存在了重復項，先消除重復文檔，保留一個文檔后，再創建
db.student.createIndex({age:1},{unique:true})
8.explain執行計划
db.student.find().explain()
可加參數查看 "executionStats"
例：db.student.find().explain("executionStats")
說明：
explain會返回查詢使用的索引情況，耗時等統計信息。
其中：
exectutionTimemillis: 耗時(毫秒)
indexBounds：當前查詢具體使用的索引
9.強制索引
db.student.find().hint("_id_")
db.student.find().hint({_id:1})
db.student.find().hint("_id_").explain("executionStats") --再查看執行計划
10.舉個使用索引查詢案例，看效果
a.插入10W條數據
for(var i=0;i<100000;i++){
db.person.insert({name:"zs"+i,age:i})
}
b.查詢name為zs10000的數據（不建立索引）
db.person.find({name:"zs"+10000})
db.person.find({name:"zs"+10000}).explain("executionStats") --看效果，此時沒建name索引
c.建立索引
db.person.getIndexes()
db.person.createIndex({name:1})
d.查詢name為zs10000的數據
db.person.find({name:"zs"+10000}).explain("executionStats")
db.person.find({name:"zs"+10000}).hint({name:1}).explain("executionStats") --看效果，此時已建name索引
索引的基本操作
數據准備：
先插入100w條記錄
for(var i=0;i<1000000;i++){
db.orders.insert({
"onumber":i,
"date":"2015-07-02",
"cname":"zcy"+i,
"items":[{
"ino":i,
"quantity":i,
"price":4.0
},{
"ino":i+1,
"quantity":i+1,
"price":6.0
}
]
})
};
等待幾分鍾
db.orders.count()總共1000000條記錄。
1. 默認索引
存儲在MongoDB集合中的每個文檔（document）都有一個默認的主鍵“_id“，如果在添加新的文檔時，沒有指定“_id“值時，MongoDB會創建一個ObjectId值，並創建會自動創建一個索引在“_id“鍵上，默認索引的名稱是”_id_“,並無法刪除，如下面的命令查看：
>db.orders.getIndexes()
2. 查看索引信息
返回一個數組，該數組保存標識和描述集合上現有索引的文檔列表，可以查看是否有對某個集合創建索引，並創建哪些索引，方便管理。
語法：
>db.collection.getIndexes()
3. 創建單列索引
對文檔單個字段創建索引或者對內嵌文檔的單個字段創建索引
語法：
db.collection.createIndex({field：boolean} })
boolean:對於某個領域的上升索引，指定一個值為1；對於下降的索引，指定一個值為1。
（1）創建
>db.orders.createIndex({cname:1})
>db.orders.getIndexes()
對orders集合創建了cname索引，默認的索引名稱是”cname_1“
（2）根據條件查詢文檔，並查看查詢效率怎么樣
> db.orders.find({"cname":"zcy100000"})
查詢orders 集合根據條件cname為zcy100000的文檔
我們測試有建索引和沒建索引在1000000條文檔執行查詢的效率怎么樣，這邊先使用explain()函數，
可加參數查看 "executionStats"
例：db.student.find().explain("executionStats")
說明：
explain會返回查詢使用的索引情況，耗時等統計信息。
其中：
exectutionTimemillis: 耗時
indexBounds：當前查詢具體使用的索引
> db.orders.find({"cname":"zcy100000"}).explain("executionStats")
1） 沒建索引時，查詢條件cname為zcy100000的文檔
可把之前建立的索引刪除：db.orders.dropIndex(“cname_1”)
db.orders.find({"cname":"zcy100000"}).explain("executionStats")
查詢可得”exectutionTimemillis”的值為:551毫秒，沒使用到索引
2） 有建索引，查詢條件cname為zcy100000的文檔
db.orders.createIndex({cname:1})
db.orders.getIndexes()
db.orders.find({"cname":"zcy100000"}).explain("executionStats")
返回一個記錄，花費時間很少，有使用到cname索引
我們結果是相差很大的，有建索引字段，查詢效率比較高，在大數據時，差別更明顯。
（3）查詢和排序組合使用
我們查詢集合cname大於zcy100的文檔並對onumber進行降序排序
db.orders.find({"cname":{$gt:"zcy1000"}}).sort({"onumber":1}).explain("executionStats")
執行出現錯誤：
"errorMessage" : "Runner error:Overflow sort stage buffered data usage of 33554456 bytes exceeds internal limit of 33554432 bytes",
我們的內存只有33554432字節，對於包括一個沒有索引的排序操作的查詢，服務器必須在返回任何結果之前將所有的文檔加載到內存中來進行排序。
可對onumber創建索引
> db.orders.createIndex({onumber:-1})
> db.orders.getIndexes()
> db.orders.find({"cname":{$gt:"zcy1000"}}).sort({"onumber":1}).explain("executionStats")
這次在執行時，可以正常執行，已經減少了內存的緩存的數據
4. 創建組合索引
我們可以同時對多個鍵創建組合索引
語法：
db.collection.createIndex({field1：boolean, field2：boolean } })
說明：
db.collection.createIndex({a:1,b:1,c:1 } })
（1） 創建組合索引
我們同時對onumber和cname進行組合索引
例子：
>db.orders.createIndex({cname:1,onumber:-1})
>db.orders.getIndexes()
索引存儲在一個易於遍歷讀取的數據集合中，存儲的數據
{_id:..,"onumber" : 2, "date" : "2015-07-02", "cname" : "zcy1"})
{_id:..,"onumber" : 1, "date" : "2015-07-02", "cname" : "zcy1"})
{_id:..,"onumber" : 1, "date" : "2015-07-02", "cname" : "zcy2"})
(2) 查詢
1）我們對cname和onumber作為查詢條件時
>db.orders.find({"cname":{$gt:"zcy1000"},"onumber":2000}).explain("executionStats")
我們查詢條件cname大於zcy1000並且onumber等於2000的數據，我們用explain()查詢索引使用情況
2）我們只用兩個索引其中一個作為查詢時
第一種情況：我們條件只使用"cname":{$gt:"zcy1000"}作為查詢條件
>db.orders.find({"cname":{$gt:"zcy1000"}}).explain("executionStats")
會使用到索引，符合我們前面介紹的我們對a、b、c進組合創建索引，支持查詢時會用到索引的第一種。
第二種情況：我們條件只使用"onumber":2000作為查詢條件
> db.orders.find({"onumber":2000}).explain("executionStats")
會使用到索引，但不符合我們前面介紹的我們對a、b、c進組合創建索引，支持查詢時會用到幾種。
（3）查詢和排序組合使用
我們查詢集合cname大於zcy100的文檔並對onumber進行降序排序
>db.orders.find({"cname":{$gt:"zcy1000"}}).sort({"onumber":1}).explain("executionStats")
5. 內嵌文檔的索引
我們對內嵌文檔創建索引時，跟基本文檔創建索引一樣
語法：
db.collection.createIndex({field：boolean} })
field說明：以“.“來指明內嵌文檔的路徑
（1） 單列的內嵌文檔的索引創建
>db.orders.createIndex({"items.info":1})
>db.orders.getIndexes()
我們orders集合下的內嵌items集合的info字段創建索引
我們以items.info字段作為查詢條件，並使用索引的情況
>db.orders.find({"items.info":{$lt:100}}).explain("executionStats")
我們查詢items.info小於100的數據
（2） 組合的內嵌文檔的索引的創建
我們對內嵌文檔創建組合索引時，跟基本文檔創建組合索引一樣
>db.collection.createIndex({field1：boolean, field2：boolean } })
>db.orders.createIndex({"items.info":1, "items. quantity":-1})
6. 刪除索引
我們對已經創建的索引進行刪除，可以針對具體的集合中索引進行刪除，也可以對所有的集合中的所有索引刪除
（1）具體索引名稱刪除索引
db.collection.dropIndex(index)
刪除具體的索引，根據索引名稱刪除，如果不知道索引的名稱，可以通過db.collection.getIndexes()查看索引名稱
> db.orders.dropIndex("cname_1")
我們刪除cname字段的索引，現在只剩下onumber字段索引
（2）刪除集合中所有索引
db.collection.dropIndexes()
> db.orders.dropIndexes()
我們對集合中的索引都刪除，我們刪除cname字段的索引和onumber字段索引，現在只剩默認的_id字段索引，索引我們在使用時，要謹慎，以免把集合中的索引都刪除。
(3)對dropIndexes方法，我們還有一種用法，可以指定集合的具體索引的刪除
> db.runCommand({"dropIndexes":"orders","index":"cname_1"})