MongoDB学习（五）MongoDB 创建\更新及删除文档\查询

1.概述

       MongoDB最重要也是最基础的部分：C（创建）R（查询）U（更新）D（删除）；由于R（查询）操作相对来说内容比较多，也比较繁琐；

1.1创建

关系型数据库的思想：一个服务器要想存放数据，首先要有数据库，表，字段，约束，当然了也少不了主键，外键，索引，关系等；

MongoDB的世界里边，我们不用预先的去创建这些信息从而直接来使用各个属性。

　　1、数据库（database）

　　　　a）、创建

　　　　　　use mydb（创建并切换到名称为mydb的数据库实例下。注：如果你对其不进行任何操作，该数据库是没有任何实际意义的）

　　2、集合（collection）---》表

　　　　a）、创建

　　　　　　我们直接指定，不做任何预处理，指定一个名称为users的数据集（相当于表），并向其中插入一条用户数据。

　　　　　　db.users.insert({ "name" : "wjg" , "age" : 24 }) 

　　　　　　返回结果如下,表示你已经成功插入了一条数据：

　　　　　　WriteResult({ "nInserted" : 1 })

　　　　b）、显式创建

　　　　　　仅创建一个名称为collectionName的，没有任何大小和数量限制的数据集

　　　　　　db.createCollection("collectionName")

　　　　　　如果该数据集有重名，会给出已经存在的提示：

　　　　　　{ "ok" : 0, "errmsg" : "collection already exists", "code" : 48 }

　　　　　　成功之后会给出ok的提示：

　　　　　　{ "ok" : 1 }

　　3、文档（document）

　　　　a）、单一插入

　　　　　　注：如果没有主键“_id”，插入文档的时候MongoDB会为我们自动保存一个进去。

　　　　　　　　这里我们指定一个“_id”，当然了，“_id”肯定是不能重复的，否则无法插入成功。

　　　　　　db.users.insert({"_id":0,"name":"jack","age":20})

　　　　　　成功插入数据之后：

　　　　　　WriteResult({ "nInserted" : 1 })

　　　　b）、批量插入

　　　　　　注：一次性插入多个文档会明显提高插入速度；

　　　　　　　　插入文档的大小限制为48MB；

　　　　　如果其中有一个文档插入失败了，这个文档之前的都可以插入成功，但是在它之后都会失败；（不同的驱动可能会有不同的处理方式）

　db.users.insert([{"_id":1,"name":"tom","age":21},{"_id":2,"name":"joe","age":22},{"_id":3,"name":"bob","age":22}])

　　　　　　批量插入成功之后会返回如下信息：

　　　　　　BulkWriteResult({

　　　　　　　　"writeErrors":[],

　　　　　　　　"writeConcernErrors":[],

　　　　　　　　"nInserted":3,

　　　　　　　　"nUpserted":0,

　　　　　　　　"nMatched":0,

　　　　　　　　"nModified":0,

　　　　　　　　"nRemoved":0,

　　　　　　　　"upserted":[]})

　　　　　　分别表示的大致意思为：

　　　　　　　　插入的错误信息，其他的插入错误信息，插入的文档数量，特殊更新的文档数量，匹配到的文档数量，

　　　　　　　　更新的文档数量，移出的文档数量和特殊文档更新信息

　　　　　　特殊的文档更新（upsert），其定义如下：

　　　　　　如果没有找到符合更新条件的文档，就会以这个条件和更新文档为基础创建一个新的文档；如果找到了匹配的文档，那么就正常更新

1.2更新

　　想要更新文档，必须要有两个参数：

　　　　一个是查询条件，用于定位到需要更新的目标文档；

          另一个是修改器，用于说明要对找到的文档进行哪些修改;

　　截至此刻为止，我们已经向mydb数据库中名称为users的数据集中添加了如下几个文档：

　　　　a）、单一更新

　　　　　　让我们来为名字为bob的年龄增加一岁，直接将年龄更新为23岁

　　　　　　db.users.update({"name":"bob"},{$set:{"age":23}}) //使用了$set修改器之后，只会更新age自段的值为23

　　　　　　或者

　　　　　　db.users.update({"name":"bob"},{"age":23}) //同样会将age自段的值更新为23，但是会移出除了“_id”和本身之外的所有字段值

　　　　　　具体详情如下图：

