Mongodb 經常使用命令

時間 2019-11-13

標籤 mongodb 經常使用命令欄目 MongoDB 简体版

原文原文鏈接

一、通常命令

　　一、顯示數據庫列表：show dbspython

　　二、切換/建立數據庫: use dabaseA (dabaseA爲數據庫名，若是該數據庫不存在，則會建立)ajax

　　三、刪除當前數據庫：db.dropDatabase() --當執行use dabaseA命令後，當前數據庫就是dabaseA，因此再執行db.dropDatabase()，刪除的當前數據庫就是dabaseA。正則表達式

　　四、顯示當前數據庫中的操做命令：db.help()sql

　　五、顯示當前數據庫中的集合：show collections (這裏的集合相似關係數據庫中的表)mongodb

　　六、顯示數據庫中某集合的操做命令： db.table.help() (這裏的table是當前數據庫中一個集合)數據庫

　　七、往某一集合中插入數據：db.person.insert({'name':'小王', 'age' : 20, 'sex':'男'}) 或者 db.person.save({'name':'小王', 'age' : 20, 'sex':'男'})數組

　　八、mongodb的save和insert函數均可以向collection裏插入數據，但二者是有兩個區別：app

　　•使用save函數裏，若是原來的對象不存在，那他們均可以向collection裏插入數據，若是已經存在，save會調用update更新裏面的記錄，而insert則會忽略操做•insert能夠一次性插入一個列表，而不用遍歷，效率高， save則須要遍歷列表，一個個插入，效率稍低函數

　　例如：已存在數據： {_id : 'abc123', " name " : " 小王 " }，再次進行插入操做時，ui

　　　insert({_id : 'abc123', " name " : " 小李 " }) 會報主鍵重複的錯誤提示

　　　save({ _id : 'abc123', " name " : " 小李 " }) 會把小王修改成小李。

　　若是集合中不存在 _id : 'abc123'，

　　 insert({_id : 'abc123', " name " : " 小李 " }) 增長一條數據

　　　save({ _id : 'abc123', " name " : " 小李 " }) 增長一條數據

　　九、查看當前使用的數據庫：db 或 db.getName() 二者效果同樣

　　十、顯示當前數據庫的狀態：db.stats()

　　十一、顯示當前數據庫的版本：db.version()

　　十二、顯示當前數據庫連接的地址：db.getMongo()

　　1三、在指定的機器上，從數據庫A，負責數據到B：db.copyDatabase("mydb", "temp", "127.0.0.1") 將本機的mydb的數據複製到temp數據庫中

　　1四、顯示當前數據庫中全部集合: db.getCollectionNames()

　　1五、顯示數據庫的狀態：db.table.stats()

　　1六、刪除當前數據庫中某個集合：db.table.drop() 刪除集合 table

　　1七、刪除當前數據庫某個集合中的全部數據：db.table.remove({}) 刪除集合 table中全部數據

　　1八、刪除當前數據庫某個集合中 name='test'的記錄：db.table.remove({name:'test'})

　　1九、刪除當前數據庫某個集合中全部數據：db.Information.remove({})

　　查看集合基本信息命令

　　一、查看當前數據庫中某集合中的幫助：db.table.help()

　　二、查看某集合的數據條數：db.table.count()

　　三、查看某集合數據空間大小: db.table.dataSize() 單位是字節

　　四、查看某集合的總空間大小：db.table.storageSize()

　　查詢命令

　　一、查詢索引記錄：至關於select * from table

　　　　db.table.find()

　　二、查詢age = 22的記錄和 age != 20

　　　　db.table.find({age:22}) 和 db.table.find({age:{$ne:22}})

　　三、查詢age >22的記錄

　　　　db.table.find({age:{$gt:22}})

　　　　db.table.find("this.age>22")

　　四、查詢age>=22的記錄

　　　　db.table.find({age:{$gte:22}})

　　　　db.table.find("this.age>=22")

　　五、查詢age <30的記錄

　　　　db.table.find({age:{$lt:30}})

　　　　db.table.find("this.age<30")

　　六、查詢age <=30的記錄

　　　　db.table.find({age:{$lte:30}})

　　　　db.table.find("this.age<=30")

