关于mongodb:MongoDB-新手入门-CRUD

本文是 MongoDB 新手入门 系列的第一篇，在本文中，咱们将会解说 MongoDB 根本的增删改查操作，在学习完本文后，读者将会把握对 MongoDB 的汇合文档进行根本的新增，批改，删除以及基于多种条件的查问操作。

本文将会继续修改和更新，最新内容请参考我的 GITHUB 上的 程序猿成长打算 我的项目，欢送 Star，更多精彩内容请 follow me。

插入文档

在 MongoDB shell 中，插入文档有以下两个办法：

• 应用 db.collection.insertOne() 插入单个文档
• 应用 db.collection.insertMany() 插入多个文档

在插入文档时，如果 collection 不存在，插入操作将会主动创立 collection。如果文档没有 _id 字段，MongoDB 将会主动增加一个 _id 字段，类型为 ObjectId。

在 MongoDB 中，每一个文档都须要一个惟一的 _id 字段作为主键，如果插入时没有指定 _id 字段，MongoDB 驱动将会主动生成一个类型为 ObjectId 的 _id 字段。

ObjectId 是一种可能疾速生成的，有序的，12 字节大小的惟一值，蕴含：

• 一个 4 字节的工夫戳，代表了 ObjectId 的创立工夫，取值为 Unix 工夫戳（秒）
• 一个 5 字节的随机值，该值每个过程都只会生成一次，对每台服务器和过程来说该值是惟一的
• 一个 3 字节的自增值，初始为一个随机数

use sample_mflix

// 插入单个文档
db.movies.insertOne(
  {
    title: "The Favourite",
    genres: ["Drama", "History"],
    runtime: 121,
    rated: "R",
    year: 2018,
    directors: ["Yorgos Lanthimos"],
    cast: ["Olivia Colman", "Emma Stone", "Rachel Weisz"],
    type: "movie"
  }
)

// 插入多个文档
db.movies.insertMany([
   {
      title: "Jurassic World: Fallen Kingdom",
      genres: ["Action", "Sci-Fi"],
      runtime: 130,
      rated: "PG-13",
      year: 2018,
      directors: ["J. A. Bayona"],
      cast: ["Chris Pratt", "Bryce Dallas Howard", "Rafe Spall"],
      type: "movie"
    },
    {
      title: "Tag",
      genres: ["Comedy", "Action"],
      runtime: 105,
      rated: "R",
      year: 2018,
      directors: ["Jeff Tomsic"],
      cast: ["Annabelle Wallis", "Jeremy Renner", "Jon Hamm"],
      type: "movie"
    }
])

除了罕用的 insertOne 和 insertMany 办法之外，还能够用以下形式插入文档

• db.collection.bulkWrite()

• 配合 upsert: true 选项

  • db.collection.updateOne()
  • db.collection.updateMany()
  • db.collection.findAndModify()
  • db.collection.findOneAndUpdate()

查问文档

最根本的查询方法是 db.collection.find() 和 db.collection.findOne()，在 MongoDB 中插入以下文档