　　　　　　注：如果需要更新的字段不存在，那么MongoDB会按字段顺序进行插入，类似于上边提到的特殊更新。

　　　　其实细心的童鞋会发现，我们都是以name作为条件进行更新，所以并不能保证其唯一性，那么MongoDB只会更新匹配到的第一个文档。

　　　　　　　　这里还是建议大家指定一个唯一的文档进行更新，"_id"可以帮你保证！

　　　　b）、使用选择器更新（重点）

　　　　　　1、$set修改器

　　　　　　　　执行特殊更新操作；可以修改内嵌文档；甚至可以更改键的类型；

　　　　　　　　Ⅰ、假设需求改了，我们需要为为所有用户添加一个”hobby“的属性用于存放用户的喜好，那么我们可以这样做：

　　　　　　　　　　db.users.update({},{$set:{"hobby":"read"}}) //这样做是错的，哈哈。。

　　　　　　　　　　更新后的文档如下：

　切记：update方法只会更新它匹配到的第一个文档对象，所以这个操作只会将名字为”wjg“的用户添加一个”hobby“属性，其它对象不会添加

　　　　　　　　　　正确方式如下：

　　db.users.update({},{$set:{"hobby":"write"}},false,true)  //第三个参数为是否启用特殊更新，第四个为是否更新所有匹配的文档；

　　　　　　　　　　这俩参数默认都为false

　　　　　　　　　　更新后的文档如下：

　　　　　　　　　　可以看到我们成功更新了五个文档对象

　　　　　　　　Ⅱ、假设我们需求又变了，老板说了，每个用户的爱好会有多个。那么简单，因为我们可以直接将string类型的hobby属性改成string数组类型的

　　　　　　　　　　db.users.update({"_id":0},{"$set":{"hobby":["write","read","paly ping-pong"]}}) //将_id为0的hobby属性更新为数组类型的

　　　　　　　　Ⅲ、然后我们发现tom压根就没有爱好，那么我们可以使用$unset修改器将其删除

　　　　　　　　　　db.users.update({"_id":1},{"$unset":{"hobby":1}}) //1表示彻底删除这个键值对

　　　　　　　　Ⅳ、现在已经过去一年了，我们是时候把所有用户的年龄加一岁了。这时$inc上场

　　　　　　　　　　db.users.update({},{"$inc":{"age":1}},false,true) //别忘了将第四个参数置为true

　　　　　　　　　　注：$inc修改器只针对数字类型，如果是string或者其他类型的会提示报错：　　　　　　　　　

　　　　　　　　　　　　　　提示无法将$inc应用到非数字类型上，并且给出错误位置：”_id“为2的文档；

　　　　　　　　　　　　　　我们将joe的age改为数字类型的重新执行一次，就可以成功啦！

　　　　　　　　Ⅴ、过了一段时间，jack又喜欢上了游泳，那么我们可以用$push这样搞：

　　　　　　　　　　db.users.update({"_id":0},{"$push":{"hobby":"swim"}}) //hobby必须是一个数组，所以你在其他文档上使用是不会成功的

　　　　　　　　Ⅵ、然而jack不喜欢读书了，我们就用$pull来移除“read”元素

　　　　　　　　　　db.users.update({"_id":0},{"$pull":{"hobby":"read"}}) //它会移除数组中所有匹配到的“read”元素

　　　　　　　　　　另外：db.users.update({"_id":0},{"$pop":{"hobby":1}}) //表示移除hobby中的最后一个元素，为-1表示移除第一个元素

　　　　　　　　　　不知道大家有没有发现，“_id”为0的文档从第二的位置被移动到了数据集的末尾，这是因为该文档尺寸变大的原因导致的，

　　　　　　　　　　原先的位置已经容不下它了！

　　　　　　　　　　那么这就引出了另外一个概念：填充因子，它是MongoDB为每个新文档预留的增长空间。上边的这种情况就会使填充因子增加。

　　　　　　　　　　移动文档是一个非常缓慢的操作，尽量让填充因子的值接近1；

　　　　　　　　　　通过db.users.stats()查看该数据集信息，“paddingFactor”即为填充因子的大小；

1.3删除

　　删除文档相对来说就简单了许多

　　1、单一删除

　　　　给定一个查询参数，只要符合条件的，都会被删除