　　七、查詢age >20 而且age<30的記錄

　　　　db.table.find({age:{$gt:20,$lt :30}})

　　　　db.table.find("this.age>20 && this.age<30")

　　八、查詢集合中name 包含mongo的數據,至關於like '%mongo%' 模糊查詢

　　　　db.table.find({name:/mongo/})

　　九、查詢集合中 name中以mongo開頭的數據,至關於like 'mongo%' 模糊查詢

　　　　db.table.find({name:/^mongo/})

　　十、查詢集合中，只查詢，name和age兩列

　　　　db.table.find({},{name:1,age:1})

　　十一、查詢結合中age>10 ,而且只查詢 name 和 age兩列

　　　　db.table.find({age:{$gt:10}},{name:1,age:1})

　　十二、按年齡排序

　　　　db.table.find().sort({age:1,name:1}) 按照年齡和姓名升序

　　　　db.table.find().sort({age:-1,name:1}) 按照年齡降序，姓名升序

　　　　python：db.table.find().sort(‘age‘，pymongo.ASCENDING) 或 db.table.find().sort(‘age‘，1)升序；

　　　　　　　　db.table.find().sort(‘age‘，pymongo.DESCENDING) 或db.table.find().sort(‘age‘，-1)降序

　　　　　　　　db.table.find().sort([(‘age‘，pymongo.DESCENDING),('name',pymongo.ASCENDING)]) 年齡降序，姓名升序

　　　　　　　　或db.table.find().sort([(‘age‘，-1),('name':1)])年齡降序，姓名升序

　　　　注意mongo和python裏面命令的區別是冒號，python是逗號

　　1三、查詢前10條數據，至關於select top 10 from table

　　　　db.table.find().limit(10)

　　1四、查詢10條之後的數據，至關於 select * from table where id not in (select top * from table )

　　　　db.table.find().skip(10)

　　1五、查詢5-10條之間的數據

　　　　db.table.find().skip(5).limit(10)

　　1六、查詢 age =10 or age =20的記錄

　　　　db.table.find({$or:[{age:20},{age:30}]})

　　1七、查詢age >20的記錄條數

　　　　db.table.find({age:{$gt:20}}).count()

　　1八、查詢age>30 or age <20 的記錄

　　　　db.table.find({$or:[{age:{$gt:30}},{age:{$lt:20}}]})

　　　　db.table.find("this.age>30 || this.age<20")

　　1九、查詢age >40 or name ='mike'的記錄　　

　　　　db.table.find({$or:[{age:{$gt:40}},{name:'mike'}]})

　　20、查詢age >40 or name ='mike'的記錄，只查詢name 和age兩列,而且按照name升序，age降序

　　　　db.table.find({$or:[{age:{$gt:40}},{name:'mike'}]},{name:1,age:-1})

　　　　查詢age >40 而且 name ='mike'的記錄，只查詢name 和age兩列,而且按照name升序，age降序

　　　　db.table.find({$and:[{age:{$gt:40}},{name:'mike'}]},{name:1,age:-1})

　　　　python 代碼：db.table.find({'$and':[{age:{'$gt':40}},{'name':'mike'}]},{'name':1,'age':-1}) 像$and和字段名必須在引號內，不然報錯

　　2一、查詢age 在[30,40] 內的記錄

　　　　db.table.find({age:{$in:[30,40]}})

　　2二、查詢age不在[30,40]範圍內的記錄

　　　　db.table.find({age:{$nin:[30,40]}})

　　2三、查詢age能被3整除的記錄

　　　　db.table.find({age:{$mod:[3,0]}})

　　2三、查詢age能被3整除餘2的記錄

　　　　db.table.find({age:{$mod:[3,2]}})

　　　　//假若有如下文檔 { 'name' : { 'first' : 'Joe', 'last' : 'Schmoe' } 'age' : 45 }

　　2四、查詢姓名爲詢姓名是Joe Schmoe的記錄

　　　　db.table.find({'name.first':'Joe','name.last':'Schmoe'})

　　　　db.table.find({name:{first:'Joe',last:'Schmoe'}})

　　2五、若是須要多個元素來匹配數組，就須要使用$all了