db.inventory.insertMany([{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm"}, status: "A" },
   {item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in"}, status: "A" },
   {item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in"}, status: "D" },
   {item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm"}, status: "D" },
   {item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm"}, status: "A" }
]);

查问 Collection 中所有文档

// 等价 SQL：SELECT * FROM inventory
db.inventory.find({})
// 等价 SQL：SELECT * FROM inventory LIMIT 1
db.inventory.findOne({})

指定查问条件

等值查问

// 等价 SQL：SELECT * FROM inventory WHERE status = "D"
db.inventory.find({status: "D"})
// 等价 SQL：SELECT * FROM inventory WHERE status != "D"
db.inventory.find({status: { $ne: "D"} })

IN 查问

// 等价 SQL：SELECT * FROM inventory WHERE status in ("A", "D")
db.inventory.find({status: { $in: ["A", "D"]}})
// 等价 SQL: SELECT * FROM inventory WHERE status NOT IN ("A", "D")
db.inventory.find({status: { $nin: ["A", "D"] } })

范畴查问

// SQL: SELECT * FROM inventory WHERE qty >= 50 AND qty < 100
db.inventory.find({qty: { $gte: 50, $lt: 100} })

比拟操作符反对这些：$lt，$gt，$gte，$lte。

AND 查问

// SQL：SELECT * FROM inventory WHERE status = "A" AND qty < 30
db.inventory.find({status: "A", qty: { $lt: 30} })

OR 查问

// SQL：SELECT * FROM inventory WHERE status = "A" OR qty < 30
db.inventory.find({$or: [ { status: "A"}, {qty: { $lt: 30} } ] })

同时应用 AND 和 OR

// SQL: SELECT * FROM inventory WHERE status = "A" AND (qty < 30 OR item LIKE "p%")
db.inventory.find({
  status: "A",
  $or: [{ qty: { $lt: 30} }, {item: /^p/} ]
})

NOT

// 查问 qty 模 5 值为 1 的所有文档，这里匹配的 qty 可能值为 1，6，11，16 等
db.inventory.find({qty: { $mod: [5, 1] } })
// 查问 qty 模 5 值部位 1 的所有文档，可能值为 2, 3, 4, 5, 7, 8, 9, 10, 12 等
db.inventory.find({qty: { $not: { $mod: [5, 1] } } })

查问嵌套的文档

查问所有 size 等于 {h: 14, w: 21, uom: "cm"} 的文档

db.inventory.find({ size: { h: 14, w: 21, uom: "cm"} } )

查问所有 size 中 uom 等于 in 的文档

db.inventory.find({ "size.uom": "in"} )

查问数组

在 MongoDB 中插入以下文档

db.inventory.insertMany([{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [14, 21] },
   {item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [14, 21] },
   {item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [14, 21] },
   {item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [22.85, 30] },
   {item: "postcard", qty: 45, tags: ["blue"], dim_cm: [10, 15.25] }
]);

上面的示例查问所有字段 tags 值只蕴含元素 “red” 和 “blank”（程序统一）的文档

db.inventory.find({tags: ["red", "blank"]})

如果只是查问同时蕴含 “red” 和 “blank” 两个值，并且不关怀排序或者数组中是否蕴含其它元素，则能够应用 $all 操作符

db.inventory.find({tags: { $all: ["red", "blank"] } })

查问 tags 蕴含 “red” 的文档

db.inventory.find({tags: "red"})

查问所有 dim_cm 蕴含至多一个大于值 25 的所有文档

db.inventory.find({dim_cm: { $gt: 25} })

查问所有 dim_cm 蕴含至多一个值大于 15 或者 小于 20 的所有文档

db.inventory.find({dim_cm: { $gt: 15, $lt: 20} })

查问所有 dim_cm 蕴含至多一个值大于 22 且小于 30 的所有文档

db.inventory.find({dim_cm: { $elemMatch: { $gt: 22, $lt: 30} } })

查问数组 dim_cm 的第二个值大于 25

db.inventory.find({"dim_cm.1": { $gt: 25}})

查问数组 tags 领有 3 个元素的所有文档

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

查问返回指定字段

默认状况下，MongoDB 的查问会返回匹配文档中所有的字段，通过 projection 能够返回指定的字段。

返回指定字段

// SQL: SELECT _id, item, status FROM inventory WHERE status = "A"
db.inventory.find({status: "A"}, {item: 1, status: 1})

查问后果中会主动返回 _id 字段，能够通过设置 _id: 0 来被动打消该字段。

// SQL：SELECT item, status FROM inventory WHRE status = "A"
db.inventory.find({ status: "A"}, {item: 1, status: 1, _id: 0} )

排除指定字段

db.inventory.find({status: "A"}, {status: 0, instock: 0})

返回数组中指定元素

应用 $slice 操作符返回 instock 数组中最初一个元素

db.inventory.find({status: "A"}, {item: 1, status: 1, instock: { $slice: -1} })

查问值为 NULL 或者缺失字段

在 MongoDB 中，不同的查问操作符对 null 的解决形式是不同的。在 MongoDB 中插入以下文档

db.inventory.insertMany([{ _id: 1, item: null},
   {_id: 2}
])

等值查问

查问 item 值为 null 或者不蕴含 item 字段的所有文档

db.inventory.find({item: null})

类型查看

查问所有 item 值为 null 的文档

db.inventory.find({item: { $type: 10} })

这里的 $type = 10 对应了 BSON 类型 Null

存在性查看

查问所有不蕴含字段 item 的文档

db.inventory.find({item: { $exists: false} })

查问所有蕴含 item 字段，然而值为 null 的文档

db.inventory.find({item: { $eq: null, $exists: true} })

限度查问后果数量

// 只查问 3 条数据
db.inventory.find({}).limit(3)
// 从第 2 条开始，查问 3 条数据
db.inventory.find({}).limit(3).skip(2)

排序

排序方向 1 为正序，-1 为倒序。

db.inventory.find({}).sort({item: 1, qty: -1})

查问汇合中的文档数量

该办法用于查问匹配条件的文档数量，语法为

db.collection.count(query, options)

示例

db.orders.count({ ord_dt: { $gt: new Date('01/01/2012') } } )

查问字段的惟一值 distinct

查问汇合中字段的惟一值，语法为

db.collection.distinct(field, query, options)

附录：反对的查问操作符

更新文档

罕用的文档更新办法有以下三种

• db.collection.updateOne(<filter>, <update>, <options>) 更新单个文档
• db.collection.updateMany(<filter>, <update>, <options>) 更新多个文档
• db.collection.replaceOne(<filter>, <update>, <options>) 替换单个文档

咱们这里以 updateOne() 办法为例进行解说，updateOne() 办法的语法如下

db.collection.updateOne(
   <filter>, // 要更新的文档筛选条件
   <update>, // 文档更新命令
   {
     upsert: <boolean>, // 设置为 true 时，如果 filter 没有匹配到文档，则主动新增文档
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [<filterdocument1>, ...],
     hint:  <document|string>        // Available starting in MongoDB 4.2.1
   }
)

更新 item=paper 的文档

db.inventory.updateOne({ item: "paper"},
   {$set: { "size.uom": "cm", status: "P"},
     $currentDate: {lastModified: true}
   }
)

更新操作符如下

• $set 操作符指定了要更新匹配文档的 size.uom 为 cm，status 为 p
• $currentDate 操作符用于更新 lastModified 字段为以后的日期，如果 lastModified 字段不存在，则主动创立

更新文档，如果不存在则新增

db.restaurant.updateOne({ "name" : "Pizza Rat's Pizzaria"},
    {$set: {"_id" : 4, "violations" : 7, "borough" : "Manhattan"} },
    {upsert: true}
);

更多字段操作符如下

除了罕用的三个办法，还有以下办法也能够用于更新文档

• db.collection.findOneAndReplace().
• db.collection.findOneAndUpdate().
• db.collection.findAndModify().
• db.collection.bulkWrite().

删除文档

在 MongoDB 中，通常应用以下办法删除文档

• db.collection.deleteMany()
• db.collection.deleteOne()

删除所有为文档

db.inventory.deleteMany({})

删除所有匹配条件的文档

db.inventory.deleteMany({status : "A"})

删除匹配条件的一个文档

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

除了罕用的两个办法外，还能够用以下办法删除文档

• db.collection.findOneAndDelete().

  findOneAndDelete() 提供了一个 sort 选项，该选项容许删除依照指定排序规定排序后匹配的第一个文档

• db.collection.findAndModify().

  db.collection.findAndModify() 提供了一个 sort 选项，该选项容许删除依照指定排序规定排序后匹配的第一个文档

• db.collection.bulkWrite().

批量写操作

MongoDB 提供了一种对单个 Collection 执行批量写入的操作能力，应用 db.collection.bulkWrite() 办法实现批量的插入、更新和删除操作。

有序和无序操作

批量写操作能够试有序的（ordered）或者无序（unordered）的，对于有序操作，MongoDB 会串行的执行操作，如果写操作过程中产生谬误，MongoDB 将会间接返回，前面的操作将不会被执行。无序操作则无奈保障这种行为，当产生谬误的时候，MongoDB 将会持续解决残余的文档。

对于分片的汇合来说，执行有序的批量操作通常会比较慢，因为每一个操作都必须期待上一个操作的实现。默认状况下，bulkWrite() 执行的是有序的操作，能够通过设置 ordered: false 选项来启用无序操作模式。

bulkWrite() 办法

bulkWrite() 反对以下写操作

• insertOne
• updateOne
• updateMany
• replaceOne
• deleteOne
• deleteMany

假如一个名为 characters 的汇合中蕴含上面的文档

{"_id" : 1, "char" : "Brisbane", "class" : "monk", "lvl" : 4},
{"_id" : 2, "char" : "Eldon", "class" : "alchemist", "lvl" : 3},
{"_id" : 3, "char" : "Meldane", "class" : "ranger", "lvl" : 3}

上面的 bulkWrite() 办法对该汇合执行多个操作

db.characters.bulkWrite(
   [
      { insertOne :
         {
            "document" :
            {"_id" : 4, "char" : "Dithras", "class" : "barbarian", "lvl" : 4}
         }
      },
      { insertOne :
         {
            "document" :
            {"_id" : 5, "char" : "Taeln", "class" : "fighter", "lvl" : 3}
         }
      },
      { updateOne :
         {"filter" : { "char" : "Eldon"},
            "update" : {$set : { "status" : "Critical Injury"} }
         }
      },
      { deleteOne :
         {"filter" : { "char" : "Brisbane"} }
      },
      { replaceOne :
         {"filter" : { "char" : "Meldane"},
            "replacement" : {"char" : "Tanys", "class" : "oracle", "lvl" : 4}
         }
      }
   ]
);

操作返回以下内容

{
   "acknowledged" : true,
   "deletedCount" : 1,
   "insertedCount" : 2,
   "matchedCount" : 2,
   "upsertedCount" : 0,
   "insertedIds" : {
      "0" : 4,
      "1" : 5
   },
   "upsertedIds" : {}}

参考文档

• MongoDB 官网文档