　　　　db.users.remove({"_id":{"$lte":1}}) //删除“_id”的值小于等于1的所有文档

　　　　返回结果如下：

　　　　WriteResult({"nRemoved":2}) //成功删除了两个文档

　　2、清空整个数据集

　　　　db.users.remove()

　　　　如果数据较多的话，用db.users.drop()会明显提升删除速度

　　注：删除都是不可逆的，不能撤销，也不能恢复，所以要谨慎使用；

　　　　清空数据集的时候集合本身并不会被删除，也不会删除集合的元信息；

1.3.1删除文档的常用方法

1、删除文档常用方法

db.collection.remove()  
    删除满足匹配条件的一个或多个文档

db.collection.deleteOne()   
    删除满足匹配条件的最多一个文档(即使有多个文档满足匹配条件),3.2版本支持

db.collection.deleteMany()  
    删除满足匹配条件的所有文档

单个或集合内的所有文档的删除，与之相应的索引并不会被删除
文档删除的操作属于原子性操作，仅仅在单个文档级别，可以理解为关系型数据库的行级锁
2、语法

    db.collection.remove(
       <query>,             //查询或过滤条件
       {
         justOne: <boolean>, //用于确定是单行还是删除所有行(true为缺省值即单行)
         writeConcern: <document>  //设定写安全，用于确保强一致性还是弱一致性
       }
    )

1.3.2准备环境

 

    > db.users.insertMany(
      [
         {
           _id: 1,
           name: "sue",
           age: 19,
           type: 1,
           status: "P",
           favorites: { artist: "Picasso", food: "pizza" },
           finished: [ 17, 3 ],
           badges: [ "blue", "black" ],
           points: [
              { points: 85, bonus: 20 },
              { points: 85, bonus: 10 }
           ]
         },
         {
           _id: 2,
           name: "bob",
           age: 42,
           type: 1,
           status: "A",
           favorites: { artist: "Miro", food: "meringue" },
           finished: [ 11, 25 ],
           badges: [ "green" ],
           points: [
              { points: 85, bonus: 20 },
              { points: 64, bonus: 12 }
           ]
         },
         {
           _id: 3,
           name: "ahn",
           age: 22,
           type: 2,
           status: "A",
           favorites: { artist: "Cassatt", food: "cake" },
           finished: [ 6 ],
           badges: [ "blue", "red" ],
           points: [
              { points: 81, bonus: 8 },
              { points: 55, bonus: 20 }
           ]
         },
         {
           _id: 4,
           name: "xi",
           age: 34,
           type: 2,
           status: "D",
           favorites: { artist: "Chagall", food: "chocolate" },
           finished: [ 5, 11 ],
           badges: [ "red", "black" ],
           points: [
              { points: 53, bonus: 15 },
              { points: 51, bonus: 15 }
           ]
         },
         {
           _id: 5,
           name: "xyz",
           age: 23,
           type: 2,
           status: "D",
           favorites: { artist: "Noguchi", food: "nougat" },
           finished: [ 14, 6 ],
           badges: [ "orange" ],
           points: [
              { points: 71, bonus: 20 }
           ]
         },
         {
           _id: 6,
           name: "abc",
           age: 43,
           type: 1,
           status: "A",
           favorites: { food: "pizza", artist: "Picasso" },
           finished: [ 18, 12 ],
           badges: [ "black", "blue" ],
           points: [
              { points: 78, bonus: 8 },
              { points: 57, bonus: 7 }
           ]
         }
      ]
    )
 

1.3.3演示文档删除

1、db.collection.deleteOne

    //语法如下
    db.collection.deleteOne(
       <filter>,                   //查询的过滤条件
       {
          writeConcern: <document> //用于控制写入何时应答及超时
       }
    )

    > db.users.find({status:"A"}).count()
    3

    > db.users.deleteOne({status:"A"})
    { "acknowledged" : true, "deletedCount" : 1 }
    > db.users.find({status:"A"}).count()
    2

2、删除多个文档

    //语法，参数同deleteOne
    db.collection.deleteMany(
       <filter>,
       {
          writeConcern: <document>
       }
    )

    > db.users.deleteMany({status:"A"})
    { "acknowledged" : true, "deletedCount" : 2 }
    > db.users.find({status:"A"}).count()
    0


