MongoDB数据库的使用

MongoDB是一个基于分布式 文件存储的NoSQL数据库,适合存储JSON风格文件的形式。

  • 三元素:数据库、集合和文档。

    • 文档:对应着关系数据库中的行,就是一个对象,由键值对构成,是json的扩展Bson形式,示例
      {name:guojing,gender:}
    • 集合:类似于关系数据库中的表,储存多个文档,结构不固定,示例
      {name:guojing,gender:}
      {name:huangrong,age:18}
      {book:shuihuzhuan,heros:108}

一、环境安装与运行

  • 安装

    sudo apt-get install mongodb

  配置文件为 /etc/mongodb.conf,默认端口号:27017

  • 启动服务器

    sudo service mongodb start  #相当于执行命令 sudo mongod --config /etc/mongod.conf
  • 关闭服务器

    sudo service mongodb stop
  • 重启服务器

    sudo service mongodb restart #修改了配置文件/etc/mongodb.conf后,需要重启mongodb服务器让配置生效
  • 启动客户端

    sudo mongo

二、数据库操作

  • 查看当前数据库

    db
  • 查看所有数据库

    show dbs
  • 切换(或创建)数据库

    use 数据库名

    切换数据库,如果数据库不存在,当插入数据或创建集合时,会自动创建这个数据库

  • 删除数据库

    db.dropDatabase()

    删除当前指向的数据库,如果不存在,则什么也不做

三、集合操作

  • 创建

    db.createCollection(name[,options])
    #name集合名称
    #options可选,是一个用于指定集合配置的文档,其中capped参数默认不设置上限(false),若设置上限(true)则需要指定参数size,单位字节
    #不设置集合大小
    db.createCollection("stu")
    #设置集合大小
    db.createCollection("sub", { capped : true, size : 10 } )
  • 查看当前数据库集合

    show collections
  • 删除集合

    db.集合名.drop()

