#coding=utf-8
#名词
"""
SQL术语/概念 MongoDB术语/概念 解释/说明
database database 数据库
table collection 数据库表/集合
row document 数据记录行/文档
column field 数据字段/域
index index 索引
table joins 表连接,MongoDB不支持
primary key primary key 主键,MongoDB自动将_id字段设置为主键
三元素：数据库，集合，文档.集合就是关系数据库中的表,文档对应着关系数据库中的行,文档，就是一个对象，由键值对构成，是json的扩展Bson形式{'name':'guojing','gender':'男'}
集合：类似于关系数据库中的表，储存多个文档，结构不固定，如可以存储如下文档在一个集合中
{'name':'guojing','gender':'男'}
{'name':'huangrong','age':18}
{'book':'shuihuzhuan','heros':'108'}
数据库：是一个集合的物理容器，一个数据库中可以包含多个文档,一个服务器通常有多个数据库
"""
"""
Ubuntu安装：
tar -zxvf mongodb-linux-x86_64-debian92-4.0.3.tgz
ls -la
mkdir mongodb
mv mongodb-linux-x86_64-debian92-4.0.3 mongodb
cd mongodb
mkdir data
mkdir logs
cd logs/
touch mongo.log
这里我们新建了data和logs文件夹，并在logs文件夹内创建mongo.log文件
创建配置文件mongo.conf：vim mongo.conf
dbpath=/mongodb/data
logpath=/mongodb/logs/mongo.log
logappend=true
journal=true
quiet=true
port=27017
fork=true #后台运行
bind_ip=0.0.0.0 #允许任何IP进行连接
auth=false #是否授权连接
配置环境变量/etc.profle文件。往里面新增一行：export PATH=$PATH:/mongodb/mongodb-linux-x86_64-debian92-4.0.3/bin其中$PATH后面跟的是实际安装的mongodb的bin所在目录。
重新加载配置：source /etc/profile
mongod命令看看是否安装成功：mongod -f /mongodb/etc/mongo.conf
"""
"""
Centos 使用yum安装MongoDB 4.0
1.配置MongoDB的yum源
更新所有包 ：# yum update
创建yum源文件：#cd /etc/yum.repos.d #vim mongodb-org-4.0.repo
添加以下内容：这里可以修改 gpgcheck=0, 省去gpg验证
[mngodb-org]
name=MongoDB Repository
baseurl=http://mirrors.aliyun.com/mongodb/yum/redhat/7Server/mongodb-org/4.0/x86_64/
gpgcheck=0
enabled=1
2.安装MongoDB
安装命令：yum -y install mongodb-org
安装完成后
查看mongo安装位置 whereis mongod
查看修改配置文件 ：vim /etc/mongod.conf
bindIp: 172.0.0.1 改为 bindIp: 0.0.0.0
(注意冒号与ip之间需要一个空格)
3.启动MongoDB
启动mongodb ：systemctl start mongod.service
停止mongodb ：systemctl stop mongod.service
查到mongodb的状态：systemctl status mongod.service
4.外网访问需要关闭防火墙：
CentOS 7.6默认使用的是firewall作为防火墙。
开通端口：firewall-cmd --zone=public --add-port=27017/tcp --permanent
查看防火墙状态：firewall-cmd --state
重新加载配置：firewall-cmd --reload
查看开放的端口：firewall-cmd --list-ports
关闭防火墙端口：firewall-cmd --zone=public --remove-port=27017/tcp --permanent
关闭firewall：
systemctl stop firewalld.service #停止firewall
systemctl disable firewalld.service #禁止firewall开机启动
5.设置开机启动
systemctl enable mongod.service
6.启动Mongo shell
命令：mongo
查看数据库：show dbs
7.需要的话启用权限控制：
编辑mongod.conf注释bindIp,并重启mongodb.
vim /etc/mongod.conf
重启mongodb：systemctl restart mongod.service
#远程连接MongoDB
windows上也安装好MongoDB，并配置好环境变量： 通过命令控制台执行mongo 远程ip即可连接成功，如：mongo 192.168.80.128
数据库切换：
查看当前数据库名称：db
查看所有数据库名称：列出所有在物理上存在的数据库：show dbs
切换数据库：如果数据库不存在，则指向数据库，但不创建，直到插入数据或创建集合时数据库才被创建：use 数据库名称。默认的数据库为test，如果你没有创建新的数据库，集合将存放在test数据库中
数据库删除：删除当前指向的数据库；如果数据库不存在，则什么也不做，db.dropDatabase()
#集合创建
语法:db.createCollection(name, options):name是要创建的集合的名称;options是一个文档，用于指定集合的配置.选项参数是可选的，所以只需要到指定的集合名称。
例1：不限制集合大小:db.createCollection("stu")
capped collection:一个固定大小的集合,自动覆盖最早的条目时达到最大值。
document validation:创建一个对更新和插入都会进行验证的集合，若校验通过则执行，反之抛出异常
例2：限制集合大小，后面学会插入语句后可以查看效果:参数capped：默认值为false表示不设置上限，值为true表示设置上限;参数size：当capped值为true时，需要指定此参数，表示存储空间上限大小，当文档达到上限时，会将之前的数据覆盖，单位为字节
db.createCollection("sub", { capped : true, size : 10 } )
db.createCollection("log", { capped : true, size : 5242880, max : 5000 } )#这个命令创建名字为“log”，最大存储空间为 5m，最多 5000 个文档的集合
db.createCollection("people", { size: 2147483648 } )下面命令只是预先分配最大存储空间为 2G，不是固定大小的 people 集合
#创建一个文档验证集合:建立新的 collection 并设置 validation。指定 contact 表的 phone 字段只能是string，或者email必须匹配如下规则，或者 status 必须为 Unkown或者 Incomplete
db.createCollection( "contacts", {
validator: { $or:
[
{ phone: { $type: "string" } },
{ email: { $regex: /@mongodb\.com$/ } },
{ status: { $in: [ "Unknown", "Incomplete" ] } }
]
}
} )
这时候做这样的插入：db.contacts.insert( { name: "xyz", status: "A" } )
返回是：
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 121,
"errmsg" : "Document failed validation"
}
})
查看当前数据库的集合:语法:show collections
删除:语法:db.集合名称.drop()
> db.createCollection("stu")
{ "ok" : 1 }
> db.createCollection("sub", {capped : true, size : 10})
{ "ok" : 1 }
> show collections
stu
sub
#数据类型
下表为MongoDB中常用的几种数据类型：
Object ID：文档ID
String：字符串，最常用，必须是有效的UTF-8
Boolean：存储一个布尔值，true或false
Integer：整数可以是32位或64位，这取决于服务器
Double：存储浮点值
Arrays：数组或列表，多个值存储到一个键
Object：用于嵌入式的文档，即一个值为一个文档
Null：存储Null值
Timestamp：时间戳
Date：存储当前日期或时间的UNIX时间格式
object id
每个文档都有一个属性，为_id，保证每个文档的唯一性
可以自己去设置_id插入文档
如果没有提供，那么MongoDB为每个文档提供了一个独特的_id，类型为objectID
objectID是一个12字节的十六进制数:前4个字节为当前时间戳;接下来3个字节的机器ID;接下来的2个字节中MongoDB的服务进程id;最后3个字节是简单的增量值
#插入:语法:db.集合名称.insert(document);插入文档时，如果不指定_id参数，MongoDB会为文档分配一个唯一的ObjectId
> db.stu.insert({name:'黄蓉', gender:0})
WriteResult({ "nInserted" : 1 })
s1={_id:'20160101',name:'hr'}
s1.gender=0
db.stu.insert(s1)
> s1={_id:'20201201',name:'杨康'}
{ "_id" : "20201201", "name" : "杨康" }
> s1.gender=1
1
> db.stu.insert(s1)
WriteResult({ "nInserted" : 1 })
简单查询:语法:db.集合名称.find()
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "杨康", "gender" : 1 }
更新:语法:
db.集合名称.update(
,
,
{multi: }
)
参数query:查询条件，类似sql语句update中where部分;参数update:更新操作符，类似sql语句update中set部分;参数multi:可选，默认是false，表示只更新找到的第一条记录，值为true表示把满足条件的文档全部更新
全文档更新:db.stu.update({name:'hr'},{name:'mnc'})
> db.stu.update({name:"杨康"}, {name:"欧阳克"})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "欧阳克" }
指定属性更新，通过操作符$set
db.stu.insert({name:'hr',gender:0})
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "欧阳克" }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
db.stu.update({name:'hr'},{$set:{name:'hys'}})
> db.stu.update({name:"欧阳克"},{$set:{name:"欧阳锋"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "欧阳锋" }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
修改多条匹配到的数据:db.stu.update({},{$set:{gender:0}},{multi:true})
> db.stu.insert({name:"穆念慈", gender:0})
WriteResult({ "nInserted" : 1 })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "欧阳锋" }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0 }
> db.stu.update({},{$set:{gender:1}},{multi:true})
WriteResult({ "nMatched" : 4, "nUpserted" : 0, "nModified" : 3 })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1 }
{ "_id" : "20201201", "name" : "欧阳锋", "gender" : 1 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
保存:语法:db.集合名称.save(document):如果文档的_id已经存在则修改，如果文档的_id不存在则添加
db.stu.save({_id:'20160102','name':'yk',gender:1})
> db.stu.save({_id:'20160102','name':'yk',gender:1})
WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : "20160102" })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1 }
{ "_id" : "20201201", "name" : "欧阳锋", "gender" : 1 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
{ "_id" : "20160102", "name" : "yk", "gender" : 1 }
db.stu.save({_id:'20160102','name':'wyk'})
> db.stu.save({_id:'20160102','name':'wyk'})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1 }
{ "_id" : "20201201", "name" : "欧阳锋", "gender" : 1 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
{ "_id" : "20160102", "name" : "wyk" }
删除:语法
db.集合名称.remove(
,
{
justOne:
}
)
参数query:可选，删除的文档的条件;参数justOne:可选，如果设为true或1，则只删除一条，默认false，表示删除多条
只删除匹配到的第一条:db.stu.remove({gender:0},{justOne:true})
> db.stu.save({_id:'20160103',name:'wyk',gender:1})
WriteResult({ "nMatched" : 0, "nUpserted" : 1, "nModified" : 0, "_id" : "20160103" })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1 }
{ "_id" : "20201201", "name" : "欧阳锋", "gender" : 1 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
{ "_id" : "20160102", "name" : "wyk" }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1 }
> db.stu.remove({name:"wyk"},{justOne:true})
WriteResult({ "nRemoved" : 1 })
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1 }
{ "_id" : "20201201", "name" : "欧阳锋", "gender" : 1 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1 }
全部删除:db.stu.remove({})
#关于size
创建集合:db.createCollection('sub',{capped:true,size:10})
插入第一条数据库查询:
db.sub.insert({title:'linux',count:10})
db.sub.find()
> db.sub.insert({title:'linux',count:10})
WriteResult({ "nInserted" : 1 })
> db.sub.find()
{ "_id" : ObjectId("5fc5af576ecfdef1a678cf48"), "title" : "linux", "count" : 10 }
插入第二条数据库查询
db.sub.insert({title:'web',count:15})
db.sub.find()
> db.sub.insert({title:'web',count:15})
WriteResult({ "nInserted" : 1 })
> db.sub.find()
{ "_id" : ObjectId("5fc5af576ecfdef1a678cf48"), "title" : "linux", "count" : 10 }
{ "_id" : ObjectId("5fc5afa16ecfdef1a678cf49"), "title" : "web", "count" : 15 }
插入第三条数据库查询
db.sub.insert({title:'sql',count:8})
db.sub.find()
> db.sub.insert({title:'sql',count:8})
WriteResult({ "nInserted" : 1 })
> db.sub.find()
{ "_id" : ObjectId("5fc5af576ecfdef1a678cf48"), "title" : "linux", "count" : 10 }
{ "_id" : ObjectId("5fc5afa16ecfdef1a678cf49"), "title" : "web", "count" : 15 }
{ "_id" : ObjectId("5fc5afb56ecfdef1a678cf4a"), "title" : "sql", "count" : 8 }
插入第四条数据库查询
db.sub.insert({title:'django',count:12})
db.sub.find()
> db.sub.insert({title:'django',count:12})
WriteResult({ "nInserted" : 1 })
> db.sub.find()
{ "_id" : ObjectId("5fc5af576ecfdef1a678cf48"), "title" : "linux", "count" : 10 }
{ "_id" : ObjectId("5fc5afa16ecfdef1a678cf49"), "title" : "web", "count" : 15 }
{ "_id" : ObjectId("5fc5afb56ecfdef1a678cf4a"), "title" : "sql", "count" : 8 }
{ "_id" : ObjectId("5fc5afc26ecfdef1a678cf4b"), "title" : "django", "count" : 12 }
插入第五条数据库查询
db.sub.insert({title:'python',count:14})
db.sub.find()
> db.sub.insert({title:'python',count:14})
WriteResult({ "nInserted" : 1 })
> db.sub.find()
{ "_id" : ObjectId("5fc5afa16ecfdef1a678cf49"), "title" : "web", "count" : 15 }
{ "_id" : ObjectId("5fc5afb56ecfdef1a678cf4a"), "title" : "sql", "count" : 8 }
{ "_id" : ObjectId("5fc5afc26ecfdef1a678cf4b"), "title" : "django", "count" : 12 }
{ "_id" : ObjectId("5fc5afcf6ecfdef1a678cf4c"), "title" : "python", "count" : 14 }
#数据查询
基本查询:方法find()：查询:db.集合名称.find({条件文档})
方法findOne()：查询，只返回第一个:db.集合名称.findOne({条件文档})
方法pretty()：将结果格式化:db.集合名称.find({条件文档}).pretty()
比较运算符
等于，默认是等于判断，没有运算符
小于$lt
小于或等于$lte
大于$gt
大于或等于$gte
不等于$ne
查询名称等于'gj'的学生:db.stu.find({name:'gj'})
> db.stu.find({name:'wyk'})
{ "_id" : "20160103", "name" : "wyk", "gender" : 1 }
查询年龄大于或等于18的学生:db.stu.find({age:{$gte:18}})
> db.stu.find() })
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 1, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 1 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1 }
> db.stu.find({age:{$gte:18}})
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
逻辑运算符:查询时可以有多个条件，多个条件之间需要通过逻辑运算符连接
逻辑与：默认是逻辑与的关系
查询年龄大于或等于18，并且性别为1的学生:db.stu.find({age:{$gte:18},gender:1})
> db.stu.find({age:{$gte:18},gender:1})
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
逻辑或：使用$or:查询年龄大于18，或性别为0的学生:db.stu.find({$or:[{age:{$gt:18}},{gender:0}]})
> db.stu.find({$or:[{age:{$gt:18}},{gender:0}]})
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
and和or一起使用:查询年龄大于18或性别为0的学生，并且学生的姓名为gj:db.stu.find({$or:[{age:{$gte:18}},{gender:1}],name:'gj'})
> db.stu.find({$or:[{age:{$gte:18}},{gender:0}],name:'黄蓉'})
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
范围运算符:使用"$in"，"$nin" 判断是否在某个范围内
查询年龄为18、28的学生:db.stu.find({age:{$in:[18,28]}})
> db.stu.find({age:{$in:[18,28]}})
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
支持正则表达式:使用//或$regex编写正则表达式:查询姓黄的学生
db.stu.find({name:/^黄/})
db.stu.find({name:{$regex:'^黄'}})
> db.stu.find({name:/^黄/})
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
> db.stu.find({name:{$regex:'^黄'}})
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
自定义查询:使用$where后面写一个函数，返回满足条件的数据:查询年龄大于30的学生:db.stu.find({$where:function(){return this.age>30}})
> db.stu.find({$where:function(){return this.age>30}})
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
limit()：用于读取指定数量的文档,语法：db.集合名称.find().limit(NUMBER)，参数NUMBER表示要获取文档的条数，如果没有指定参数则显示集合中的所有文档
查询2条学生信息：db.stu.find().limit(2)
> db.stu.find().limit(2)
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
skip()：用于跳过指定数量的文档，语法：db.集合名称.find().skip(NUMBER)参数NUMBER表示跳过的记录条数，默认值为0
查询从第3条开始的学生信息：db.stu.find().skip(2)
> db.stu.find().skip(2)
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
一起使用：方法limit()和skip()可以一起使用，不分先后顺序：db.stu.find().skip(2).limit(2)
> db.stu.find().skip(2).limit(2)
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
创建数据集：for(i=0;i<15;i++){db.t1.insert({_id:i})}
> for(i=0;i<15;i++){db.t1.insert({_id:i})}
WriteResult({ "nInserted" : 1 })
> db.t1.find()
{ "_id" : 0 }
{ "_id" : 1 }
{ "_id" : 2 }
{ "_id" : 3 }
{ "_id" : 4 }
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
{ "_id" : 9 }
{ "_id" : 10 }
{ "_id" : 11 }
{ "_id" : 12 }
{ "_id" : 13 }
{ "_id" : 14 }
查询第5至8条数据：db.t1.find().limit(4).skip(5)或db.t1.find().skip(5).limit(4)
> db.t1.find().limit(4).skip(5)
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
> db.t1.find().skip(5).limit(4)
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
#投影,在查询到的返回结果中，只选择必要的字段，而不是选择一个文档的整个字段
一个文档有5个字段，需要显示只有3个，投影其中3个字段即可,语法：参数为字段与值，值为1表示显示，值为0不显示;db.集合名称.find({},{字段名称:1,...})对于需要显示的字段，设置为1即可，不设置即为不显示;特殊：对于_id列默认是显示的，如果不显示需要明确设置为0
db.stu.find({},{name:1,gender:1})
> db.stu.find({},{name:1,gender:1})
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0 }
{ "_id" : "20201201", "name" : "欧阳锋" }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1 }
db.stu.find({},{_id:0,name:1,gender:1})
> db.stu.find({},{_id:0,name:1,gender:1})
{ "name" : "黄蓉", "gender" : 0 }
{ "name" : "欧阳锋" }
{ "name" : "欧阳克", "gender" : 1 }
{ "name" : "穆念慈", "gender" : 0 }
{ "name" : "wyk", "gender" : 1 }
#排序:方法sort()，用于对结果集进行排序,语法:db.集合名称.find().sort({字段:1,...}),参数1为升序排列,参数-1为降序排列
根据性别降序，再根据年龄升序:db.stu.find().sort({gender:-1,age:1})
> db.stu.find().sort({gender:-1,age:1})
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
#统计个数:方法count()用于统计结果集中文档条数,语法:db.集合名称.find({条件}).count(),可以为：db.集合名称.count({条件})
统计男生人数：db.stu.find({gender:1}).count()
#> db.stu.find({gender:1}).count()
2
统计年龄大于20的男生人数：db.stu.count({age:{$gt:20},gender:1})
> db.stu.count({age:{$gt:20},gender:1})
0
#消除重复:方法distinct()对数据进行去重,语法:db.集合名称.distinct('去重字段',{条件})
查找年龄大于18的性别(去重):db.stu.distinct('gender',{age:{$gt:18}})
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
> db.stu.distinct('gender',{age:{$gt:18}})
[ 1 ]
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
#聚合 aggregate,聚合(aggregate)主要用于计算数据，类似sql中的sum()、avg();语法:db.集合名称.aggregate([{管道:{表达式}}])
管道:管道在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的输入:ps ajx | grep mongo,在mongodb中，管道具有同样的作用，文档处理完毕后，通过管道进行下一次处理
常用管道
$group：将集合中的文档分组，可用于统计结果
$match：过滤数据，只输出符合条件的文档
$project：修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
$sort：将输入文档排序后输出
$limit：限制聚合管道返回的文档数
$skip：跳过指定数量的文档，并返回余下的文档
$unwind：将数组类型的字段进行拆分
表达式:处理输入文档并输出,语法:表达式:'$列名'
常用表达式
$sum：计算总和，$sum:1同count表示计数
$avg：计算平均值
$min：获取最小值
$max：获取最大值
$push：在结果文档中插入值到一个数组中
$first：根据资源文档的排序获取第一个文档数据
$last：根据资源文档的排序获取最后一个文档数据
$group:将集合中的文档分组，可用于统计结果;_id表示分组的依据，使用某个字段的格式为'$字段'
统计男生、女生的总人数
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }
{ "_id" : 20201201, "name" : "欧阳锋", "age" : 40 }
db.stu.aggregate([
{$group:
{
_id:'$gender',
counter:{$sum:1}
}
}
])
{ "_id" : 1, "counter" : 2 }
{ "_id" : null, "counter" : 5 }
{ "_id" : 0, "counter" : 2 }
Group by null:将集合中所有文档分为一组;求学生总人数、平均年龄
db.stu.aggregate([
{$group:
{
_id:null,
counter:{$sum:1},
avgAge:{$avg:'$age'}
}
}
])
{ "_id" : null, "counter" : 9, "avgAge" : 30.22222222222222 }
透视数据：统计学生性别及学生姓名
db.stu.aggregate([
{$group:
{
_id:'$gender',
name:{$push:'$name'}
}
}
])
{ "_id" : 1, "name" : [ "欧阳克", "wyk" ] }
{ "_id" : null, "name" : [ "欧阳锋", "欧阳锋", "欧阳锋", "欧阳锋", "欧阳锋" ] }
{ "_id" : 0, "name" : [ "黄蓉", "穆念慈" ] }
使用$$ROOT可以将文档内容加入到结果集的数组中:
db.stu.aggregate([
{$group:
{
_id:'$gender',
name:{$push:'$$ROOT'}
}
}
])
{ "_id" : 1, "name" : [ { "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }, { "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 } ] }
{ "_id" : null, "name" : [ { "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }, { "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }, { "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }, { "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }, { "_id" : 20201201, "name" : "欧阳锋", "age" : 40 } ] }
{ "_id" : 0, "name" : [ { "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }, { "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 } ] }
$match,用于过滤数据，只输出符合条件的文档,使用MongoDB的标准查询操作
查询年龄大于20的学生
> db.stu.aggregate([
... {$match:{age:{$gt:20}}}
... ])
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }
{ "_id" : 20201201, "name" : "欧阳锋", "age" : 40 }
查询年龄大于20的男生、女生人数
> db.stu.aggregate([
... {$match:{age:{$gt:20}}},
... {$group:{_id:'$gender',counter:{$sum:1}}}
... ])
{ "_id" : null, "counter" : 5 }
$project,修改输入文档的结构，如重命名、增加、删除字段、创建计算结果
查询学生的姓名、年龄
> db.stu.aggregate([
... {$project:{_id:0,name:1,age:1}}
... ])
{ "name" : "黄蓉", "age" : 16 }
{ "name" : "欧阳锋", "age" : 40 }
{ "name" : "欧阳克", "age" : 19 }
{ "name" : "穆念慈", "age" : 18 }
{ "name" : "wyk", "age" : 19 }
{ "name" : "欧阳锋", "age" : 40 }
{ "name" : "欧阳锋", "age" : 40 }
{ "name" : "欧阳锋", "age" : 40 }
{ "name" : "欧阳锋", "age" : 40 }
查询男生、女生人数，输出人数
> db.stu.aggregate([
... {$group:{_id:'$gender',counter:{$sum:1}}},
... {$project:{_id:0,counter:1}}
... ])
{ "counter" : 2 }
{ "counter" : 5 }
{ "counter" : 2 }
$sort,将输入文档排序后输出
查询学生信息，按年龄升序
> db.stu.aggregate([{$sort:{age:1}}])
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }
{ "_id" : 20201201, "name" : "欧阳锋", "age" : 40 }
查询男生、女生人数，按人数降序
> db.stu.aggregate([
... {$group:{_id:'$gender',counter:{$sum:1}}},
... {$sort:{counter:-1}}
... ])
{ "_id" : null, "counter" : 5 }
{ "_id" : 1, "counter" : 2 }
{ "_id" : 0, "counter" : 2 }
$limit,限制聚合管道返回的文档数
查询2条学生信息
db.stu.aggregate([{$limit:2}])
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
$skip,跳过指定数量的文档，并返回余下的文档
查询从第3条开始的学生信息
> db.stu.aggregate([{$skip:2}])
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }
{ "_id" : 20201201, "name" : "欧阳锋", "age" : 40 }
统计男生、女生人数，按人数升序，取第二条数据
> db.stu.aggregate([
... {$group:{_id:'$gender',counter:{$sum:1}}},
... {$sort:{counter:1}},
... {$skip:1},
... {$limit:1}
... ])
{ "_id" : 1, "counter" : 2 }
注意顺序：先写skip，再写limit
$unwind,将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值
语法1:对某字段值进行拆分,db.集合名称.aggregate([{$unwind:'$字段名称'}])
构造数据:db.t2.insert({_id:1,item:'t-shirt',size:['S','M','L']})
查询:db.t2.aggregate([{$unwind:'$size'}])
> db.t2.insert({_id:1,item:'t-shirt',size:['S','M','L']})
WriteResult({ "nInserted" : 1 })
> db.t2.find()
{ "_id" : 1, "item" : "t-shirt", "size" : [ "S", "M", "L" ] }
> db.t2.aggregate([{$unwind:'$size'}])
{ "_id" : 1, "item" : "t-shirt", "size" : "S" }
{ "_id" : 1, "item" : "t-shirt", "size" : "M" }
{ "_id" : 1, "item" : "t-shirt", "size" : "L" }
语法2:对某字段值进行拆分,处理空数组、非数组、无字段、null情况
db.inventory.aggregate([{
$unwind:{
path:'$字段名称',
preserveNullAndEmptyArrays:#防止数据丢失
}
}])
构造数据
> db.t3.insert([
... { "_id" : 1, "item" : "a", "size": [ "S", "M", "L"] },
... { "_id" : 2, "item" : "b", "size" : [ ] },
... { "_id" : 3, "item" : "c", "size": "M" },
... { "_id" : 4, "item" : "d" },
... { "_id" : 5, "item" : "e", "size" : null }
... ])
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 5,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
> db.t3.find()
{ "_id" : 1, "item" : "a", "size" : [ "S", "M", "L" ] }
{ "_id" : 2, "item" : "b", "size" : [ ] }
{ "_id" : 3, "item" : "c", "size" : "M" }
{ "_id" : 4, "item" : "d" }
{ "_id" : 5, "item" : "e", "size" : null }
使用语法1查询
> db.t3.aggregate([{$unwind:'$size'}])
{ "_id" : 1, "item" : "a", "size" : "S" }
{ "_id" : 1, "item" : "a", "size" : "M" }
{ "_id" : 1, "item" : "a", "size" : "L" }
{ "_id" : 3, "item" : "c", "size" : "M" }
查看查询结果，发现对于空数组、无字段、null的文档，都被丢弃了
使用语法2查询不丢弃呢
> db.t3.aggregate([{$unwind:{path:'$size',preserveNullAndEmptyArrays:true}}])
{ "_id" : 1, "item" : "a", "size" : "S" }
{ "_id" : 1, "item" : "a", "size" : "M" }
{ "_id" : 1, "item" : "a", "size" : "L" }
{ "_id" : 2, "item" : "b" }
{ "_id" : 3, "item" : "c", "size" : "M" }
{ "_id" : 4, "item" : "d" }
{ "_id" : 5, "item" : "e", "size" : null }
超级管理员,在mongodb中创建用户,采用了角色-用户-数据库的安全管理方式
常用系统角色如下：root：只在admin数据库中可用，超级账号，超级权限;Read：允许用户读取指定数据库;readWrite：允许用户读写指定数据库
创建超级管理用户
use admin
db.createUser({
user:'admin',
pwd:'123',
roles:[{role:'root',db:'admin'}]
})
> use admin
switched to db admin
> db.createUser({
... user:'admin',
... pwd:'123',
... roles:[{role:'root',db:'admin'}]
... })
Successfully added user: {
"user" : "admin",
"roles" : [
{
"role" : "root",
"db" : "admin"
}
]
}
启用安全认证;修改配置文件:sudo vi /etc/mongod.conf
启用身份验证,注意：keys and values之间一定要加空格, 否则解析会报错
security:
authorization: enabled
重启服务:systemctl restart mongod
终端连接: >mongo --authenticationDatabase "admin" 192.168.80.128 -u "admin" -p
MongoDB shell version v4.4.1
Enter password:
#普通用户管理,使用超级管理员登录，然后进入用户管理操作,查看当前数据库的用户
use test1
show users
创建普通用户
db.createUser({
user:'t1',
pwd:'123',
roles:[{role:'readWrite',db:'test1'}]
})
> show dbs
admin 0.000GB
config 0.000GB
local 0.000GB
test 0.000GB
> show users
{
"_id" : "admin.admin",
"userId" : UUID("de3b0cbf-7eed-40e2-aad9-078ab3f351f5"),
"user" : "admin",
"db" : "admin",
"roles" : [
{
"role" : "root",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> use test
switched to db test
> show users
> db.createUser({
... user:'t1',
... pwd:'123',
... roles:[{role:'readWrite',db:'test1'}]
... })
Successfully added user: {
"user" : "t1",
"roles" : [
{
"role" : "readWrite",
"db" : "test1"
}
]
}
> show users
{
"_id" : "test.t1",
"userId" : UUID("5ad5bcc0-0057-4a05-b49d-db7e61dbe720"),
"user" : "t1",
"db" : "test",
"roles" : [
{
"role" : "readWrite",
"db" : "test1"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
终端连接:mongo --authenticationDatabase "test1" 192.168.80.128 -u "t1" -p
> db
test
> show dbs
切换数据库，执行命令查看效果
> use admin
switched to db admin
> show users
uncaught exception: Error: not authorized on admin to execute command
修改用户：可以修改pwd、roles属性:db.updateUser('t1',{pwd:'456'})
> db.updateUser('t1',{pwd:'456'})
> db.updateUser('t1',{roles:[{role:'read', db:'test'}]})
> show users
{
"_id" : "test.t1",
"userId" : UUID("5ad5bcc0-0057-4a05-b49d-db7e61dbe720"),
"user" : "t1",
"db" : "test",
"roles" : [
{
"role" : "read",
"db" : "test"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> db
test
> show dbs
test 0.000GB
> show collections
stu
sub
t1
t2
t3
> db.stu.find()
{ "_id" : ObjectId("5fc5a87e6ecfdef1a678cf45"), "name" : "黄蓉", "gender" : 0, "age" : 16 }
{ "_id" : "20201201", "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5ab916ecfdef1a678cf46"), "name" : "欧阳克", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5ac996ecfdef1a678cf47"), "name" : "穆念慈", "gender" : 0, "age" : 18 }
{ "_id" : "20160103", "name" : "wyk", "gender" : 1, "age" : 19 }
{ "_id" : ObjectId("5fc5bc756ecfdef1a678cf4d"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bcb76ecfdef1a678cf4e"), "name" : "欧阳锋", "age" : 40 }
{ "_id" : ObjectId("5fc5bd0e6ecfdef1a678cf4f"), "id" : 20201201, "name" : "欧阳锋", "age" : 40 }
{ "_id" : 20201201, "name" : "欧阳锋", "age" : 40 }
> db.stu.save({name:"小龙女", gender:0, age: 19})
WriteCommandError({
"ok" : 0,
"errmsg" : "not authorized on test to execute command { insert: \"stu\", ordered: true, lsid: { id: UUID(\"f7675305-6efb-4561-8cb1-73e4bf5facef\") }, $db: \"test\" }",
"code" : 13,
"codeName" : "Unauthorized"
})
复制(副本集),复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性，并可以保证数据的安全性,复制还允许从硬件故障和服务中断中恢复数据
复制功能：数据备份；数据灾难恢复；读写分离；高(24* 7)数据可用性；无宕机维护；副本集对应用程序是透明
复制的工作原理：复制至少需要两个节点A、B...；A是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据
节点常见的搭配方式为：一主一从、一主多从；主节点记录在其上的所有操作，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致，主节点与从节点进行数据交互保障数据的一致性
复制的特点：N 个节点的集群；任何节点可作为主节点；所有写入操作都在主节点上；自动故障转移；自动恢复；设置复制节点
接下来的操作需要打开多个终端窗口，而且可能会连接多台服务器主机，建议在xshell中实现
step1:创建数据库目录t1、t2
在Desktop目录下演示，其它目录也可以，注意权限即可
mkdir t1
mkdir t2
step2:使用如下格式启动mongod，注意replSet的名称是一致的
mongod --bind_ip 192.168.80.128 --port 27017 --dbpath ~/t1 --replSet rs0
mongod --bind_ip 192.168.80.128 --port 27018 --dbpath ~/t2 --replSet rs0
step3:连接主服务器，此处设置192.168.80.128:27017为主服务器
mongo --host 192.168.80.128 --port 27017
step4:初始化:rs.initiate()
> rs.initiate()
{
"info2" : "no configuration specified. Using a default configuration for the set",
"me" : "192.168.80.128:27017",
"ok" : 1,
"operationTime" : Timestamp(1606808776, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1606808776, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
rs0:SECONDARY>
初始化完成后，提示符：rs.SECONDARY>
step5:查看当前状态:rs.status()
rs0:SECONDARY> rs.status()
{
"set" : "rs0",
"date" : ISODate("2020-12-01T07:46:45.053Z"),
"myState" : 1,
"term" : NumberLong(1),
"syncingTo" : "",
"syncSourceHost" : "",
"syncSourceId" : -1,
"heartbeatIntervalMillis" : NumberLong(2000),
"optimes" : {
"lastCommittedOpTime" : {
"ts" : Timestamp(1606808796, 1),
"t" : NumberLong(1)
},
"readConcernMajorityOpTime" : {
"ts" : Timestamp(1606808796, 1),
"t" : NumberLong(1)
},
"appliedOpTime" : {
"ts" : Timestamp(1606808796, 1),
"t" : NumberLong(1)
},
"durableOpTime" : {
"ts" : Timestamp(1606808796, 1),
"t" : NumberLong(1)
}
},
"lastStableCheckpointTimestamp" : Timestamp(1606808776, 6),
"electionCandidateMetrics" : {
"lastElectionReason" : "electionTimeout",
"lastElectionDate" : ISODate("2020-12-01T07:46:16.307Z"),
"electionTerm" : NumberLong(1),
"lastCommittedOpTimeAtElection" : {
"ts" : Timestamp(0, 0),
"t" : NumberLong(-1)
},
"lastSeenOpTimeAtElection" : {
"ts" : Timestamp(1606808776, 1),
"t" : NumberLong(-1)
},
"numVotesNeeded" : 1,
"priorityAtElection" : 1,
"electionTimeoutMillis" : NumberLong(10000),
"newTermStartDate" : ISODate("2020-12-01T07:46:16.310Z"),
"wMajorityWriteAvailabilityDate" : ISODate("2020-12-01T07:46:16.329Z")
},
"members" : [
{
"_id" : 0,
"name" : "192.168.80.128:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 175,
"optime" : {
"ts" : Timestamp(1606808796, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2020-12-01T07:46:36Z"),
"syncingTo" : "",
"syncSourceHost" : "",
"syncSourceId" : -1,
"infoMessage" : "",
"electionTime" : Timestamp(1606808776, 2),
"electionDate" : ISODate("2020-12-01T07:46:16Z"),
"configVersion" : 1,
"self" : true,
"lastHeartbeatMessage" : ""
}
],
"ok" : 1,
"operationTime" : Timestamp(1606808796, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1606808796, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
step6:添加复本集:rs.add('192.168.80.128:27018')
rs0:PRIMARY> rs.add('192.168.80.128:27018')
{
"ok" : 1,
"operationTime" : Timestamp(1606809312, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1606809312, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
step7:复本集添加成功后，当前状态rs.status()
rs0:PRIMARY> rs.status()
{
"set" : "rs0",
"date" : ISODate("2020-12-01T07:57:00.208Z"),
"myState" : 1,
"term" : NumberLong(1),
"syncingTo" : "",
"syncSourceHost" : "",
"syncSourceId" : -1,
"heartbeatIntervalMillis" : NumberLong(2000),
"optimes" : {
"lastCommittedOpTime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"readConcernMajorityOpTime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"appliedOpTime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"durableOpTime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
}
},
"lastStableCheckpointTimestamp" : Timestamp(1606809376, 1),
"electionCandidateMetrics" : {
"lastElectionReason" : "electionTimeout",
"lastElectionDate" : ISODate("2020-12-01T07:46:16.307Z"),
"electionTerm" : NumberLong(1),
"lastCommittedOpTimeAtElection" : {
"ts" : Timestamp(0, 0),
"t" : NumberLong(-1)
},
"lastSeenOpTimeAtElection" : {
"ts" : Timestamp(1606808776, 1),
"t" : NumberLong(-1)
},
"numVotesNeeded" : 1,
"priorityAtElection" : 1,
"electionTimeoutMillis" : NumberLong(10000),
"newTermStartDate" : ISODate("2020-12-01T07:46:16.310Z"),
"wMajorityWriteAvailabilityDate" : ISODate("2020-12-01T07:46:16.329Z")
},
"members" : [
{
"_id" : 0,
"name" : "192.168.80.128:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 790,
"optime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2020-12-01T07:56:56Z"),
"syncingTo" : "",
"syncSourceHost" : "",
"syncSourceId" : -1,
"infoMessage" : "",
"electionTime" : Timestamp(1606808776, 2),
"electionDate" : ISODate("2020-12-01T07:46:16Z"),
"configVersion" : 2,
"self" : true,
"lastHeartbeatMessage" : ""
},
{
"_id" : 1,
"name" : "192.168.80.128:27018",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 107,
"optime" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"optimeDurable" : {
"ts" : Timestamp(1606809416, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2020-12-01T07:56:56Z"),
"optimeDurableDate" : ISODate("2020-12-01T07:56:56Z"),
"lastHeartbeat" : ISODate("2020-12-01T07:56:58.769Z"),
"lastHeartbeatRecv" : ISODate("2020-12-01T07:56:58.949Z"),
"pingMs" : NumberLong(0),
"lastHeartbeatMessage" : "",
"syncingTo" : "192.168.80.128:27017",
"syncSourceHost" : "192.168.80.128:27017",
"syncSourceId" : 0,
"infoMessage" : "",
"configVersion" : 2
}
],
"ok" : 1,
"operationTime" : Timestamp(1606809416, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1606809416, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}
step8:连接第二个mongo服务:mongo --host 192.168.80.128 --port 27018
step9:向主服务器中插入数据
use test
for(i=0;i<10;i++){db.t3.insert({_id:i})}
db.t3.find()
rs0:PRIMARY> use test
switched to db test
rs0:PRIMARY> for(i=0;i<10;i++){db.t3.insert({_id:i})}
WriteResult({ "nInserted" : 1 })
rs0:PRIMARY> db.t3.find()
{ "_id" : 0 }
{ "_id" : 1 }
{ "_id" : 2 }
{ "_id" : 3 }
{ "_id" : 4 }
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
{ "_id" : 9 }
step10:在从服务器中插查询,说明：如果在从服务器上进行读操作，需要设置rs.slaveOk()
rs.slaveOk()
db.t3.find()
rs0:SECONDARY> rs.slaveOk()
WARNING: slaveOk() is deprecated and may be removed in the next major release. Please use secondaryOk() instead.
rs0:SECONDARY> db.t3.find()
{ "_id" : 0 }
{ "_id" : 2 }
{ "_id" : 1 }
{ "_id" : 3 }
{ "_id" : 4 }
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
{ "_id" : 9 }
rs0:SECONDARY> secondaryOk()
uncaught exception: ReferenceError: secondaryOk is not defined :
@(shell):1:1
rs0:SECONDARY> db.t3.find()
{ "_id" : 0 }
{ "_id" : 2 }
{ "_id" : 1 }
{ "_id" : 3 }
{ "_id" : 4 }
{ "_id" : 5 }
{ "_id" : 6 }
{ "_id" : 7 }
{ "_id" : 8 }
{ "_id" : 9 }
{ "_id" : 11 }
其它说明
删除从节点:rs.remove('192.168.80.128:27018')
关闭主服务器后，再重新启动，会发现原来的从服务器变为了从服务器，新启动的服务器(原来的从服务器)变为了从服务器
备份,语法:mongodump -h dbhost -d dbname -o dbdirectory
-h：服务器地址，也可以指定端口号
-d：需要备份的数据库名称
-o：备份的数据存放位置，此目录中存放着备份出来的数据
mkdir test1bak
[root@localhost ~]# mongodump -h 192.168.80.128:27017 -d test -o ~/test1bak --authenticationDatabase "admin" -u "admin"
Enter password:
2020-12-01T16:43:13.657+0800 writing test.t1 to
2020-12-01T16:43:13.657+0800 writing test.stu to
2020-12-01T16:43:13.657+0800 writing test.t3 to
2020-12-01T16:43:13.657+0800 writing test.sub to
2020-12-01T16:43:13.731+0800 done dumping test.stu (9 documents)
2020-12-01T16:43:13.731+0800 writing test.t2 to
2020-12-01T16:43:13.736+0800 done dumping test.t1 (15 documents)
2020-12-01T16:43:13.763+0800 done dumping test.t3 (5 documents)
2020-12-01T16:43:13.763+0800 done dumping test.sub (4 documents)
2020-12-01T16:43:13.769+0800 done dumping test.t2 (1 document)
恢复,语法:mongorestore -h dbhost -d dbname --dir dbdirectory
-h：服务器地址
-d：需要恢复的数据库实例
--dir：备份数据所在位置
mongorestore -h 192.168.80.128:27017 -d test2 --dir ~/test1bak/test
[root@localhost test1bak]# mongorestore -h 192.168.80.128:27017 -d test2 --dir ~/test1bak/test --authenticationDatabase "admin" -u "admin"
Enter password:
2020-12-01T16:47:41.389+0800 the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead
2020-12-01T16:47:41.390+0800 building a list of collections to restore from /root/test1bak/test dir
2020-12-01T16:47:41.412+0800 reading metadata for test2.stu from /root/test1bak/test/stu.metadata.json
2020-12-01T16:47:41.455+0800 reading metadata for test2.t1 from /root/test1bak/test/t1.metadata.json
2020-12-01T16:47:41.455+0800 reading metadata for test2.t3 from /root/test1bak/test/t3.metadata.json
2020-12-01T16:47:41.455+0800 reading metadata for test2.sub from /root/test1bak/test/sub.metadata.json
2020-12-01T16:47:41.455+0800 restoring test2.stu from /root/test1bak/test/stu.bson
2020-12-01T16:47:41.534+0800 restoring test2.t3 from /root/test1bak/test/t3.bson
2020-12-01T16:47:41.535+0800 restoring test2.t1 from /root/test1bak/test/t1.bson
2020-12-01T16:47:41.580+0800 no indexes to restore
2020-12-01T16:47:41.580+0800 finished restoring test2.stu (9 documents)
2020-12-01T16:47:41.580+0800 reading metadata for test2.t2 from /root/test1bak/test/t2.metadata.json
2020-12-01T16:47:41.580+0800 restoring test2.sub from /root/test1bak/test/sub.bson
2020-12-01T16:47:41.616+0800 no indexes to restore
2020-12-01T16:47:41.616+0800 finished restoring test2.t3 (5 documents)
2020-12-01T16:47:41.619+0800 no indexes to restore
2020-12-01T16:47:41.619+0800 finished restoring test2.t1 (15 documents)
2020-12-01T16:47:41.630+0800 no indexes to restore
2020-12-01T16:47:41.630+0800 finished restoring test2.sub (4 documents)
2020-12-01T16:47:41.630+0800 restoring test2.t2 from /root/test1bak/test/t2.bson
2020-12-01T16:47:41.687+0800 no indexes to restore
2020-12-01T16:47:41.687+0800 finished restoring test2.t2 (1 document)
2020-12-01T16:47:41.687+0800 done
"""
#与python交互
#安装python包,进入虚拟环境,pip install pymongo或源码安装python setup.py
#引入包pymongo
import pymongo
#连接，创建客户端
#client=pymongo.MongoClient(host="192.168.80.128", port=27017)
client=pymongo.MongoClient('mongodb://admin:123@192.168.80.128:27017/')
#获得数据库test1
db=client.test
#获得集合stu
stu = db.stu
#添加文档
#s1={'name':'gj', 'age':18}
#s1_id = stu.insert_one(s1).inserted_id
#查找一个文档
s2=stu.find_one()
print(s2)#{'_id': ObjectId('5fc5a87e6ecfdef1a678cf45'), 'name': '黄蓉', 'gender': 0.0, 'age': 16.0}
#查找多个文档1
for cur in stu.find():
print(cur)
"""
{'_id': ObjectId('5fc5a87e6ecfdef1a678cf45'), 'name': '黄蓉', 'gender': 0.0, 'age': 16.0}
{'_id': '20201201', 'name': '欧阳锋', 'age': 40.0}
{'_id': ObjectId('5fc5ab916ecfdef1a678cf46'), 'name': '欧阳克', 'gender': 1.0, 'age': 19.0}
{'_id': ObjectId('5fc5ac996ecfdef1a678cf47'), 'name': '穆念慈', 'gender': 0.0, 'age': 18.0}
{'_id': '20160103', 'name': 'wyk', 'gender': 1.0, 'age': 19.0}
{'_id': ObjectId('5fc5bc756ecfdef1a678cf4d'), 'name': '欧阳锋', 'age': 40.0}
{'_id': ObjectId('5fc5bcb76ecfdef1a678cf4e'), 'name': '欧阳锋', 'age': 40.0}
{'_id': ObjectId('5fc5bd0e6ecfdef1a678cf4f'), 'id': 20201201.0, 'name': '欧阳锋', 'age': 40.0}
{'_id': 20201201.0, 'name': '欧阳锋', 'age': 40.0}
{'_id': ObjectId('5fc60608ebce63c848d751a3'), 'name': 'gj', 'age': 18}
"""
#查找多个文档2
cur=stu.find()
print(cur.next())#{'_id': ObjectId('5fc5a87e6ecfdef1a678cf45'), 'name': '黄蓉', 'gender': 0.0, 'age': 16.0}
print(cur.next())#{'_id': '20201201', 'name': '欧阳锋', 'age': 40.0}
print(cur.next())#{'_id': ObjectId('5fc5ab916ecfdef1a678cf46'), 'name': '欧阳克', 'gender': 1.0, 'age': 19.0}
#获取文档个数
print(stu.count())#10,不推荐使用
print(stu.count_documents({}))#10
print(stu.estimated_document_count())#10
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
