mongoDB的CRUD的总结

今天开始接触非关系型数据库的mongoDB，如今将本身作的笔记发出来，供你们参考，也便于本身之后忘记了能够查看。 首先，mongoDB，是一种数据库，可是又区别与mysql，sqlserver、orcle等关系数据库，在优点上面也略高一筹；至于为何会这么说呢？很简单，咱们来举两个例子： 1.在存储上面，非关系型数据库能够更大规模的存储，打个比方，Facebook用的数据库就是非关系型数据库。 2.运用起来更加流畅也是这个数据库的优势，将分布式的特色发挥到极致。 当我查看官方文档的时候，简直要人命，光是一个插入方法都讲了好几条，脑壳都大了，如今我总结一下每一插入方法的特性

db.collection.insert()

db.collection.insert() 向集合插入一个或多个文档.要想插入一个文档,传递一个文档给该方法;要想插入多个文档,就能够采用该方法。 例如

db.users.insert(
   [
     { name: "bob", age: 42, status: "A", },
     { name: "ahn", age: 22, status: "A", },
     { name: "xi", age: 34, status: "D", }
   ]
)

若是插入成功就会返回

WriteResult({ "nInserted" : 3 })

若是异常状况，那么就会返回以下咯：

WriteResult({
   "nInserted" : 3,
   "writeConcernError" : {
      "code" : 64,
      "errmsg" : "waiting for replication timed out at shard-a"
   }
})

当咱们想插入一条数据的时候，采用insert的方法据比较浪费内存，这个时候，咱们久采用插入单个的语法db.collection.insertOne() 向集合插入 单个 文档 document 举个小列子来讲明一下。

db.users.insertOne(
   {
      name: "sue",
      age: 19,
      status: "P"
   }
)

有了单个，就确定会有多个，那么多个又是怎么样的呢？语法都很相似，db.collection.insertMany()这个语法跟上面没有区别嘛，对不对，固然是错的，你想，若是添加的数据是数组里面嵌套数组，前面两个的方法的性能就大打折扣了，影响数据库的性能。废话少说，列子走一波：

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", "Picasso" ],
       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: [ "Picasso", "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 }
       ]
     }
   ]
)

注意:insertOne()、insertMany()是3.2版本的语法。

既然增了，就得查找，对吧，查找里面呢也有不少小东西，有许多本身自定义查询。 一、查询所有

db.users.find( {} ) 等价于db.users.find()

二、指定等于条件 一个 query filter document 可使用 <field>:<value> 表达式指定等于条件以选择全部包含 <field> 字段而且等于特定 <value> 的全部文档：

下面的示例从 user 集合中检索 status 字段值为 "P" 或者 "D" 的全部文档：

db.users.find( { status: { $in: [ "P", "D" ] } } )

三、指定 AND 条件 复合查询能够在集合文档的多个字段上指定条件。隐含地，一个逻辑的 AND 链接词会链接复合查询的子句，使得查询选出集合中匹配全部条件的文档。

下面的示例在 users 集合中检索 status 等于 "A"``**而且** ``age 小于 ($lt) 30是全部文档：

db.users.find( { status: "A", age: { $lt: 30 } } )

四、指定 OR 条件 经过使用 $or 操做符，你能够指定一个使用逻辑 OR 链接词链接各子句的复合查询选择集合中匹配至少一个条件的文档。