四、数据操作

  • 插入

    db.集合名.insert(文档) 或 db.集合名.insert([文档...])
    #如果不指定_id字段,则分配一个唯一的ObjectId;如果指定_id字段,且_id已经存在时,不做任何操作;如果一次性插入多条数据,以数组的方式传入文档
    # 不指定_id
    db.stu.insert({name:gj,gender:1})
    
    #指定_id
    s1={_id:20160101,name:hr}
    s1.gender=0
    db.stu.insert(s1)
  • 删除--(注意justOne参数)

    db.集合名.remove(条件,{justone:<boolean>}) #参数justOne默认false,删除多条
    # 只删除匹配到的一条数据
    db.stu.remove({gender:0},{justOne:true})
    
    #删除所有
    db.stu.remove({})
  • 修改--(注意$set以及multi参数)

    db.集合名.update({条件},$操作符,{multi: <boolean>}]) #参数multi只和$操作符一起使用,默认false,只修改一条数据,true表示修改多条数据
    # 不使用操作符$set,修改整条文档
    db.stu.update({name:hr},{name:mnc})
    
    #使用操作符$set指定属性修改
    db.stu.update({name:hr},{$set:{name:hys}})
    
    #multi参数和$set一起使用,修改多条文档
    db.stu.update({},{$set:{gender:0}},{multi:true})
  • 保存

    db.集合名.save(document) 
    #在手动插入_id字段时,如果_id已经存在,做全文档更新操作,其余均表示插入数据。
    db.stu.save({_id:20160102,name:yk,gender:1})
    db.stu.save({_id:20160102,name:wyk}) #对上述文档做修改
  • 查询

    • 基本查询

      db.集合名.find({条件文档}) #查询所有
      db.集合名.findOne({条件文档}) #只查询第一条
      db.集合名.find({条件文档}).pretty() #结果格式化输出
    • 比较运算符

      • 等于:默认,没有运算符
      • 小于: $lt
      • 小于等于: $lte
      • 大于:$gt
      • 大于等于:$gte
      • 不等于:$ne
        #查询年龄大于等于18的学生
        db.stu.find({"age":{$gte:18}})
    • 逻辑运算符

      • 逻辑与:默认
      • 逻辑或:$or
        # 查询年龄大于或等于18,并且性别为1的学生
        db.stu.find({"age":{$gte:18},"gender":1})
        
        #查询年龄大于18,或性别为0的学生
        db.stu.find({$or:[{"age":{$gt:18}},{"gender":1}]})
        
        #查询年龄小于18或者大于20,性别为1的学生
        db.stu.find({$or:[{"age":{$lt:18}},{"age":{$gt:20}}],"gender":1})
    • 范围运算符

      • 在某个范围$in,后面接数组
      • 不在某个范围$nin,后面接数组
        #查询年龄18、20以及22岁的学生
        db.stu.find({"age":{$in:[18,20,22]}})
        
        #查询年龄不等于18或20的学生
        db.stu.find({"age":{$nin:[18,20]}})
    • 正则表达式

      • 使用/表达式/或者$regex
        #查询姓黄的学生
        db.stu.find({"name":/^黄/})
        db.stu.find({"name":{$regex:"^黄"}})
    • 自定义查询

      • 使用$where:function(){return 满足条件的数据表达式}------运算符使用js语法,比如逻辑与(&&),逻辑或(||)
        #查询年龄18-22的学生
        db.stu.find({$where:function(){return this.age>18 && this.age<22}})
        
        #查询年龄小于18或者大于22的学生
        db.stu.find({$where:function(){return this.age<18 || this.age>22}})
    • 投影

      • 只显示部分字段
        db.集合名.find({条件},{字段名:1,...}) #1表示该字段显示,0不显示;_id列默认显示,不显示需要明确设置为0
        #查询姓名和年龄(显示_id)
        db.stu.find({},{name:1,gender:1})
        
        #查询姓名和年龄(不显示_id)
        db.stu.find({},{_id:0,name:1,gender:1})
    • skip

      • 跳过指定数量的文档
        db.集合名.find({条件}).skip(number) #number默认为0
        #查询从第3条开始的学生信息
        db.stu.find().skip(2)
    • limit

      • 读取指定数量的文档
        db.集合名.find({条件}).limit(number) #不写number参数,默认读取所有文档
        #读取3条学生信息
        db.stu.find().limit(3)
    • skip和limit合用

      • 不区分先后顺序
        #查询第5-9条学生信息
        db.stu.find().skip(4).limit(5) #相当于跳过4条数据,选5条
    • sort

      • 对结果集进行排序
        db.集合名称.find({条件}).sort({字段:1,...}) #1表示升序,-1表示降序
        #根据性别降序,再根据年龄升序
        db.stu.find().sort({"gender":-1,"age":1})
    • count

      • 对结果集中文档数目进行统计,返回整数
        db.集合名.find({条件}).count() 
        或者 
        db.集合名.count({条件})
        #统计年龄大于20的男生人数
        db.stu.count({"age":{$gt:20},"gender":1})
    • distinct

      • 对数据去重,返回的是一个列表
        db.集合名.distinct("字段名",{条件}) 

