zoukankan      html  css  js  c++  java

  • 004.MongoDB数据库基础使用

    一 数据库管理

    1.1 创建数据库

      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use admin
  3 > db.grantRolesToUser( "useradmin",[{ role: "dbOwner",db:"mydb" }])	#授权
  4 > use mydb					#若存在mymongodb则切换，若不存在则创建
  5 > show dbs
  6 admin   0.000GB
  7 config  0.000GB
  8 local   0.000GB
  9 > db.age01.insert({"name": "xianghongying"})
 10 WriteResult({ "nInserted" : 1 })		#输出信息
 11 > show dbs
 12 admin   0.000GB
 13 config  0.000GB
 14 local   0.000GB
 15 mydb    0.000GB
     
    提示：新创建的数据库，若需要显示需要向该数据库中创建集合，同时集合只有在内容插入后才会创建，即创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建。

    1.2 删除数据库

      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 switched to db mydb				#输出信息
  4 > db.dropDatabase()
  5 { "dropped" : "mydb", "ok" : 1 }
     

    二 集合管理

    2.1 创建集合

    语法格式：
      1 db.createCollection(name, options)
    参数说明：
    • name: 要创建的集合名称
    • options: 可选参数, 指定有关内存大小及索引的选项
    options 可以是如下参数：
    字段

     

    类型

     

    描述
    capped
    布尔
    （可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。
    当该值为 true 时，必须指定 size 参数。
    autoIndexId
    布尔
    （可选）如为 true，自动在 _id 字段创建索引。默认为 false。
    size
    数值
    （可选）为固定集合指定一个最大值（以字节计）。
    如果 capped 为 true，也需要指定该字段。
    max
    数值
    （可选）指定固定集合中包含文档的最大数量。
    在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。
      1 > use mydb
  2 > db.createCollection("age01")
  3 { "ok" : 1 }				#输出信息
  4 > show tables				#也可使用show collections
  5 age01
  6 > db.createCollection("age02",{ capped: true, autoIndexId : true, size: 6142800, max: 10000})
  7 {
  8         "note" : "the autoIndexId option is deprecated and will be removed in a future release",
  9         "ok" : 1
 10 }
 11 #创建固定集合 age02，整个集合空间大小 6142800 KB, 文档最大个数为 10000 个。
 12 > db.age03.insert({"name": "xianghongying","age": "18"})
 13 WriteResult({ "nInserted" : 1 })
 14 > show tables
 15 age01
 16 age02
 17 age03
     
    提示：MongoDB中可直接插入文档，即可自动创建集合。

    2.2 删除集合

    语法格式：
      1 db.collection.drop()
    提示：如果成功删除选定集合，则 drop() 方法返回 true，否则返回 false。
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > show tables
  4 age01
  5 age02
  6 age03
  7 > db.age03.drop()
  8 true
  9 > show tables
 10 age01
 11 age02
     

    三 文档管理

    3.1 插入文档

    文档的数据结构和 JSON 基本一样。
    所有存储在集合中的数据都是 BSON 格式。
    BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。
    语法格式：
      1 db.COLLECTION_NAME.insert(document)
  2 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  3 > use mydb
  4 > db.age01.insert({name: 'zhangsan',
  5 age: '18',
  6 tel: '123456781',
  7 love: ['apple','banana']
  8 })
  9 WriteResult({ "nInserted" : 1 })		#输出信息
     
    提示：MongoDB插入文档的时候，如果该集合不在该数据库中，MongoDB 会自动创建该集合并插入文档。

    3.2 查看文档

      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find()
  4 > db.age01.find().pretty()
     
    001
    将数据定义为一个变量，然后插入此变量的方式插入文档。
      1 > lisi_age=({name: 'lisi', age: '19', tel: '123456782', love: ['apple','orange']})
  2 > db.age01.insert(lisi_age)
  3 WriteResult({ "nInserted" : 1 })		#输出信息
  4 > db.age01.find().pretty()
     
    002

    3.3 其他方式

    向指定集合中插入一条文档数据。
      1 > db.age01.insertOne({name: 'wanger', age: '15', tel: '123456783', love: ['pear','orange']})
  2 向指定集合中插入多条文档数据。
  3 > db.age01.insertMany([{name: 'mazi', age: '15', tel: '123456784', love: ['pear','apple']},{name: 'xiaoming', age: '8', tel: '123456785', love: ['apple','grape']}])
     
    003
      1 > db.age01.find().pretty()
    004

    四 更新文档

    4.1 update方法

    update() 方法用于更新已存在的文档。
    语法格式：
      1 db.collection.update(
  2    <query>,
  3    <update>,
  4    {
  5      upsert: <boolean>,
  6      multi: <boolean>,
  7      writeConcern: <document>
  8    }
  9 )
     
    参数说明：
    • query : update的查询条件，类似sql update查询的where所跟的条件。
    • update : update的对象和一些更新的操作符（如$,$inc...）等，类似sql update查询的set所跟的更新操作。
    • upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
    • multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true，就把按条件查出来多条记录全部更新。
    • writeConcern :可选，抛出异常的级别。
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.update({name: "xiaoming"},{$set:{love: ['strawberry','orange']}})
  4 WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })	#输出信息
  5 > db.age01.find().pretty()
    005
      1 > db.age01.update({age: '15'},{$set:{tel: '133333333'}},{multi:true})	#修改多条
  2 WriteResult({ "nMatched" : 2, "nUpserted" : 0, "nModified" : 2 })
  3 > db.age01.find().pretty()
     
    006

    4.2 save方法

    save() 方法通过传入的文档来替换已有文档。
    语法格式：
      1 db.collection.save(
  2    <document>,
  3    {
  4      writeConcern: <document>
  5    }
  6 )
     
    参数说明：
    • document : 文档数据。
    • writeConcern :可选，抛出异常的级别。
      1 > db.age01.save({_id: ObjectId("5ceb9b2785cdc85ba0f3d6a3"),name: 'zhangsan', age: '14', tel: '155555555', love: ['peach','waxberry']})
  2 WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })	#输出信心
  3 > db.age01.find().pretty()
     
    007

    4.3 其他方式

    向指定集合中更新一条文档数据。
      1 > db.age01.updateOne({name: 'lisi'}, {$set:{age: '28'}})
  2 { "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
     
    向指定集合中更新多条文档数据。
      1 > db.age01.updateMany({age: {$gt: '15'}}, {$set:{tel: '188888888'}})
  2 { "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }
     
     
    只更新第一条记录：
      1 db.col.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } );
    全部更新：
      1 db.col.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true );
    只添加第一条：
      1 db.col.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false );
    全部添加进去:
      1 db.col.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true );
    全部更新：
      1 db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
    只更新第一条记录：
      1 db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

    五 删除文档

    5.1 删除文档

    remove() 方法的基本语法格式如下所示：
      1 db.collection.remove(
  2    <query>,
  3    {
  4      justOne: <boolean>,
  5      writeConcern: <document>
  6    }
  7 )
     
    参数说明：
    • query :（可选）删除的文档的条件。
    • justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，表示删除所有匹配条件的文档。
    • writeConcern :（可选）抛出异常的级别
    提示：建议在执行remove()函数前先执行find()命令来判断执行的条件是否正确。
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find().pretty()
     
    008
    向指定集合中删除一条文档数据。
      1 > db.age01.deleteOne({"name" : "xiaoming"})
  2 WriteResult({ "nRemoved" : 1 })
  3 > db.age01.find().pretty()
     
    009
    向指定集合中删除多条文档数据。
      1 > db.age01.deleteMany({tel: '133333333'})
  2 { "acknowledged" : true, "deletedCount" : 2 }
     
    向指定集合中删除全部文档数据。
      1 > db.collection.deleteMany({})
    提示：新版MongoDB也支持旧版remove()方式删除（官方不建议）。但remov并不会真正释放空间，需要执行db.repairDatabase()回收磁盘空间。

    六 查询文档

    6.1 简单查询

    MongoDB 查询文档使用 find() 方法。
    find() 方法以非结构化的方式来显示所有文档。
    语法格式：
      1 db.collection.find(query, projection)
    参数说明：
    • query ：可选，使用查询操作符指定查询条件。
    • projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。
    以易读的方式来读取数据，可以使用 pretty() 方法，语法格式：
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find().pretty()		#pretty() 方法以格式化的方式来显示所有文档
     
    010

    6.2 多个条件

    MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。
    语法格式：
      1 > db.collection.find({key1:value1, key2:value2}).pretty()
  2 > db.age01.find({age: {$gt:'10'}, tel: '188888888'}).pretty()
     
    011
    MongoDB 的 find() 方法可以传入多个键(key)，使用关键字 $or,，即常规 SQL 的 OR 条件。
    语法格式：
      1 > db.col.find(
  2    {
  3       $or: [
  4          {key1: value1}, {key2:value2}
  5       ]
  6    }
  7 ).pretty()
  8 > db.age01.find({$or:[{age: {$gt: '14'}},{tel: '188888888'}]}).pretty()
     
    012
    MongoDB 支持多个条件联合使用，AND 和 OR 联合使用，类似常规 SQL 语句为： 'where likes >50 AND (name = 'zhangsna' OR tel = '188888888')'
      1 > db.age01.find({age: {$gt: '10'},$or:[{name: 'zhangsan'},{tel: '188888888'}]}).pretty()
    013
    控制查询范围： 查询大于15，小于28岁。
      1 > db.age01.find({age: {$gt: '14',$lt: '28'}}).pretty()
    014
    控制查询匹配后需要显示的数据：
      1 > db.age01.find({name: 'zhangsan'},{name: 1, age: 1}).pretty()	#仅显示name和age
  2 {
  3         "_id" : ObjectId("5ceb9b2785cdc85ba0f3d6a3"),
  4         "name" : "zhangsan",
  5         "age" : "14"
  6 }
  7 > db.age01.find({name: 'zhangsan'},{name: 0}).pretty()		#不显示name
  8 {
  9         "_id" : ObjectId("5ceb9b2785cdc85ba0f3d6a3"),
 10         "age" : "14",
 11         "tel" : "155555555",
 12         "love" : [
 13                 "peach",
 14                 "waxberry"
 15         ]
 16 }
     
    解释：inclusion模式 指定返回的键，不返回其他键，exclusion模式 指定不返回的键,返回其他键。默认ID都返回。
    两种模式不可混用（因为这样的话无法推断其他键是否应返回），只能全1或全0，除了在inclusion模式时可以指定_id为0。

    七 条件操作符

    7.1 相关条件

    操作
    格式
    范例
    RDBMS中的类似语句
    等于
    {<key>:<value>}
    db.col.find({"by":"中国"}).pretty()
    where by = '中国'
    小于
    {<key>:{$lt:<value>}}
    db.col.find({"likes":{$lt:50}}).pretty()
    where likes < 50
    小于或等于
    {<key>:{$lte:<value>}}
    db.col.find({"likes":{$lte:50}}).pretty()
    where likes <= 50
    大于
    {<key>:{$gt:<value>}}
    db.col.find({"likes":{$gt:50}}).pretty()
    where likes > 50
    大于或等于
    {<key>:{$gte:<value>}}
    db.col.find({"likes":{$gte:50}}).pretty()
    where likes >= 50
    不等于
    {<key>:{$ne:<value>}}
    db.col.find({"likes":{$ne:50}}).pretty()
    where likes != 50
    		 
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find({age: {$gt: '20'}}).pretty()
     
    015
      1 > db.age01.find({age: {$gte: '15'}}).pretty()
    016
      1 > db.age01.find({age: {$lt: '15'}}).pretty()
    017
      1 > db.age01.find({age: {$lte: '15'}}).pretty()
    018
      1 > db.age01.find({age: {$lt: '18',$gt: '10'}}).pretty()
    019
    模糊查询
    操作
    格式
    范例
    包含
    /<value>/
    db.col.find({title:/zhangsan/})
    以……开头
    /^<value>/
    db.col.find({title:/^zhangsan/})
    以……结尾
    /<value>$/
    db.col.find({title:/zhangsan$/})
    		 
      1 > db.age01.find({love: /apple/}).pretty()
    020
      1 > db.age01.find({tel: /^188/}).pretty()
    021
      1 > db.age01.find({tel: /88$/}).pretty()

    八 MongoDB操作符

    8.1 操作符

    $type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。
    MongoDB 中可以使用的类型如下表所示：
    类型
    数字
    备注
    Double
    1
     
    String
    2
     
    Object
    3
     
    Array
    4
     
    Binary data
    5
     
    Undefined
    6
    已废弃。
    Object id
    7
     
    Boolean
    8
     
    Date
    9
     
    Null
    10
     
    Regular Expression
    11
     
    JavaScript
    13
     
    Symbol
    14
     
    JavaScript (with scope)
    15
     
    32-bit integer
    16
     
    Timestamp
    17
     
    64-bit integer
    18
     
    Min key
    255
    Query with -1.
    Max key
    127
     
    		 
      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find({tel: {$type: 2}}).pretty()
  4 > db.age01.find({tel: {$type: 'string'}}).pretty()
     

    九 限定数量查询

    9.1 MongoDB Limit() 方法

    若需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。
    语法格式：
      1 >db.COLLECTION_NAME.find().limit(NUMBER)
  2 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  3 > use mydb
  4 > db.age01.find({tel: /^188/}).limit(1).pretty()
     
    022
    提示：若没有指定limit()方法中的参数则显示集合中的所有数据。

    9.2 MongoDB Skip() 方法

    除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。
    语法格式：
      1 > db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
  2 > db.age01.find({love: /apple/}).pretty()
     
    023
      1 > db.age01.find({love: /apple/}).limit(2).skip(1).pretty()
    024
    提示：skip默认为跳过第一条数据。

    十 MongoDB排序

    10.1 MongoDB sort() 方法

    在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。
    语法格式：
      1 > db.COLLECTION_NAME.find().sort({KEY:1})
  2 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  3 > use mydb
  4 > db.age01.find().sort({age: 1}).pretty()
     
    025
    提示：skip(), limilt(), sort()一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()。

    十一 其他查询技巧

    11.1 查询说明

      1 [root@uhost ~]# mongo --host 172.24.9.225 --port 27017 -u useradmin -p useradmin
  2 > use mydb
  3 > db.age01.find({},{name: 1, _id: 0}).limit(2)

    说明：

    第一个 {} 为 where 条件，为空表示返回集合中所有文档。

    第二个 {} 指定那些列显示和不显示 （0表示不显示 1表示显示)。

    11.2 范围读取

    想要读取从 10 条记录后 100 条记录，相当于 sql 中limit (10,100)。

      1 > db.COLLECTION_NAME.find().skip(10).limit(100)

    以上实例在集合中跳过前面 10 条返回 100 条数据。

    提示：skip 和 limit 结合就能实现分页。

    11.3 skip说明

    kip和limit方法只适合小数据量分页，如果是百万级效率就会非常低，因为skip方法是一条条数据数过去的，建议使用where_limit。不要轻易使用Skip来做查询，否则数据量大了就会导致性能急剧下降，这是因为Skip是一条一条的数过来的，多了自然就慢了。

    11.4 语法优化

    limit(n) 是用来规定显示的条数，而 skip(n) 是用来在符合条件的记录中从第一个记录跳过的条数，这两个函数可以交换使用。

    比如：find({},{age:1,_id:0}).limit(2).skip(1)，在符合条件的文档中，要显示两条文档，显示的位置从跳过第一条记录开始。这样不是很好理解。

    如果写成 find({},{age:1,_id:0}).skip(1).limit(2)，在符合条件的文档中，先跳过第一条文档，然后显示两条文档，这样比较好理解。

    注意：普通查询skip，和limit三者执行顺序和位置无关，但是在聚合aggregate中使用的时候，具有管道流的特质，执行顺序是按照位置关系顺序执行的。

    十二 异常级别

    • WriteConcern.NONE:没有异常抛出
    • WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
    • WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
    • WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
    • WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
    • WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
    • WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。

    参考文档：https://www.runoob.com/mongodb/

     
  • 相关阅读:
    Python 爬虫一 简介
    linux 基础笔记本
    Celery 分布式任务队列快速入门
    Git & Github
    Python 设计模式
    Python 数据结构
    Python 基础算法
    js2wordcloud 词云包的使用
    lambda 3
    sql server 远程
  • 原文地址：https://www.cnblogs.com/itzgr/p/10976679.html
Copyright © 2011-2022 走看看