　　　　//假設在咱們表中3個下面的文檔：

　　　　db.food.insert({'_id' : 1,'fruit' : ['apple', 'banana', 'peach']})

　　　　db.food.insert({'_id' : 2,'fruit' : ['apple', 'kumquat', 'orange']})

　　　　db.food.insert({'_id' : 3,'fruit' : ['cherry', 'banana', 'apple']})

　　　　要找到既有apple又有banana的文檔：

　　　　db.food.find({fruit:{$all:['apple', 'banana']}})

　　2六、查詢age不是30而且性別不是‘男’的記錄,就用到 $nor

　　　　db.person.find({$nor:[{age:30},{sex:'男'}]})

　　　　db.jdftdata.find({$nor:[{content:"-1"}]})

　　2七、查詢age不大於30的記錄，用到$not，$not執行邏輯NOT運算，選擇出不能匹配表達式的文檔，包括沒有指定鍵的文檔。

　　　　db.person.find({age:{$not:{$gt:30}}})

　　2八、若是$exists的值爲true,選擇存在該字段的文檔；若值爲false則選擇不包含該字段的文檔。

　　　　選擇age存在，且不在[30,40]只能的記錄

　　　　db.person.find({age:{$exists:true,$nin:[30,40]}})

　　2九、查詢name中包括字母t的記錄，相似 name like '%t%'

　　　　db.person.find({name:/t/})

　　　　db.person.find({name:{$regex:/t/}})

　　　　db.person.find({name:/t/i}) i在這裏是不區分大小寫

　　　　db.person.find({name:{$regex:/t/,$options:'i'}}) i在這裏是不區分大小寫

　　30、查詢name中以t字母結尾的記錄，相似 name like '%t', 要用到符號$

　　　　db.person.find({name:/t$/})

　　3一、若是在查詢的時候須要多個元素來匹配數組，就須要用到$all了，這樣就匹配一組元素。

　　　　例如：假如建立了包含3個元素的以下集合：

　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "pear", "orange" ] }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }

　　　　要找到既有apple, 又有banana的文檔，就要用到$all

　　　　db.food.find({fruit:{$all:['apple','banana']}})

　　　　查詢結果以下：

　　　　> db.food.find({fruit:{$all:['apple','banana']}})
　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }

　　　　注意兩條結果記錄的apple和banana的順序是不同的，也就是說，順序可有可無。

　　　　要是想查詢指定數組位置的元素，則須要用key.index語法指定下標

　　　　db.food.find({'fruit.2':'peach'})，結果爲：

　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }

　　3二、null

　　　　null比較奇怪，它確實能匹配自己，假若有下面的數據：

　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "pear", "orange" ] }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }
　　　　{ "_id" : 4, "fruit" : null }

　　　　db.food.find({fruit:null}) 查詢結果：{ "_id" : 4, "fruit" : null }

　　　　可是null不只能匹配自己，並且能匹配「不存在的」，例如：

　　　　db.food.find({x: null}) ，food集合中原本不包含x鍵的，結果以下：

　　　　> db.food.find({x:null})
　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "pear", "orange" ] }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }
　　　　{ "_id" : 4, "fruit" : null }

　　3三、$size 對於查詢來講也是意義非凡，顧名思義就是可用它來查詢指定長度的數組。

　　　　好比有如下數據：

　　　　db.food.find({fruit:{$size:3}}) 查詢結果以下：fruit對應的數組的長度爲3

　　　　{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "pear", "orange" ] }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }

　　　　db.food.find({fruit:{$size:1}}) 查詢結果以下：fruit對應的數組的長度爲1

　　　　{ "_id" : 5, "fruit" : [ "apple", "orange" ] }

　　3四、$slice 能夠按偏移量返回記錄，針對數組。如{"$slice":10}返回前10條,{"$slice":{[23,10]}}從24條取10條

　　　　例如在集合food中有數據以下：

　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana" ], "name" : "fruitName1" }
　　　　{ "_id" : 2, "fruit" : [ "apple", "orange", "pear", "banana" ], "name" : "fruitName2" }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ], "name" : "fruitName3" }
　　　　{ "_id" : 4, "fruit" : null }

