# 十.删除文档

前言

remove:用来移除集合中的数据

db.collection.remove(
   <query>, # query :（可选）删除的文档的条件
   {
     justOne: <boolean> # justOne : （可选）如果设为 true 或 1，则只删除匹配到的多个文档中的第一个
   }
)

1
2
3
4
5
6

删除 worker 集合里 name 是小明 2 的所有文档数据

 db.students.remove({name:'小明 2'});
#  WriteResult({ "nRemoved" : 2 })

1
2

即使匹配多条也只删除一条

db.students.remove({name:"小明 2"},{justOne:true})
-- WriteResult({ "nRemoved" : 1 })

1
2

# 11. 查询文档

# 11.1 find

语法

db.getCollection("test").find()

参数

collection_name 集合的名字实例查询 students 下所有的文档

db.students.find()

# 11.2 查询指定列

语法

db.getCollection("test").find({queryWhere},{key:1,key:1})

参数列表

collection_name 集合的名字 queryWhere 参阅查询条件操作符 key 指定要返回的列 1 表示要显示实例只返回显示 age 列

db.students.find({},{age:1});

# 11.3 findOne

查询匹配结果的第一条数据语法

db.getCollection("test").findOne()

实例

db.students.findOne()

# 11.4 $in

查询字段在某个范围内

db.student.find({age:{$in:[30,100]}},{name:1,age:1});

# 11.5 $nin

查询字段不在某个范围内

db.student.find({age:{$nin:[30,100]}},{name:1,age:1});

# 11.6 $not

对特定条件取反

db.student.find({age:{$not:{$gte:20,$lte:30}}});

# 11.7 array

对数组的查询

//按所有元素匹配 //let result = db.student.find({friends:[ "A", "B", "C", "D" ]}); //匹配一项包含 A 的就可以 //let result = db.student.find({friends:"A"}); //$all 必须同时包含A B //let result = db.student.find({friends:{$all:['A',"B"]}}); //$in 或者关系，包含A或者B //let result = db.student.find({friends:{$in:['A',"B"]}}); //$size 按数组的长度去匹配 //let result = db.student.find({friends:{$size:4}}); //$slice 只返回数组中的某一部分 //let result = db.student.find({friends:{$size:5}},{name:1,friends:{$slice:2}}); //let result = db.student.find({friends:{$size:5}},{name:1,friends:{$slice:-2}}); $slice:["$array", [startIndex, ] length ] （startIndex可以省略，默认从0开始） "friends" : [ "A", "B" ] } "friends" : [ "C", "D" ] db.stu.find({},{friends:{$slice:[0,3]}}); "friends" : [ "A", "B", "C" ]

# 11.8 where

db.student.find({$where:"this.age>30"},{name:1,age:1});

# 11.9 cursor

游标不是查询结果，而是查询的一个返回资源或者接口，通过这个接口，可以逐条读取数据 var result = db.student.find();

//while(result.hasNext()){ // printjson(result.next()); //}

# 12. 条件操作符

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

# 12.1 大于操作符

语法

db.collectoin_name.find({<key>:{$gt:<value>}})

参数

collectoin_name 集合名称 key 字段 value 值查询 age 大于 30 的数据

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

# 12.2 大于等于操作符

语法

db.collectoin_name.find({<key>:{$gte:<value>}})

参数

collectoin_name 集合名称 key 字段 value 值查询 age 3 大于等于 30 的数据

db.students.find({age: {$gte: 30}})

# 12.3 小于操作符

语法

db.collectoin_name.find( {<key>:{$lt:<value>}})

参数

collectoin_name 集合名称 key 字段 value 值实例

db.students.find({age: {$lt: 30}}) 查询 age 小于 30 的数据

# 12.4 小于等于操作符

语法

db.collectoin_name.find({<key>:{$lte:<value>}})

参数

collectoin_name 集合名词 key 字段 value 值查询 age 小于等于 30 的数据

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

# 12.5 同时使用 $gte和$lte

语法

db.collectoin_name.find({<key>:{$gte:<value>},<key>:{$lte:<value>}})

参数

collectoin_name 集合名称 key 字段 value 值实例查询 age 大于等于 30 并且 age 小于等于 50 的数据

db.students.find({age: {$gte: 30, $lte: 50}})

# 12.6 等于

语法

db.collectoin_name.find({<key>:<value>,<key>:<value>})

参数

collectoin_name 集合名词 key 字段 value 值查询 age = 30 的数据

