Mongodb 常用命令
MongoDB中文手册|官方文档中文版 https://docs.mongoing.com/
1、一般命令
1、显示数据库列表：show dbs
2、切换/创建数据库: use dabaseA (dabaseA为数据库名，如果该数据库不存在，则会创建)
3、删除当前数据库：db.dropDatabase() --当执行use dabaseA命令后，当前数据库就是dabaseA，所以再执行db.dropDatabase()，删除的当前数据库就是dabaseA。
4、显示当前数据库中的操作命令：db.help()
5、显示当前数据库中的集合：show collections (这里的集合类似关系数据库中的表)
6、显示数据库中某集合的操作命令： db.table.help() (这里的table是当前数据库中一个集合)
7、往某一集合中插入数据：db.person.insert({'name':'小王', 'age' : 20, 'sex':'男'}) 或者 db.person.save({'name':'小王', 'age' : 20, 'sex':'男'})
8、mongodb的save和insert函数都可以向collection里插入数据，但两者是有两个区别：
•使用save函数里，如果原来的对象不存在，那他们都可以向collection里插入数据，如果已经存在，save会调用update更新里面的记录，而insert则会忽略操作•insert可以一次性插入一个列表，而不用遍历，效率高， save则需要遍历列表，一个个插入，效率稍低
例如：已存在数据： {_id : 'abc123', " name " : " 小王 " }，再次进行插入操作时，
insert({_id : 'abc123', " name " : " 小李 " }) 会报主键重复的错误提示
save({ _id : 'abc123', " name " : " 小李 " }) 会把 小王 修改为 小李 。
如果集合中不存在 _id : 'abc123'，
insert({_id : 'abc123', " name " : " 小李 " }) 增加一条数据
save({ _id : 'abc123', " name " : " 小李 " }) 增加一条数据
9、查看当前使用的数据库：db 或 db.getName() 两者效果一样
10、显示当前数据库的状态：db.stats()
11、显示当前数据库的版本 ：db.version()
12、显示当前数据库链接的地址：db.getMongo()
13、在指定的机器上，从数据库A，负责数据到B：db.copyDatabase("mydb", "temp", "127.0.0.1") 将本机的mydb的数据复制到temp数据库中
14、显示当前数据库中所有集合: db.getCollectionNames()
15、显示数据库的状态：db.table.stats()
16、删除当前数据库中某个集合：db.table.drop() 删除集合 table
17、删除当前数据库某个集合中的所有数据：db.table.remove({}) 删除集合 table中所有数据
18、删除当前数据库某个集合中 name='test'的记录：db.table.remove({name:'test'})
19、删除当前数据库某个集合中所有数据：db.Information.remove({})
查看集合基本信息命令
1、查看当前数据库中某集合中的帮助：db.table.help()
2、查看某集合的数据条数：db.table.count()
3、查看某集合数据空间大小: db.table.dataSize() 单位是字节
4、查看某集合的总空间大小：db.table.storageSize()
查询命令
1、查询索引记录：相当于select * from table
db.table.find()
2、查询age = 22的记录 和 age != 20
db.table.find({age:22}) 和 db.table.find({age:{$ne:22}})
3、查询age >22的记录
db.table.find({age:{$gt:22}})
db.table.find("this.age>22")
4、查询age>=22的记录
db.table.find({age:{$gte:22}})
db.table.find("this.age>=22")
5、查询age <30的记录
db.table.find({age:{$lt:30}})
db.table.find("this.age<30")
6、查询age <=30的记录
db.table.find({age:{$lte:30}})
db.table.find("this.age<=30")
7、查询age >20 并且age<30的记录
db.table.find({age:{$gt:20,$lt :30}})
db.table.find("this.age>20 && this.age<30")
8、查询集合中name 包含mongo的数据,相当于like '%mongo%' 模糊查询
db.table.find({name:/mongo/})
9、查询集合中 name中以mongo开头的数据,相当于like 'mongo%' 模糊查询
db.table.find({name:/^mongo/})
10、查询集合中，只查询，name和age两列
db.table.find({},{name:1,age:1})
11、查询结合中age>10 ,并且只查询 name 和 age两列
db.table.find({age:{$gt:10}},{name:1,age:1})
12、按年龄排序
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是逗号
13、查询前10条数据，相当于select top 10 from table
db.table.find().limit(10)
14、查询10条以后的数据，相当于 select * from table where id not in (select top * from table )
db.table.find().skip(10)
15、查询5-10条之间的数据
db.table.find().skip(5).limit(10)
16、查询 age =10 or age =20的记录
db.table.find({$or:[{age:20},{age:30}]})
17、查询age >20的记录条数
db.table.find({age:{$gt:20}}).count()
18、查询age>30 or age <20 的记录
db.table.find({$or:[{age:{$gt:30}},{age:{$lt:20}}]})
db.table.find("this.age>30 || this.age<20")
19、查询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和字段名必须在引号内，否则报错
操作日期格式是，ISODate("2019-12-14T08:28:20.079Z")的数据：db.Account.find({CreateDate:{'$gt':ISODate("2020-01-01 00:00:00.215")}}) 报错：db.Account.find({CreateDate:{'$gt':ISODate("2020-01-01 0:00:00.215")}}) ，必须是两个0
查询 2020-09-13 到2020-09-14一天的记录数：db.Article_Mongo.count({WX_datetime:{'$gt':ISODate("2020-09-13 00:00:00.000"),'$lte':ISODate("2020-09-14 00:00:00.000")}})
21、查询age 在[30,40] 内的记录
db.table.find({age:{$in:[30,40]}})
22、查询age不在[30,40]范围内的记录
db.table.find({age:{$nin:[30,40]}})
23、查询age能被3整除的记录
db.table.find({age:{$mod:[3,0]}})
23、查询age能被3整除余2的记录
db.table.find({age:{$mod:[3,2]}})
//假如有以下文档 { 'name' : { 'first' : 'Joe', 'last' : 'Schmoe' } 'age' : 45 }
24、查询姓名为询姓名是Joe Schmoe的记录
db.table.find({'name.first':'Joe','name.last':'Schmoe'})
db.table.find({name:{first:'Joe',last:'Schmoe'}})
25、如果需要多个元素来匹配数组，就需要使用$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']}})
26、查询age不是30并且性别不是‘男’的记录,就用到 $nor
db.person.find({$nor:[{age:30},{sex:'男'}]})
db.jdftdata.find({$nor:[{content:"-1"}]})
27、查询age不大于30的记录 ，用到$not，$not执行逻辑NOT运算，选择出不能匹配表达式的文档 ，包括没有指定键的文档。
db.person.find({age:{$not:{$gt:30}}})
28、如果$exists的值为true,选择存在该字段的文档；若值为false则选择不包含该字段的文档。
选择age存在，且不在[30,40]只能的记录
db.person.find({age:{$exists:true,$nin:[30,40]}})
29、查询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$/})
31、如果在查询的时候需要多个元素来匹配数组，就需要用到$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" ] }
32、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 }
33、$size 对于查询来说也是意义非凡，顾名思义就是可用它来查询指定长度的数组。
比如有以下数据：
{ "_id" : 1, "fruit" : [ "apple", "banana", "peach" ] }
{ "_id" : 2, "fruit" : [ "apple", "pear", "orange" ] }
{ "_id" : 3, "fruit" : [ "cherry", "banana", "apple" ] }
{ "_id" : 4, "fruit" : null }
{ "_id" : 5, "fruit" : [ "apple", "orange" ] }
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" ] }
34、$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 }
35、 $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 } ] }
36、$exists
判断某个字段是否存在，查询school集合中存在zipcode字段的记录
db.school.find({zipcode:{$exists:1}})
37、假如有集合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 } }
分组、统计、排序
假设一个集合detail,包含date, name,..等字段，那么统计某天按照name分组统计不同name的记录条数命令：
db.detail.aggregate([ {'$match':{date:'2020-10-27'}}, { '$group':{ '_id':{name:'$name'}, count:{'$sum':1} } }, {'$sort':{'count':-1}} ])
python
# 分组，统计，排序 def aggregate_match_group(self,strDate): # 为空表示所有都进行分组 match_dict = {"$match": {'date':strDate}} # 以分数$name来分组，并且统计该$name下的记录条数 group_dic = {"$group": {"_id": {"name": "$name"}, "count": {"$sum": 1}}} # 排序，1：升序，-1：降序 sort_dict={'$sort':{'count':-1}} result = self.db.detail103.aggregate([match_dict, group_dic,sort_dict]) for one in result: print(one['_id']['name'],':',one['count']) print(1)
2、更新命令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
1、$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 );
2、$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 }
3、$unset
用法：{ $unset : { field : 1} }
顾名思义，就是删除字段了.
有数据如下：
{ "_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 }
{ "_id" : 5, "count" : 17 }
如果要把第一条数据中name字段删除，更新语句为：
db.food.update({_id : 1},{$unset : {name : 1}})
4、$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" ] }
5、 $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" }
6、 $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" }
7、 $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" ] }
8、$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" ] }
9、$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" ] }
3、$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 |
4、索引命令
1、创建索引,对age列，创建索引，并且是升序
db.table.ensureIndex({age:1})
#python代码
import pymongo
from pymongo import ASCENDING, DESCENDING
db.table.create_index([("age",ASCENDING)])
2、创建对name列升序，age列倒序的索引
db.table.ensureIndex({name:1,age:-1})
db.trsdata.ensureIndex({IR_URLTIME:1})
db.table.create_index([("name",ASCENDING),("age",DESCENDING)]) #python代码
3、查询当前集合索引索引
db.table.getIndexes()
4、查询总索引记录大小
db.table.totalIndexSize()
5、查询当前集合索引索引信息
db.table.reIndex()
MapReduce
5、用户创建
现在需要创建一个帐号，该账号需要有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（内置角色）： 1、数据库用户角色：read、readWrite;
2、数据库管理角色：dbAdmin、dbOwner、userAdmin；
3、 集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
4、备份恢复角色：backup、restore；
5、 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
6、超级用户角色：root // 这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
7、内部角色：__system
具体角色：
刚建立了 userAdminAnyDatabase 角色，用来管理用户，可以通过这个角色来创建、删除用户。验证：需要开启auth参数。