　　　　針對fruit 如何只獲取該鍵對應數據前個數據，{"$slice":2}

　　　　查詢語句：db.food.find({},{fruit:{$slice:2}}) 查詢結果爲：

　　　　{ "_id" : 1, "fruit" : [ "apple", "pear" ], "name" : "fruitName1" } 注意fruit對應的數據，只獲取了，前兩個數據，後面的去掉了
　　　　{ "_id" : 2, "fruit" : [ "apple", "orange" ], "name" : "fruitName2" }
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana" ], "name" : "fruitName3" }
　　　　{ "_id" : 4, "fruit" : null }

　　　　針對fruit 如何只獲取該鍵對應數據從第二個數據開始取，取兩個，{"$slice":[1,2]}

　　　　查詢語句：db.food.find({},{fruit:{$slice:[1,2]}}) 查詢結果爲：

　　　　{ "_id" : 1, "fruit" : [ "pear", "orange" ], "name" : "fruitName1" }
　　　　{ "_id" : 2, "fruit" : [ "orange", "pear" ], "name" : "fruitName2" }
　　　　{ "_id" : 3, "fruit" : [ "banana", "apple" ], "name" : "fruitName3" }
　　　　{ "_id" : 4, "fruit" : null }

　　3五、 $elemMatch
　　　　若是對象有一個元素是數組，那麼$elemMatch能夠匹配內數組內的元素。

　　　　例如數據集school中有以下數據：

　　　　{ "_id" : 1, "zipcode" : "63109", "students" : [ { "name" : "john", "school" : 102, "age" : 10 }, { "name" : "jess", "school" : 102, "age" : 11 },
　　　　{ "name" : "jeff", "school" : 108, "age" : 15 } ] }
　　　　{ "_id" : 2, "zipcode" : "63110", "students" : [ { "name" : "ajax", "school" : 100, "age" : 7 }, { "name" : "achilles", "school" : 100, "age" : 8 } ] }
　　　　{ "_id" : 3, "zipcode" : "63108", "students" : [ { "name" : "ajax", "school" : 100, "age" : 7 }, { "name" : "achilles", "school" : 100, "age" : 8 } ] }
　　　　{ "_id" : 4, "zipcode" : "63109", "students" : [ { "name" : "barney", "school" : 102, "age" : 7 }, { "name" : "ruth", "school" : 102, "age" : 16 } ] }
　　　　{ "_id" : 5, "zipcode" : "63109", "students" : [ { "name" : "barney", "school" : 102, "age" : 12 }, { "name" : "ruth", "school" : 102, "age" : 16 } ] }

　　　　要查詢 zipcode="63109" ，school= ‘102’ 而且 age>10的記錄

　　　　db.school.find( { zipcode: "63109" },{ students: { $elemMatch: { school: 102 ,age:{$gt: 10}} } } )

　　　　查詢結果：

　　　　{ "_id" : 1, "students" : [ { "name" : "jess", "school" : 102, "age" : 11 } ] }
　　　　{ "_id" : 4, "students" : [ { "name" : "ruth", "school" : 102, "age" : 16 } ] }
　　　　{ "_id" : 5, "students" : [ { "name" : "barney", "school" : 102, "age" : 12 } ] }

　　3六、$exists

　　　　判斷某個字段是否存在，查詢school集合中存在zipcode字段的記錄

　　　　db.school.find({zipcode:{$exists:1}})

　　3七、假若有集合school ,數據以下：

　　　　{ "_id" : 1, "zipcode" : "63109", "students" : [ { "name" : "john", "school" : 102, "age" : 10 }, { "name" : "jess", "school" : 102, "age" : 11 }, { 　　"name" : "jeff", "school" : 108, "age" : 15 } ] }
　　　　{ "_id" : 2, "zipcode" : "63110", "students" : [ { "name" : "ajax", "school" : 100, "age" : 7 }, { "name" : "achilles", "school" : 100, "age" : 8 } ] }
　　　　{ "_id" : 3, "zipcode" : "63109", "students" : [ { "name" : "ajax", "school" : 100, "age" : 7 }, { "name" : "achilles", "school" : 100, "age" : 8 } ] }
　　　　{ "_id" : 4, "zipcode" : "63109", "students" : [ { "name" : "barney", "school" : 102, "age" : 7 }, { "name" : "ruth", "school" : 102, "age" : 16 } ] }
　　　　{ "_id" : 5, "zipcode" : "63109", "students" : [ { "name" : "barney", "school" : 102, "age" : 12 }, { "name" : "ruth", "school" : 102, "age" : 16 } ] }