db.students.find({"age": 30})`

# 12.7 使用 _id 进行查询

语法

db.collectoin_name.find({"_id" : ObjectId("value")})

参数

value _id 的值实例查询_id 是 562af23062d5a57609133974 数据

db.students.find({_id:ObjectId("5adb666ecd738e9771638985")});

{ "_id" : ObjectId("5adb666ecd738e9771638985"), "name" : "zzzz" }

# 12.8 查询结果集的条数

语法

db.collectoin_name.find().count()

参数

collectoin_name 集合名称实例

db.students.find().count()

# 12.9 正则匹配

语法

db.collection.find({key:/value/})

参数

collectoin_name 集合名称 key 字段 value 值实例查询 name 里包含 zhang 的数据

db.students.find({name:/value/})

查询某个字段的值当中是否以另一个值开头

db.students.find({name:/^zhang/})

# 13. 与和或

# 13.1 and

find 方法可以传入多个键(key)，每个键(key)以逗号隔开

语法

db.getCollection("test").find({key1:value1, key2:value2})

实例查询 name 是小明并且 age 是 1 的数据

db.students.find({name:'小明',age:1})

# 13.2 or

语法

db.getCollection("test").find(
   {
      $or: [
   {key1: value1}, {key2:value2}
      ]
   }
)

1
2
3
4
5
6
7

实例查询 age = 30 或者 age = 50 的数据

db.students.find({$or:[{age:30},{age:50}]})

# 13.3 and 和 or 联用

语法

db.getCollection("test").find(
   {
     key1:value1,
     key2:value2,
     $or: [
   {key1: value1},
   {key2:value2}
     ]
   }
)

1
2
3
4
5
6
7
8
9
10

实例查询 name 是小明并且 age 是 30 或者 age 是 50 的数据

db.students.find({name:'小明',$or:[{age:30},{age:50}]})

# 14. 分页查询

# 14.1 limit

读取指定数量的数据记录语法

db.collectoin_name.find().limit(number)

参数

collectoin_name 集合 number 读取的条数实例查询前 3 条数据

db.students.find().limit(3)

# 14.2 skip

跳过指定数量的数据，skip 方法同样接受一个数字参数作为跳过的记录条数语法

db.collectoin_name.find().skip(number)

参数

collectoin_name 集合 number 跳过的条数实例查询 3 条以后的数据

db.students.find().skip(3)

# 14.3 skip+limit

通常用这种方式来实现分页功能语法

db.collectoin_name.find().skip(skipNum).limit(limitNum)

参数

collectoin_name 集合名称 skipNum 跳过的条数 limitNum 限制返回的条数实例查询在 4-6 之间的数据

db.students.find().skip(3).limit(3);

# 14.4 sort 排序

sort()方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1 是用于降序排列。语法

db.collectoin_name.find().sort({key:1})
db.collectoin_name.find().sort({key:-1})

1
2

参数

collectoin_name 集合 key 表示字段实例查询出并升序排序 {age:1} age 表示按那个字段排序 1 表示升序

db.students.find().sort({age:1})

# 15. 执行脚本

var username = "小明"
var password = "123456"
var user = { username: username, password: password }
var db = connect("students") //选择users数据库
var result = db.users.insert(user)
print("write " + result)
var start = Date.now()
var db = connect("students")
for (var i = 0; i < 1000; i++) {
  db.users.insert({ username: "小明" + i })
}
var cost = Date.now() - start
print("cost " + cost + " ms")
var start = Date.now()
var db = connect("students")
var users = []
for (var i = 0; i < 1000; i++) {
  users.push({ username: "小明" + i })
}
db.users.insert(users)
var cost = Date.now() - start
print("cost " + cost + " ms")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在命令行中执行

script>mongo 1.js MongoDB shell version: 2.6.7 connecting to: test connecting to: students write WriteResult({ "nInserted" : 1 })

# 16. 备份与导出

mongodump
-- host 127.0.0.1
-- port 27017
-- out D:/databack/backup
-- collection mycollection
-- db test
-- username
-- password
//mongodump --host 127.0.0.1 --port 27017 --out ./backup --collection users --db students
//db.users.drop();

mongorestore
--host
--port
--username
--password

// mongorestore --host 127.0.0.1 --port 27017 ./backup

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 17. 权限

# 17.1 创建用户

使用 use admin 进入我们的 admin 库使用 db.createUser 方法来创建集合

db.createUser({
    user:'小明',
    pwd:'123456',
    customData:{
        name:'zhufengpeixun',
        email:'zhufengpeixun@126.com',
        age:9
    },
    roles:[
        {
          role:'readWrite',
          db:'school'
        },
        'read'
    ]
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 17.2 查询用户

db.system.users.find();

# 17.3 删除用户

db.system.users.remove({user:'小明'});

# 17.4 启动数据库权限检查

mongod --auth mongo -u 小明 -p 123456 127.0.0.1:27017/admin

# 17.5 鉴权

use admin; db.auth('小明','小明'); 正确返回 1，如果错误返回 0

# 18. 索引

# 18.1 准备数据

var db = connect('school');//选择 users 数据库 var users = []; for(var i=0;i<20;i++){ users.push({_id:i,name:'小明'+i}); } print(users.length); db.users.insert(users);

# 18.2 打印出查询时间

var startTime = Date.now(); var db = connect('school');
var records=db.users.find({name:"小明 100"}); records.forEach(function(item){printjson(item)}); print(Date.now() - startTime);

# 18.3 建立索引

db.users.ensureIndex({name:1});

# 19. 附录

# 19.1 ObjectId 构成

之前我们使用 MySQL 等关系型数据库时，主键都是设置成自增的。但在分布式环境下，这种方法就不可行了，会产生冲突。为此，MongoDB 采用了一个称之为 ObjectId 的类型来做主键。ObjectId 是一个 12 字节的 BSON 类型字符串。按照字节顺序，一次代表：

4 字节：UNIX 时间戳 3 字节：表示运行 MongoDB 的机器 2 字节：表示生成此_id 的进程 3 字节：由一个随机数开始的计数器生成的值

# 19.2 Mongodb 启动命令 mongod 参数说明

选项含义 --port 指定服务端口号，默认端口 27017 --logpath 指定 MongoDB 日志文件，注意是指定文件不是目录 --logappend 使用追加的方式写日志 --dbpath 指定数据库路径 --directoryperdb 设置每个数据库将被保存在一个单独的目录

# 19.3 集合命令

db.students.help();
DBCollection help
db.students.find().help() - show DBCursor help 显示游标帮助
db.students.count() 显示条数
db.students.copyTo(newColl) - duplicates collection by copying all docum ents to newColl; no indexes are copied. 把一个旧集合拷贝到一个新的集合，不拷贝索引
db.students.convertToCapped(maxBytes) - calls {convertToCapped:'students ', size:maxBytes}} command
db.students.dataSize() 数据大小
db.students.distinct( key ) - e.g. db.students.distinct( 'x' ) 统计唯一的key的数量
db.students.drop() drop the collection ，删除集合
db.students.dropIndex(index) - e.g. db.students.dropIndex( "indexName" ) 删除索引 or db.students.dropIndex( { "indexKey" : 1 } )
db.students.dropIndexes() 删除 所有的索引
db.students.ensureIndex(keypattern[,options]) - options is an object wit h these possible fields: name, unique, dropDups 添加索引
db.students.reIndex()
db.students.find([query],[fields]) - query is an optional query filter. fields is optional set of fields to return. 查找文档
     e.g. db.students.find( {x:
77} , {name:1, x:1} )
db.students.find(...).count() 数量
db.students.find(...).limit(n) 限制返回的条数
db.students.find(...).skip(n) 设置跳过的条数
db.students.find(...).sort(...) 排序
db.students.findOne([query]) 查找一条
db.students.findAndModify( { update : ... , remove : bool [, query: {}, sort: {}, 'new': false] } ) 查找并且修改 更新后的值，是否删除，查询条件 排序 是否返回新值
db.students.getDB() get DB object associated with collection 获得DB
db.students.getPlanCache() get query plan cache associated with collecti on
db.students.getIndexes() 获取索引
db.students.group( { key : ..., initial: ..., reduce : ...[, cond: ...] } ) 分组统计
db.students.insert(obj) 插入文档
db.students.mapReduce( mapFunction , reduceFunction , ) 统计
db.students.aggregate( [pipeline], ) - performs an agg regation on a collection; returns a cursor 聚合
db.students.remove(query) 删除
db.students.renameCollection( newName , ) renames the colle ction. 重命名集合
db.students.runCommand( name , ) runs a db command with the gi ven name where the first param is the collection name
db.students.save(obj) 保存对象
db.students.stats() 统计信息
db.students.storageSize() - includes free space allocated to this collec tion
db.students.totalIndexSize() - size in bytes of all the indexes
db.students.totalSize() - storage allocated for all data and indexes
db.students.update(query, object[, upsert_bool, multi_bool]) - instead o f two flags, you can pass an object with fields: upsert, multi 更新
db.students.validate( ) - SLOW
db.students.getShardVersion() - only for use with sharding
db.students.getShardDistribution() - prints statistics about data distri bution in the cluster
db.students.getSplitKeysForChunks( ) - calculates split p oints over all chunks and returns splitter function
db.students.getWriteConcern() - returns the write concern used for any o perations on this collection, inherited from server/db if set
db.students.setWriteConcern( ) - sets the write conc ern for writes to the collection
db.students.unsetWriteConcern( ) - unsets the write concern for writes to the collection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 20. 用户和权限

# 20.1 角色

# 20.1.1 数据库用户角色

针对每一个数据库进行控制。

read :提供了读取所有非系统集合，以及系统集合中的 system.indexes, system.js, system.namespaces
readWrite: 包含了所有 read 权限，以及修改所有非系统集合的和系统集合中的 system.js 的权限

# 20.1.2 数据库管理角色

每一个数据库包含了下面的数据库管理角色。

dbOwner：该数据库的所有者，具有该数据库的全部权限。
dbAdmin：一些数据库对象的管理操作，但是没有数据库的读写权限。（参考：http://docs.mongodb.org/manual/reference/built-in-roles/#dbAdmin） (opens new window)
userAdmin：为当前用户创建、修改用户和角色。拥有 userAdmin 权限的用户可以将该数据库的任意权限赋予任意的用户。

# 20.1.3 集群管理权限

admin 数据库包含了下面的角色，用户管理整个系统，而非单个数据库。这些权限包含了复制集和共享集群的管理函数。
clusterAdmin：提供了最大的集群管理功能。相当于 clusterManager, clusterMonitor, and hostManager 和 dropDatabase 的权限组合。
clusterManager：提供了集群和复制集管理和监控操作。拥有该权限的用户可以操作 config 和 local 数据库（即分片和复制功能）
clusterMonitor：仅仅监控集群和复制集。
hostManager：提供了监控和管理服务器的权限，包括 shutdown 节点，logrotate, repairDatabase 等。备份恢复权限：admin 数据库中包含了备份恢复数据的角色。包括 backup、restore 等等。

# 20.1.4 所有数据库角色

admin 数据库提供了一个 mongod 实例中所有数据库的权限角色：
readAnyDatabase：具有 read 每一个数据库权限。但是不包括应用到集群中的数据库。
readWriteAnyDatabase：具有 readWrite 每一个数据库权限。但是不包括应用到集群中的数据库。
userAdminAnyDatabase：具有 userAdmin 每一个数据库权限，但是不包括应用到集群中的数据库。
dbAdminAnyDatabase：提供了 dbAdmin 每一个数据库权限，但是不包括应用到集群中的数据库。

# 20.1.5 超级管理员权限

root: dbadmin 到 admin 数据库、useradmin 到 admin 数据库以及 UserAdminAnyDatabase。但它不具有备份恢复、直接操作 system.*集合的权限，但是拥有 root 权限的超级用户可以自己给自己赋予这些权限。

# 20.1.6 备份恢复角色

backup、restore；

# 20.1.7 内部角色

__system

# 20.2 权限配置

数据库用户角色 read readWrite
数据库管理角色 dbAdmin dbOwner userAdmin
集群管理角色 clusterAdmin clusterManager clusterMonitor hostManager
备份恢复角色 backup restore
所有数据库角色 readAnyDatabase readWriteAnyDatabase userAdminAnyDatabase dbAdminAnyDatabase
超级用户角色 root

mongod.conf 配置文件

# 20.2.1 常见命令

ps -ef | grep mongo //查看当前进程 /usr/bin/mongod -f /etc/mongod.conf //寻找配置文件 systemctl restart mongod.service //重启 mongodb

# 20.2.2 创建超级管理员

show users //显示所有用户

# 20.2.3 创建用户

use admin

db.createUser({
  user:'admin',
  pwd:'123456',
  roles:[{role:'root',db:'admin'}]
});

1
2
3
4
5

# 20.2.4 管理员登录

mongo admin -u admin -p 123456

# 20.2.5 给每个库创创建一个自己的管理员

use question;

db.createUser({
  user:'questionadmin',
  pwd:'123456',
  roles:[{role:'dbOwner',db:'question'}]
});

1
2
3
4
5

# 20.2.6 删除用户

db.dropUser("admin")  // 删除某个用户,接受字符串参数
db.dropAllUser();     // 删除当前库的所有用户

1
2

# 20.2.7 更新用户

db.updateUser('admin',{pwd:'password'})

# 20.2.8 密码认证

db.auth('admin','password');

← 八.更新文档导入导出数据 →