下面的示例在 users 集合中检索 status` 等于 "A"**或者** age 小于 ($lt) 30 全部文档：

db.users.find(
   {
     $or: [ { status: "A" }, { age: { $lt: 30 } } ]
   }
)

五、指定 AND 和 OR 条件（能够更加精确的查询) 在下面的示例中，复合查询文档选择集合中status`` 等于 "A" 而且 要么 age 小于 ($lt) 30 要么 type 等于 1 的全部文档：

db.users.find(
   {
     status: "A",
     $or: [ { age: { $lt: 30 } }, { type: 1 } ]
   }
)

六、嵌入文档上的精确匹配 使用{ <field>: <value> }而且 “<value>” 为要匹配文档的查询文档，来指定匹配整个内嵌文档的彻底相等条件.(要使)相等条件匹配上内嵌文档须要指定 <value> 包括字段顺序的 精确 匹配。

在下面的例子中,查询匹配全部 favorites 字段是以该种顺序只包含 等于 "Picasso"``的 ``artist 和等于 "pizza" 的 food 字段的内嵌文档：

db.users.find( { favorites: { artist: "Picasso", food: "pizza" } } )

七、嵌入文档中字段上的等于匹配 在下面的例子中,查询使用 dot notation 匹配全部 favorites 字段是包含等于 "Picasso" 的字段 ``artist``(可能还包含其余字段) 的内嵌文档：

db.users.find( { "favorites.artist": "Picasso" } )

八、数组上的查询 采用一个参数： $elemMatch (该参数是值精确的数组) 下面的例子查询 finished 数组至少包含一个大于 ($gt) 15 而且小于 ($lt) 20 的元素的文档：

db.users.find( { finished: { $elemMatch: { $gt: 15, $lt: 20 } } } )

九、嵌入文档数组 使用数组索引匹配嵌入文档中的字段 在下面的例子中,查询使用 the dot notation 匹配全部 dadges 是第一个元素为”black” 的数组的文档:

db.users.find( { 'points.0.points': { $lte: 55 } } )

十、不指定数组索引匹配字段 若是你不知道文档在数组中的索引位置，用点号 (.) 将包含数组的字段的名字和内嵌文档的字段的名字连起来。

下面的例子选择出全部 points``数组中至少有一个嵌入文档包含值小于或等于 ``55 的字段 points 的文档:

db.users.find( { 'points.points': { $lte: 55 } } )

十一、指定数组文档的多个查询条件 单个元素知足查询条件 使用 $elemMatch 操做符为数组元素指定复合条件，以查询数组中至少一个元素知足全部指定条件的文档。

下面的例子查询 points 数组有至少一个包含 points 小于等于 70 而且字段 bonus 等于 20 的内嵌文档的文档：

db.users.find( { points: { $elemMatch: { points: { $lte: 70 }, bonus: 20 } } }

十二、元素组合知足查询条件 下面的例子查询了 points 数组包含了以某种组合知足查询条件的元素的文档；例如，一个元素知足 points 小于等于 70 的条件而且有另外一个元素知足 bonus 等于 20 的条件，或者一个元素同时知足两个条件：

db.users.find( { "points.points": { $lte: 70 }, "points.bonus": 20 } )

接下来就是更新咯，老样子跟插入方法差很少，更新就能够看作是插入的一种。 来一段官方文档的话： 若是 db.collection.update()，db.collection.updateOne()， db.collection.updateMany() 或者 db.collection.replaceOne() 包含 upsert : true 而且 没有文档匹配指定的过滤器，那么此操做会建立一个新文档并插入它。若是有匹配的文档，那么此操做修改或替换匹配的单个或多个文档。 这个解释在我认为就是在没有该数据的时候就会建立相应的数据，毕竟它是插入的一种特殊方法。

一、db.collection.updateOne():修改单条数据 下面的例子对 users 集合使用 db.collection.updateOne() 方法来更新第一个 根据 过滤条件favorites.artist 等于 "Picasso" 匹配到的文档更新操做:

使用 $set 操做符更新 favorites.food 字段的值为 "pie" 并更新 type 字段的值为 3,

db.users.updateOne(
   { "favorites.artist": "Picasso" },
   {
     $set: { "favorites.food": "pie", type: 3 },
    
   }
)

二、db.collection.update()的用法和db.collection.updateOne()相似，为了区别一下，咱们采用了 { multi: true }这个参数，这样会在你修改以后的数据中有这个参数，表示修改完成。

db.users.update(
   { "favorites.artist": "Pisanello" },
   {
     $set: { "favorites.food": "pizza", type: 0,  }
   },
   { multi: true }
)

三、 db.collection.updateMany(),这个会不会认为是修改不少，固然能够这么理解，可是我更喜欢把他理解成修改多个参数。 下面这个举例就是为了你们看的明白采用了{ upsert: true }，它能够清晰的返回你修改后的值

db.inspectors.updateMany(
      { "Sector" : { $gt : 4 }, "inspector" : "R. Coltrane" },
      { $set: { "Patrolling" : false } },
      { upsert: true }
   );

四、修改还有一个就是文档替换db.collection.replaceOne 下面的例子对 users 集合使用 db.collection.replaceOne() 方法将经过过滤条件 name 等于 "sue" 匹配到的 **第一个** 文档替换为新文档:

db.users.replaceOne(
   { name: "abc" },
   { name: "amy", age: 34, type: 2, status: "P", favorites: { "artist": "Dali", food: "donuts" } }
)

走着，撸删除了： 一、删除全部文档db.collection.remove() 这个方法就干脆了，就至关于sql中的删除表结构的delete()

db.users.remove({})

做为另外一种选择以下例子使用 db.collection.remove() 从 users 集合中删除全部 status 字段等于 "A" 的文档:

db.users.remove( { status : "P" } )

二、仅删除一个知足条件的文档db.collection.deleteOne() 以下例子使用 db.collection.deleteOne() 删除 第一个 status 字段等于 "A" 的文档:

db.users.deleteOne( { status: "D" } )

三、删除集合中全部文档db.collection.deleteMany() 以下的例子使用 db.collection.deleteMany() 方法从 users 集合中删除了 全部 文档:

db.users.deleteMany({})

以上是经过两天学习官方文达能的总结，下面配上官方文档的地址表示感谢。 https://docs.mongodb.com/manual/reference/method/js-collection/

原文出处：https://www.cnblogs.com/XSdao/p/11339092.html