　　　　若是隻查詢students字段裏面的內容，而且只查詢school =102 的姓名和年齡信息：

　　　　查詢語句爲：db.school.find({'students.school' : 102},{'students.name':1,'students.age':1})

　　　　結果以下：

　　　　{ "_id" : 1, "students" : [ { "name" : "john", "age" : 10 }, { "name" : "jess", "age" : 11 }, { "name" : "jeff", "age" : 15 } ] }
　　　　{ "_id" : 4, "students" : [ { "name" : "barney", "age" : 7 }, { "name" : "ruth", "age" : 16 } ] }
　　　　{ "_id" : 5, "students" : [ { "name" : "barney", "age" : 12 }, { "name" : "ruth", "age" : 16 } ] }

　　　　假設school 集合中包含一些記錄：students字段對應一個數據字典

　　　　{ "_id" : 7, "zipcode" : "63109", "students" : { "name" : "jike", "school" : "102", "age" : 45 } }
　　　　{ "_id" : 8, "zipcode" : "63109", "students" : { "name" : "Marry", "school" : "100", "age" : 75 } }

　　　　若是隻查詢字段students對應name和age信息，則查詢語句以下：

　　　　db.school.find({_id : {$gt:5}},{'students.name':1,'students.age':1})

　　　　結果爲：這裏_id是必需要顯示的

　　　　{ "_id" : 7, "students" : { "name" : "jike", "age" : 45 } }
　　　　{ "_id" : 8, "students" : { "name" : "Marry", "age" : 75 } }

　　二、更新命令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 :可選，拋出異常的級別。

　　　　咱們在集合 col 中插入以下數據：

　　　　db.col.insert({ 　　　　title: 'MongoDB 教程', 　　　　description: 'MongoDB 是一個 Nosql 數據庫', 　　　　by: '菜鳥教程', 　　　　url: 'http://www.runoob.com', 　　　　tags: ['mongodb', 'database', 'NoSQL'], 　　　　likes: 100 　　　　})
　　　　接着咱們經過 update() 方法來更新標題(title):

　　　　db.col.update({'name':'aa'},{$set:{'name':'aa'}},{upsert:true}) 若是集合col中沒有name='aa',那麼就插入aa

　　　一、$set
　　　　用法：{ $set : { field : value } }
　　　　就是至關於sql的set field = value，所有數據類型都支持$set。例：

　　　　db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})

　　　　db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB','flag':1}}) 一次更新兩個字段


　　　　更多實例：

　　　　只更新第一條記錄：
　　　　db.col.update( { "count" : { $gt : 2 } } , { $set : { "test" : "Yes"} } );

　　　　所有更新：
　　　　db.col.update( { "count" : { $gt : 6 } } , { $set : { "test" : "Yes"} },false,true );

　　　　只添加第一條：
　　　　db.col.update( { "count" : { $gt : 2 } } , { $set : { "test" : "Yes"} },true,false );

　　　　所有更新：
　　　　db.col.update( { "count" : { $gt : 30 } } , { $inc : { "count" : 1} },false,true );

　　　　只更新第一條記錄：
　　　　db.col.update( { "count" : { $gt : 50 } } , { $inc : { "count" : 1} },false,false );

　　二、$inc
　　　　用法：{ $inc : { field : value } }
　　　　意思對一個數字字段field增長value，例：在集合food中有一條數據：
　　　　{ "_id" : 5, "count" : 6 } ，若是count的值增長2，則更新語句爲：
　　　　db.food.update({_id : 5},{$inc : {count : 2}}) 執行結果爲：

　　　　{ "_id" : 5, "count" : 8 }

　　三、$unset
　　　　用法：{ $unset : { field : 1} }
　　　　顧名思義，就是刪除字段了.
　　　　有數據以下：