五、聚合(aggregate)

  • 聚合主要用于计算数据,类似sql中的sum()、avg()

    db.集合名.aggregate([{管道:{表达式}}...])
  • 管道

    • 文档处理完毕后,通过管道进行下一次处理

    • 常用管道:

      • $group:将集合中的文档分组,可用于统计结果
      • $match:过滤数据,只输出符合条件的文档
      • $project:修改输入文档的结构,如重命名、增加、删除字段、创建计算结果
      • $sort:将输入文档排序后输出
      • $limit:限制聚合管道返回的文档数
      • $skip:跳过指定数量的文档,并返回余下的文档
      • $unwind:将数组类型的字段进行拆分
  • 表达式

    • 处理输入文档并输出

    • 语法:表达式:‘$字段名’

    • 常用表达式:

      • $sum:计算总和,$sum:‘$字段‘表示求和,注意$sum:1表示计数,
      • $avg:计算平均值
      • $min:获取最小值
      • $max:获取最大值
      • $push:在结果文档中插入值到一个数组中(以列表的方式显示字段值)
      • $first:根据资源文档的排序获取第一个文档数据
      • $last:根据资源文档的排序获取最后一个文档数据
  • $group

    • 文档分组,用于统计结果
    • _id表示分组的依据,使用某个字段的格式为‘$字段‘
      # 统计男、女生人数
      db.stu.aggregate([{$group:{"_id":gender,"couter":{$sum:1}}}])
      #结果文档中显示_id和counter的值
    • _id按照null分组,会将集合中所有文档分为一组
      # 求学生总人数和平均年龄
      db.stu.aggregate([{$group:{_id:null,counter:{$sum:1},average_age:{$avg:"$age"}}}])
    • 使用$$ROOT可以将文档内容加入到结果集的数组中
      #统计男、女生信息
      db.stu.aggregate([{$group:{_id:"$gender",objects:{$push:"$$ROOT"}}}])
  • $match

    • 过滤数据,输出符合条件文档
      #查询年龄大于20的学生
      db.stu.aggregate([{$match:{age:{$gt:20}}}])
      
      #查询年龄大于20的男、女生人数
      db.stu.aggregate([{$match:{age:{$gt:20}}},{$group:{_id:"$gender",counter:{$sum:1}}}])
  • $project

    • 修改输出文档的结构
      #查找学生姓名、年龄
      db.stu.aggregate([{$project:{"_id":0,"name":1,"age":1}}])
      
      #查询男生、女生人数,但仅输出人数
      db.stu.aggregate([{$group:{_id:$gender,counter:{$sum:1}}},{$project:{_id:0,counter:1}}])
  • $sort

    • 将输入文档排序后输出
      #查询学生信息,按年龄升序
      db.stu.aggregate([{$sort:{age:1}}])
      
      #查询男生、女生人数,按人数降序
      db.stu.aggregate([{$group:{_id:$gender,counter:{$sum:1}},{$sort:{counter:-1}}])
  • $limit

    • 限制聚合管道返回的文档数
      #查询2条学生信息
      db.stu.aggregate([{$limit:2}])
  • $skip

    • 跳过指定数量的文档,并返回余下的文档,$skip和$limi合用时,注意先写skip,再写limit
      #查询从第3条开始的学生信息
      db.stu.aggregate([{$skip:2}])
      
      #统计男生、女生人数,按人数升序,取第二条数据
      db.stu.aggregate([{$group:{_id:"$gender",counter:{$sum:1}}},{$sort:{"counter":1}},{$skip:1},{$limit:1}])
  • $unwind

    • 将文档中的某一个数组类型字段拆分成多条,每条包含数组中的一个值
      db.集合名称.aggregate([{$unwind:$字段名称}]) 

六、索引

  • 提升查询速度

  • 创建大量数据

    for(var i=0;i<1000000;i++){db.stu.insert({name:test+i,num:i})}
  • 性能分析工具:explain("executionStats")

    查询语句.explain("executionStats")

    ‘millis‘后面显示的是查询时间,单位ms

  • 建立索引

    db.集合.ensureIndex({属性:1或-1}) #1表示升序,-1表示降序,建立后的索引名称为"属性_1"或者"属性_-1"

    例如:db.stu.ensureIndex({name:1}),建立后的索引名称为"name_1"

  • 建立唯一索引

    db.集合.ensureIndex({属性:1},{"unique":true})
  • 建立联合索引

    db.集合名.ensureIndex({属性1:1,属性2:1...})
  • 查看索引

    db.集合名.getIndexes()
  • 删除索引

    db.集合名.dropIndex("索引名称") 

七、数据库安全

为了更安全的访问mongodb,需要访问者提供用户名和密码,于是需要在mongodb中创建用户。mongodb数据库采用了角色-用户-数据库的安全管理方式。

  • 常用系统角色如下:

    • root:只在admin数据库中可用,超级账号,超级权限
    • Read:允许用户读取指定数据库
    • readWrite:允许用户读写指定数据库
  • 创建超级管理用户:

    use admin #首先切换到admin数据库
    
    db.createUser({
        user:用户名,
        pwd:密码,
        roles:[{role:root,db:admin}]
    })
  • 启用安全验证

    • 修改配置文件( /etc/mongodb.conf)

      #noauth = true
      auth = true #开启安全验证
    • 重启服务

      sudo service mongodb restart
    • 终端连接

      # sudo mongo -u ‘用户名‘ -p ‘密码‘ --authenticationDatabase ‘数据库名‘ 
      sudo mongo -u admin -p 密码 --authenticationDatabase admin
  • 普通用户管理

    • 首先使用超级管理员登陆,然后再进行用户管理操作

    • 创建普通用户

      db.createUser({
          user:用户名,
          pwd:密码,
          roles:[{role:readWrite,db:数据库名}...] #数组里可以有多个角色文档,比如用户在不同的数据库里都有读写权限
      })
    • 查看当前数据库的用户

      show users
    • 修改用户:可以修改pwd、roles属性

      db.updateUser(用户名,{pwd:新密码,roles:[{新角色}...]})
    • 删除用户

      use admin  #切换到admin数据库
      db.system.users.remove(条件)
    • 终端连接

       sudo mongo -u 用户名 -p 密码 --authenticationDatabase 数据库名 

八、复制

复制提供了数据的冗余备份,并在多个服务器上存储数据的副本,允许从硬件故障和服务中断中恢复数据,能够实现无宕机维护(自动故障转移与自动恢复)。

复制至少需要2个节点,其中1个为主节点,其它均为从节点。任何节点均可以成为主节点。

主节点负责所有写入操作,从节点定期轮询主节点获取这些操作并执行这些操作,从而保证从节点的数据与主节点一致。

  • 设置复制节点

    • 创建数据库文件存放目录(自定义)

      mkdir ~/Desktop/t1
      mkdir ~/Desktop/t2
    • 使用如下格式启动mongod,如果在同一台主机上,注意port不能相同,replSet的名称必须是一致的(名称可以自定义)

      sudo mongod --bind_ip 192.168.196.128 --port 27017 --dbpath ~/Desktop/t1 --replSet rs0
      sudo mongod --bind_ip 192.168.196.128 --port 27018 --dbpath ~/Desktop/t2 --replSet rs0
    • 连接主服务器(自定义一个)

      sudo mongo --host 192.168.196.128 --port 27017
    • 初始化

      rs.initiate()

      哪个服务器执行初始化,哪个服务器就作为主节点,rs是mongo服务器中专门用于复本集操作的内置对象

    • 查看当前状态

      rs.status()
    • 添加副本集

      rs.add("192.168.127.128:8899")
    • 连接从服务器

      sudo mongo --host 192.168.196.128 --port 27018
    • 从服务器设置

      rs.slaveOk()

      主服务器插入数据,从服务器就可以读取数据了

    • 删除从节点

      rs.remove(192.168.196.128:27018) #需要在主服务器操作

      关闭主服务器后再重新启动,会发现原来的从服务器变为了主服务器,新启动的服务器(原来的主服务器)变为了从服务器,但是注意重新设置rs.slaveOk()

九、备份与恢复

  • 备份

    • 语法

      sudo mongodump -h 服务器地址 -d 需要备份的数据库 -o 备份数据存放目录
      mkdir ~/Desktop/test1_bak #创建存放备份数据的目录
      sudo mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1_bak
  • 恢复

    • 语法

      sudo mongorestore -h 服务器地址 -d 恢复后数据库名 --dir 备份数据所在位置
      sudo mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1_bak/test1

十、python交互

  • 安装pymongo包

    sudo pip3 install pymongo
  • 引入包

    import pymongo
  • 建立连接并创建客户端

    有安全认证:client=MongoClient("mongodb://用户名:密码@host:27017/数据库名称")
    无安全认证:client=MongoClient("mongodb://localhost: 27017")
  • 获得数据库(以test数据库为例)

    db = client.数据库名
    例如:db = client.test
  • 获得集合stu

    stu = db.stu
  • 数据操作

    • 查询

      • find_one 查找单个文档
        stu1 = stu.find_one({条件}) #返回一条文档,字典类型
      • find 查找多个文档
        cursor = stu.find({条件}) #返回迭代器对象cursor
        #方式1:用for循环迭代取值
        for s in cursor:
        print(s) #字典类型
        
        #方式2:用next取值
        s1 = next(cursor)
        s2 = next(cursor)
        ...
    • 插入

      • insert_one 插入一条文档
        stu.insert_one(文档)
      • insert_many 插入多条文档
        stu.insert_many([文档1,文档2...])
    • 更新

      • update 更新匹配到的第一条整条文档
        stu.update({条件},文档) #注意条件中的数字一定要写成字符串类型
      • update_one 与$set一起使用,指定属性修改匹配到的第一条文档
        stu.update_one({条件},{$set:{文档}})
      • update_many 与$set一起使用,指定属性修改多条文档
        stu.update_many({条件},{$set:{文档}})
    • 删除

      • delete_one 删除单条文档
        stu.delete_one({条件})
      • delete_many 删除多条文档
        stu.delete_many({条件})

         






MongoDB数据库的使用

上一篇:Redis:持久化篇一(RDB)


下一篇:基于python-flask的数据库可视化系统(增删改查)