3、db.collection.remove

    //语法
    db.collection.remove(
       <query>,       //过滤条件
       {
         justOne: <boolean>,  //可选条件,布尔类,为true时，仅删除满足条件单个文档，否则删除满足条件全部文档
         writeConcern: <document> 写安全参数，用于控制写入何时应答及超时
       }
    )

    //对于db.collection.remove，当justOne为true时等同于deleteOne方法，为false时等同于deleteMany方法

    //如下，当不指定任何参数的时候，收到错误提示，即需要指定过滤条件，防止误清空整个集合
    > db.users.remove()
    2016-10-21T23:48:31.766+0800 E QUERY    [thread1] Error: remove needs a query :
    DBCollection.prototype._parseRemove@src/mongo/shell/collection.js:406:1
    DBCollection.prototype.remove@src/mongo/shell/collection.js:433:18
    @(shell):1:1

    > db.users.find({status:"D"}).count()
    2

    > db.users.createIndex({name:1})
    {
            "createdCollectionAutomatically" : false,
            "numIndexesBefore" : 1,
            "numIndexesAfter" : 2,
            "ok" : 1
    }
    > db.users.getIndexes()
    [
            {
                    "v" : 1,
                    "key" : {
                            "_id" : 1   //Author : Leshami
                    },                  //Blog   : http://blog.csdn.net/leshami
                    "name" : "_id_",
                    "ns" : "test.users"
            },
            {
                    "v" : 1,
                    "key" : {
                            "name" : 1
                    },
                    "name" : "name_1",
                    "ns" : "test.users"
            }
    ]

    //删除满足状态为D的任意一个文档
    > db.users.remove({status:"D"},true)
    WriteResult({ "nRemoved" : 1 })

    //删除满足年龄大于20的所有文档
    > db.users.remove({age:{$gt:20}})
    WriteResult({ "nRemoved" : 1 })

    //删除满足年龄小于20的所有文档
    //且writeConcern参数w为majority，该参数通常用于副本集中，确定有几个节点写入成功才应答给客户端
    //此列中表明，满足大多数即可返回应答给客户端，如3个节点复制集，2个节点写入即可返回应答
    //wtimeout为写入超时参数，避免写入因意外故障导致挂起，陷入无限等待
    > db.users.remove(
         { age: { $lt: 20 } },
         { writeConcern: { w: "majority", wtimeout: 5000 } }
     )
    WriteResult({ "nRemoved" : 1 })

    //此时查看集合，已经无文档返回
    > db.users.find()   

    //查看索引，索引依旧存在，尽管没有任何文档
    > db.users.getIndexes()
    [
            {
                    "v" : 1,
                    "key" : {
                            "_id" : 1
                    },
                    "name" : "_id_",
                    "ns" : "test.users"
            },
            {
                    "v" : 1,
                    "key" : {
                            "name" : 1
                    },
                    "name" : "name_1",
                    "ns" : "test.users"
            }
    ]

    > db.users.dropIndexes()
    {
            "nIndexesWas" : 2,
            "msg" : "non-_id indexes dropped for collection",
            "ok" : 1
    }

    //下面直接删除这个空集合
    > db.users.drop()
    true

    //再次查看当前数据库下已经无任何集合对象
    > show collections;

1.3.4小结

    1、文档的移除通过使用db.collection.remove()方法来实现。
    2、db.collection.remove()方法，当justOne为true时等同于db.collection.deleteOne
    3、db.collection.remove()方法，当justOne为false时等同于db.collection.deleteMany
    4、文档的删除以及全部删除后，对于已经创建的索引依旧存在，可以单独删除(dropIndexes)或者删除整个集合
    5、参数writeConcern: <document>在副本集的时候用于副本集数据库一致性

2.MongoDB的查询