　　　　若是要把第一條數據中name字段刪除，更新語句爲：

　　　　db.food.update({_id : 1},{$unset : {name : 1}})

 　　四、$push
　　　　用法：{ $push : { field : value } }
　　　　把value追加到field裏面去，field必定要是數組類型才行，若是field不存在，會新增一個數組類型加進去。

　　　　如今集合food中有數據以下：
　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana" ] }
　　　　給fruit對應的數組中增長一個數據："peach",則更新語句爲：
　　　　db.food.update({_id : 1}, {$push : {fruit : 'peach'}}) 執行結果爲
　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana", "peach" ] }

　　　　若是再給這條數據中更新，一個不存在的字段addCol的數據'newColumn'，則增長進去，以下：

　　　　db.food.update({_id : 1}, {$push : {addCol:'newColumn'}}) 則執行結果以下：
　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana", "peach" ], "addCol" : [ "newColumn" ] }

　　五、 $pushAll
　　　　用法：{ $pushAll : { field : value_array } }
　　　　同$push,只是一次能夠追加多個值到一個數組字段內。
　　　　例如在集合food 中有一條數據以下：
　　　　{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ], "name" : "fruitName3" }
　　　　若是要把 "orange", "strawberry" 數據更新到fruit對應的數組中，則更新語句爲：
　　　　db.food.update({_id : 3} , {$pushAll : {fruit ：["orange", "strawberry"]}})執行結果以下：
　　　　{ "_id" : 3, "fruit" : [ "apple", "orange", "strawberry", "orange", "strawberry" ], "name" : "fruitName3" }

　　六、 $addToSet
　　　　用法：{ $addToSet : { field : value } }
　　　　增長一個值到數組內，並且只有當這個值不在數組內才增長
　　　　例如集合food中有一下數據:

　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana", "peach" ], "addCol" : [ "newColumn" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "orange", "pear", "banana" ], "name" : "fruitName2" }
　　　　{ "_id" : 3, "fruit" : [ "apple", "orange", "strawberry", "orange", "strawberry" ], "name" : "fruitName3" }

　　　　若是給集合中全部fruit對應的數組中增長一個數據"peach",更新語句爲：
　　　　db.food.update({_id :{$gt: 0}},{$addToSet : {fruit : 'peach'},false,true})
　　　　執行結果爲：

　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana", "peach" ], "addCol" : [ "newColumn" ] }
　　　　{ "_id" : 2, "fruit" : [ "apple", "orange", "pear", "banana", "peach" ], "name" : "fruitName2" }
　　　　{ "_id" : 3, "fruit" : [ "apple", "orange", "strawberry", "orange", "strawberry", "peach" ], "name" : "fruitName3" }

　　七、 $pop
　　　　刪除數組內的一個值
　　　　用法：刪除最後一個值：{ $pop : { field : 1 } }刪除第一個值：{ $pop : { field : -1 } }

　　　　注意，只能刪除一個值

　　　　對於數據：{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry" ], "addCol" : [ "newColumn" ] }

　　　　執行 db.food.update({_id : 1},{$pop : {fruit : 1}}) 把 "strawberry"刪除掉結果以下:

　　　　{ "_id" : 1, "fruit" : [ "apple", "pear", "orange" ], "addCol" : [ "newColumn" ] }

　　　　再執行 db.food.update({_id : 1},{$pop : {fruit : -1}}) 把 "apple"刪除掉結果以下:

　　　　{ "_id" : 1, "fruit" : ["pear", "orange" ], "addCol" : [ "newColumn" ] }

　　八、$pull
　　　　用法：$pull : { field : value } }
　　　　從數組field內刪除一個等於value值。

  　　對應集合food的數據{ "_id" : 1, "fruit" : [ "apple", "pear", "orange", "strawberry", "banana", "peach" ], "addCol" : [ "newColumn" ] }

　　　刪除 "orange" 更新語句爲：db.food.update({_id ： 1},{$pull : {fruit :'orange'}})
　　　結果爲：{ "_id" : 1, "fruit" : [ "apple", "pear", "strawberry", "banana", "peach" ], "addCol" : [ "newColumn" ] }

　九、$pullAll
　　　用法：{ $pullAll : { field : value_array } }
　　同$pull,能夠一次刪除數組內的多個值。
　　對於集合food中的數據{ "_id" : 1, "fruit" : [ "orange", "strawberry", "banana", "apple", "peach" ], "addCol" : [ "newColumn" ] }
　　若是刪除 'apple'和'orange' 那麼更新語句爲：db.food.update({_id : 1}, {$pullAll: {fruit : ['apple', 'orange']}})
　　執行結果爲：{ "_id" : 1, "fruit" : [ "strawberry", "banana",  "peach" ], "addCol" : [ "newColumn" ] }

　三、$type

　　語法: { field: { $type:  } }
　　選擇字段值爲指定的BSON數據類型的文檔.使用下面類型對應的編號：

類型	類型	編號
Double	雙精度	1
String	字符串	2
Object	對象	3
Array	數組	4
Binary data	二進制對象	5
Object id	對象id	7
Boolean	布爾值	8
Date	日期	9
Null	未定義	10
Regular Expression	正則表達式	11
JavaScript	JavaScript代碼	13
Symbol	符號	14
JavaScript (with scope)	JavaScript代碼(帶範圍)	15
32-bit integer	32 位整數	16
Timestamp	時間戳	17
64-bit integer	64 位整數	18
Min key	最小鍵	255
Max key	最大鍵	127

　四、索引命令

　　一、建立索引,對age列，建立索引，而且是升序

　　　　db.table.ensureIndex({age:1})

　　　　#python代碼

　　　　import pymongo
　　　　from pymongo import ASCENDING, DESCENDING

　　　　db.table.create_index([("age",ASCENDING)])

　　二、建立對name列升序，age列倒序的索引

　　　　db.table.ensureIndex({name:1,age:-1})

　　　　db.trsdata.ensureIndex({IR_URLTIME:1})

　　　　db.table.create_index([("name",ASCENDING),("age",DESCENDING)]) #python代碼

　　三、查詢當前集合索引索引

　　　　db.table.getIndexes()

　　四、查詢總索引記錄大小

　　　　db.table.totalIndexSize()

　　五、查詢當前集合索引索引信息

　　　　db.table.reIndex()

　　MapReduce

　五、用戶建立

　　如今須要建立一個賬號，該帳號須要有grant權限，即：帳號管理的受權權限。注意一點，賬號是跟着庫走的，因此在指定庫裏受權，必須也在指定庫裏驗證(auth)。

 use admin
switched to db admin
> db.createUser(
...   {
...     user: "dba",
...     pwd: "dba",
...     roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
...   }
... )
Successfully added user: {
    "user" : "dba",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}

　在OT_DB數據庫建立讀寫用戶tta

> use admin
switched to db admin

> db.createUser(
...  {
...     user: "tta",
...    pwd: "tta",
...     roles: [
...       { role: "readWrite", db: "OT_DB" },
...    ]
...  }
...  )
Successfully added user: {
        "user" : "tta",
        "roles" : [
                {
                        "role" : "readWrite",
                        "db" : "OT_DB" 
} ] }

　　上面加粗的就是執行的命令：

　　user：用戶名

　　pwd：密碼

　　roles：指定用戶的角色，能夠用一個空數組給新用戶設定空角色；在roles字段,能夠指定內置角色和用戶定義的角色。role裏的角色能夠選：

　Built-In Roles（內置角色）：
  一、數據庫用戶角色：read、readWrite;
　二、數據庫管理角色：dbAdmin、dbOwner、userAdmin； 

　三、 集羣管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager； 
　四、備份恢復角色：backup、restore； 
　五、 全部數據庫角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase 
　六、超級用戶角色：root // 這裏還有幾個角色間接或直接提供了系統超級用戶的訪問（dbOwner 、userAdmin、userAdminAnyDatabase） 
　七、內部角色：__system

　　具體角色：

　　剛創建了 userAdminAnyDatabase 角色，用來管理用戶，能夠經過這個角色來建立、刪除用戶。驗證：須要開啓auth參數。
　　

　　刪除用戶：

　　db.system.users.remove({user:"username"});