测试数据为基础，进行下面的基本查询操作：

 db.blogs.insert([
   {
          "author": "张三",
         "title": "MongoDB简介",
          "content": "它是介于关系型数据库和非关系型数据库之间的一种NoSQL数据库，用C++编写，是一款集敏捷性、可伸缩性、扩展性于一身的高性能的面向文档的通用数据库",
         "tags": [
              "MongoDB",
              "NoSQL"
          ],
         "comment": [
             {
                 "name": "Jack",
                 "detail": "Good！",
                "date": ISODate("2015-07-09 09:55:49")
             },
             {
                 "name": "Tom",
                 "detail": "Hello World！",
                 "date": ISODate("2015-07-09 18:12:35")
             },
             {
                 "name": "Alice",
                 "detail": "你好，Mongo！",
                 "date": ISODate("2015-07-10 20:30:30")
             }
         ],
         "readCount": 154
     },
     {
         "author": "李四",
         "title": "1+1等于几",
         "content": "有的人说1+1=2，因为这是老师从小告诉我们的；而有的人说1+1=11，这是两个1的组合；但是有些人就认为1+1=1，他们觉得1个团队加上另一个团队，会组成了一个更强大的团队！",
        "tags": [
            "story",
            "rule",
           "数学"
         ],
         "comment": [
             {
                 "name": "王小光",
                 "detail": "每个人心里边都有自己的答案。",
                 "date": ISODate("2015-07-10 11:45:57")
             }
         ],
         "readCount": 367
     },
     {
         "author": "李四",
         "title": "如何写一篇好的博客？",
        "content": "1、目标；2、坚持；3、分享；4、学习；5、提高",
         "tags": null,
         "comment": [
             {
                 "name": "小明",
                 "detail": "ComeOn!!!!",
                 "date": ISODate("2015-07-10 14:49:06")
             },
             {
                 "name": "Nike",
                 "detail": "终身学习！",
                 "date": ISODate("2015-07-11 10:22:36")
             },
             {
                 "name": "小红",
                 "detail": "贵在坚持吧、",
                 "date": ISODate("2015-07-12 12:12:12")
             }
         ],
         "readCount": 1489,
         "isTop": true
     }
 ])

1、查询所有博客

db.blogs.find()
或
db.blogs.find({})

注：查询一个文档：db.blogs.findOne()

2、查询所有博客的标题和内容（指定需要返回的键值）

db.blogs.find({},{"title":1,"content":1,"_id":0})

注：1表示返回，0表示不返回。默认情况下，“_id”这个键总是被返回，即便是没有指定这个键

3、查询作者为“张三”的博客（=操作）

db.blogs.find({"author":"张三"})
或
db.blogs.find({"author":{"$eq":"张三"}})

4、查询除了作者为“张三”的博客（!=操作）

db.blogs.find({"author":{"$ne":"张三"}})

5、查询作者为“李四”并且博客标题为“MongoDB简介”的博客（and操作）

db.blogs.find({"author":"张三","title":"MongoDB简介"})

6、查询阅读量大于等于200并且小于1000的博客（>=操作）

db.blogs.find({"readCount":{"$gte":200,"$lt":1000}})

注：“$lt”，“$lte”，“$gt”，“$gte”分别对应<，<=，>，>=操作

7、查询作者为“张三”或者“李四”的博客（or操作）

db.blogs.find({"$or":[{"author":"张三"},{"author":"李四"}]})

8、查询博客标签包含了“NoSQL”或者“数学”的博客（in操作）

db.blogs.find({"tags":{"$in":["NoSQL","数学"]}})
注：not in操作
db.blogs.find({"tags":{"$nin":["NoSQL","数学"]}}) //不包含

9、查询标签为空的博客（null操作）

db.blogs.find({"tags":null})
注：null不仅会匹配到某个键为null的文档，也会匹配不包含这个键的文档

10、查询内容里边包含了数字“1”的博客

db.blogs.find({"content":/1/})

注：只要符合常规正则表达式的，都能被MongoDB接受

数组操作

11、查询标签里边既包含“story”，又包含了“rule”的博客

db.blogs.find({"tags":{"$all":["story","rule"]}})

12、查询第一个标签是“MongoDB”的博客

db.blogs.find({"tags.0":"MongoDB"})

注：数组的下标是从0开始的

13、查询标签个数为3个的博客

db.blogs.find({"tags":{"$size":3}})

内嵌文档
14、查询“jack”评论过的博客

db.blogs.find({"comment.name":"Jack"})

注：因为内嵌文档“.”的问题，所以不能使用URL等

15、假设每页2篇博客，按阅读量倒序，取第二页的数据

db.blogs.find({}).skip(2).limit(2).sort({"readCount":-1})

注：skip()、limit()、sort()，分别表示略过文档的数量，匹配的数量和排序（1表示正序，-1表示倒序）