MongoDB 的基本使用

目录

数据库的创建和删除

创建数据库

查看数据库

删除数据库

集合的创建和删除

显示创建

查看

删除集合

隐式创建

文档的插入和查询

单个文档的插入

insertOne

insertMany

查询

嵌入式文档

查询数组

查询数组元素

为数组元素指定多个条件

通过对数组元素使用复合筛选条件查询数组

查询满足多个条件的数组元素

按数组索引位置查询元素

按数组长度查询数组

查询嵌入式文档数组

查询嵌套在数组中的文档

在文档数组中的字段上指定查询条件

在文档数组中嵌入的字段上指定查询条件

使用数组索引查询嵌入式文档中的字段

为文档数组指定多个条件

单个嵌套文档满足嵌套字段的多个查询条件

组合满足标准的元素

Update

更新或插入（upsert）选项

更新集合中的文档

更新单份文档

更新多个文档

替换文档

使用聚合管道进行更新

[使用 $set 的 updateOne](#使用 $set 的 updateOne)

[find() 和 find().pretty() 有什么区别](#find() 和 find().pretty() 有什么区别)

[使用 $replaceRoot 和 $set 的 updateMany](#使用 $replaceRoot 和 $set 的 updateMany)

[使用 $set 的 updateMany](#使用 $set 的 updateMany)

[使用 $set 的 updateOne](#使用 $set 的 updateOne)

[使用 $addFields 的 updateMany](#使用 $addFields 的 updateMany)

replaceOne

删除

deleteOne

deleteMany

remove

WriteResul

---

参考： MongoDB CRUD 操作 - MongoDB 手册 v7.0

数据库的创建和删除

创建数据库

use database

数据库存在则使用(同 mysql 一样)，没有则创建

查看数据库

test> show dbs
admin   40.00 KiB
config  12.00 KiB
local   40.00 KiB

注意：当我们创建出新的数据库之后再次 show dbs 并不会出现新增的数据库，这个就涉及到 mongodb 的存储机制的问题了， mongodb 的存储分为上下两个部分，分别是内存部分和磁盘部分，当使用 use 去创建数据库时，其实数据库这会还在内存当中，并没有初始化到磁盘中去，那什么时候回存在在磁盘当中呢，就是在数据库中存在至少一个集合的时候，这个数据库他就会帮你持久化到磁盘当中去

有一些数据库名是保留的，可以直接访问这些特殊作用的数据库

• admin 从权限角度来看，这是 root 数据库，要是将一个用户添加到这个数据库当中，则这个用户会自动继承所有数据库的权限，一些特定的服务器命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器

• local 这个数据库永远不会被复制，可以用来存储仅限于本地但要服务器的任意集合

• config 当 mongodb 用于分片设置时，config 数据库在内部使用，用于保存分片的相关信息

删除数据库

adb> db.dropDatabase()
{ ok: 1, dropped: 'adb' }

集合的创建和删除

显示创建

adb> db.createCollection("wxw")
{ ok: 1 }

查看

adb> show collections
wxw

删除集合

adb> db.wxw.drop()
true

隐式创建

在接下来的文章中会有例子提及，还请耐心看完 ~~~~~~

文档的插入和查询

文档 （document） 的数据结构和 JSON 基本一样

所有存储在集合中的数据都是 BSON 格式

文档的插入

使用 install() 或者 save() 方法向集合中插入文档

单个文档的插入

参数说明

Parameter	Type	Description
document	document or array	要插入到集合的文档或者文档数组（json 格式）
writeConcern	document	可选的。表达书面关注的文件。省略使用默认写关注点。参见写关注。不明确设置写关注在事务中运行的操作。使用写关注点关于事务，请参见事务和写关注点。
ordered	boolean	可选。如果为真，则按顺序插入数组中的文档，如果其中一个文档出现错误，MongoDB 将返回而不处理属猪中的其余文档。如果为假，则执行无序插入，如果其中一个文档出现错误，则继续处理数组中的主文档。在版本 2.6+ 中默认为 true

insertOne

将一个文档插入到集合中

_id 字段

如果文档没有指定_id字段，那么mongod将在插入之前添加_id字段并为文档分配唯一的ObjectId()。大多数驱动程序创建一个ObjectId并插入_id字段，但如果驱动程序或应用程序没有创建并填充_id，则mongod将创建并填充_id。

如果文档包含_id字段，则_id值在集合中必须是唯一的，以避免重复键错误。

像这种插入集合的情况，首先本地并没有创建过集合，而是创建集合和插入数据是一块执行的这种操作就是隐式创建

try {
   db.products.insertOne( { item: "card", qty: 15 } );
} catch (e) {
   print (e);
};

返回这个则表示成功

{
  acknowledged: true,
  insertedId: ObjectId('66fac15c5fb050d96a964039')
}

因为文档没有包含id，所以mongod创建并添加了id字段，并为其分配了唯一的ObjectId()值。

ObjectId值特定于操作运行时的机器和时间。因此，您的值可能与示例中的值不同。

插入指定_id字段的文档

在下面的示例中，传递给insertOne()方法的文档包含*id字段。*id的值在集合中必须是唯一的，以避免重复键错误。

try {
   db.products.insertOne( { _id: 10, item: "box", qty: 20 } );
} catch (e) {
   print (e);
}

返回结果与上述同理

插入作为唯一索引一部分的任何键的重复值，例如id，会引发异常。下面的例子尝试插入一个已经存在的id值的文档:

try {
   db.products.insertOne( { _id: 10, "item" : "packing peanuts", "qty" : 200 } );
} catch (e) {
   print (e);
}

由于_id: 10已经存在，抛出以下异常:

WriteError({
   "index" : 0,
   "code" : 11000,
   "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 10.0 }",
   "op" : {
      "_id" : 10,
      "item" : "packing peanuts",
      "qty" : 200
   }
})

insertMany

将多个文档插入到集合中。

try {
   db.products.insertMany( [
      { item: "card", qty: 15 },
      { item: "envelope", qty: 20 },
      { item: "stamps" , qty: 30 }
   ] );
} catch (e) {
   print (e);
}

返回如下则表示成功

{
   "acknowledged" : true,
   "insertedIds" : [
      ObjectId("562a94d381cb9f1cd6eb0e1a"),
      ObjectId("562a94d381cb9f1cd6eb0e1b"),
      ObjectId("562a94d381cb9f1cd6eb0e1c")
   ]
}

这个 _id 还是上面的解释同理

try {
   db.products.insertMany( [
      { _id: 10, item: "large box", qty: 20 },
      { _id: 11, item: "small box", qty: 55 },
      { _id: 12, item: "medium box", qty: 30 }
   ] );
} catch (e) {
   print (e);
}

返回的结果也和上面大差不差

插入作为唯一索引一部分的任何键的重复值，例如_id，会引发异常。下面的例子尝试插入一个已经存在的_id值的文档:

try {
   db.products.insertMany( [
      { _id: 13, item: "envelopes", qty: 60 },
      { _id: 13, item: "stamps", qty: 110 },
      { _id: 14, item: "packing tape", qty: 38 }
   ] );
} catch (e) {
   print (e);
}

由于_id: 13已经存在，抛出以下异常:

BulkWriteError({
   "writeErrors" : [
      {
         "index" : 0,
         "code" : 11000,
         "errmsg" : "E11000 duplicate key error collection: inventory.products index: _id_ dup key: { : 13.0 }",
         "op" : {
            "_id" : 13,
            "item" : "stamps",
            "qty" : 110
         }
      }
   ],
   "writeConcernErrors" : [ ],
   "nInserted" : 1,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

查询

嵌入式文档

使用inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

 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'
      }
    ]);

查看一下是否插入成功

adb> db.inventory.find()
[
  {
    _id: ObjectId('66faccfb5f8cb68228964033'),
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    _id: ObjectId('66faccfb5f8cb68228964034'),
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'A'
  },
  {
    _id: ObjectId('66faccfb5f8cb68228964035'),
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    _id: ObjectId('66faccfb5f8cb68228964036'),
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    _id: ObjectId('66faccfb5f8cb68228964037'),
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]

查询数组

还是先插入一些数据

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]
  }
]);

匹配数组

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

相反，如果想查找同时包含 "red" 和 "blank" 元素的数组，而不考虑顺序或数组中的其他元素，则请使用 $all 运算符：

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

查询数组元素

要查询数组字段是否至少包含一个 具有指定值的元素，请使用筛选器 { <field>: <value> }，其中的 <value> 是元素值。

以下示例将查询所有文档，其中 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 }
});

查询满足多个条件的数组元素

使用 $elemMatch 运算符为数组的元素指定多个条件，以使至少一个数组元素满足所有指定的条件。

以下示例将查询特定文档，其中 dim_cm 数组至少包含一个大于 (gt) 22 且小于 (lt) 30 的元素：

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

按数组索引位置查询元素

使用点符号，可以在数组的特定索引或位置为元素指定查询条件。该数组使用从零开始的索引。

以下示例将查询所有文档，其中数组 dim_cm 中的第二个元素大于 25：

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

按数组长度查询数组

使用 $size 操作符以便按元素个数来查询数组。例如，以下示例会选择数组 tags 有 3 个元素的文档。

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

查询嵌入式文档数组

db.inventory.insertMany([
  {
    item: 'journal',
    instock: [
      { warehouse: 'A', qty: 5 },
      { warehouse: 'C', qty: 15 }
    ]
  },
  {
    item: 'notebook',
    instock: [{ warehouse: 'C', qty: 5 }]
  },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 15 }
    ]
  },
  {
    item: 'planner',
    instock: [
      { warehouse: 'A', qty: 40 },
      { warehouse: 'B', qty: 5 }
    ]
  },
  {
    item: 'postcard',
    instock: [
      { warehouse: 'B', qty: 15 },
      { warehouse: 'C', qty: 35 }
    ]
  }
]);

查询嵌套在数组中的文档

以下示例选择 instock 数组中的元素与指定文档匹配的所有文档：

db.inventory.find({
  instock: { warehouse: 'A', qty: 5 }
});

整个嵌入式/嵌套文档的相等匹配要求与指定文档精确 匹配，包括字段顺序。例如，以下查询不匹配 inventory 集合中的任何文档：

db.inventory.find({
  instock: { qty: 5, warehouse: 'A' }
});

在文档数组中的字段上指定查询条件

在文档数组中嵌入的字段上指定查询条件

如果您不知道嵌套在数组中的文档的索引位置，请使用点 (.) 来连接数组字段的名称以及嵌套文档中的字段名称。

以下示例选择满足下列条件的所有文档------instock 数组至少有一份嵌入式文档包含字段 qty 且其值小于或等于 20：

db.inventory.find({
  'instock.qty': { $lte: 20 }
});

使用数组索引查询嵌入式文档中的字段

使用点符号，可以在数组的特定索引或位置为文档中的字段指定查询条件。该数组使用从零开始的索引。

注意

使用点符号查询时，字段和索引必须位于引号内。

以下示例选择所有满足如下条件的文档------instock 数组的第一个元素是包含值小于或等于 20 的 qty 字段的文档：

db.inventory.find({
  'instock.0.qty': { $lte: 20 }
});

为文档数组指定多个条件

对嵌套在文档数组中的多个字段指定条件时，可指定查询，以使单个文档满足这些条件，或使数组中任意文档（包括单个文档）的组合满足这些条件。

单个嵌套文档满足嵌套字段的多个查询条件

使用 $elemMatch 操作符在大量嵌入式文档中指定多个条件，以使至少一个嵌入式文档满足所有指定条件。

以下示例查询满足如下条件的文档------instock 数组至少有一份嵌入式文档，该文档同时包含等于 5 的字段 qty 和等于 A 的字段 warehouse：

db.inventory.find({
  instock: { $elemMatch: { qty: 5, warehouse: 'A' } }
});

以下示例将查询 instock 数组至少包含一个嵌入文档，且该文档包含大于 qty 且小于或等于 20 的字段 10：

db.inventory.find({
  instock: { $elemMatch: { qty: { $gt: 10, $lte: 20 } } }
});

组合满足标准的元素

如果数组字段上的复合查询条件没有使用 $elemMatch 操作符，则查询会选择如下文档：数组中包含满足条件的任意元素的组合。

例如，以下查询匹配如下文档：嵌套在 instock 数组内的任何文档的 qty 字段大于 10 且该数组中的任何文档（不一定是同一份嵌入式文档）的 qty 字段小于或等于 20：

db.inventory.find({
  'instock.qty': { $gt: 10, $lte: 20 }
});

以下示例查询符合以下条件的文档 --- instock 数组至少有一个包含等于 5 的字段 qty 的嵌入式文档，以及至少一个包含等于 A 的字段 warehouse 的嵌入式文档（但不一定是同一个嵌入式文档）：

db.inventory.find({
  'instock.qty': 5,
  'instock.warehouse': 'A'
});

Update

更新或插入（upsert）选项

使用inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

db.insertMany([
  {
    item: 'canvas',
    qty: 100,
    size: { h: 28, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mat',
    qty: 85,
    size: { h: 27.9, w: 35.5, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'mousepad',
    qty: 25,
    size: { h: 19, w: 22.85, uom: 'cm' },
    status: 'P'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'P'
  },
  {
    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'
  },
  {
    item: 'sketchbook',
    qty: 80,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'sketch pad',
    qty: 95,
    size: { h: 22.85, w: 30.5, uom: 'cm' },
    status: 'A'
  }
]);

更新集合中的文档

要更新文档，MongoDB 提供 $set 等更新操作符来修改字段值。

如果字段不存在，某些更新操作符（例如$set ）将创建该字段。有关详细信息，请参阅各个更新操作符参考文档。

更新单份文档

以下示例使用 Collection.updateOne()方法在 inventory 集合上更新第一个 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 字段不存在，则 $currentDate 将创建该字段。有关详细信息，请参阅 $currentDate。

更新多个文档

如下示例使用 Collection.updateMany()方法（位于 inventory 集合上）更新 qty 小于 50 的所有文档：

db.inventory.updateMany(
  { qty: { $lt: 50 } },
  {
    $set: { 'size.uom': 'in', status: 'P' },
    $currentDate: { lastModified: true }
  }
);

更新操作：和上述操作一致

替换文档

要替换除 _id 字段之外的文档的所有内容，请将全新文档作为第二个参数传递给 Collection.replaceOne()。

替换文档时，替换文档必须仅包含字段/值对。替换文档不能包含更新操作符表达式。

替换文档可以具有与原始文档不同的字段。在替换文档中，您可以省略_id字段，因为_id字段不可变。但是，如果您确实包含_id字段，则它的值必须与当前值相同。

如下示例将替换 inventory 集合中的第一个 文档，其中的 item: "paper"：

db.inventory.replaceOne(
  { item: 'paper' },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 40 }
    ]
  }
);

使用聚合管道进行更新

通过更新操作，聚合管道可以包含以下阶段：

• [addFields](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/addFields/#mongodb-pipeline-pipe.-addFields "addFields")

• [set](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/set/#mongodb-pipeline-pipe.-set "set")

• [project](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/project/#mongodb-pipeline-pipe.-project "project")

• [unset](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/unset/#mongodb-pipeline-pipe.-unset "unset")

• [replaceRoot](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/replaceRoot/#mongodb-pipeline-pipe.-replaceRoot "replaceRoot")

• [replaceWith](https://www.mongodb.com/zh-cn/docs/manual/reference/operator/aggregation/replaceWith/#mongodb-pipeline-pipe.-replaceWith "replaceWith")

使用聚合分析管道可以进行更具表现力的更新声明，例如基于当前字段值的Express条件更新或使用另一个字段的值更新一个字段。

使用 $set 的 updateOne

创建一个 students 示例集合（如果该集合当前不存在，插入操作则会创建该集合）：

db.students.insertMany( [
   { _id: 1, test1: 95, test2: 92, test3: 90, modified: new Date("01/05/2020") },
   { _id: 2, test1: 98, test2: 100, test3: 102, modified: new Date("01/05/2020") },
   { _id: 3, test1: 95, test2: 110, modified: new Date("01/04/2020") }
] )

若要验证，请查询集合：

db.students.find()

以下 db.collection.updateOne() 操作会使用某一聚合管道来更新 _id: 3 的文档：

db.students.updateOne( { _id: 3 }, [ { $set: { "test3": 98, modified: "$$NOW"} } ] )

具体来说，管道包含一个 $set 阶段，该阶段将 test3 字段（并将其值设置为 98）添加到文档中，并将 modified 字段设置为当前日期时间。该操作使用聚合变量 NOW 作为当前日期时间。要访问变量，请使用 $ 作为前缀，并用引号括起来。

若要验证更新，您可以查询集合：

db.students.find().pretty()

find() 和 find().pretty() 有什么区别

1. db.collection.find()：

   • 这是最基本的查询方法，它会返回一个游标（cursor），这个游标可以用来遍历查询结果集中的所有文档。
   • 返回的结果通常是以JSON格式的字符串形式显示，但这个格式是紧凑的，没有缩进和换行，可读性较差。

2. db.collection.find().pretty()：

   • .pretty() 是一个辅助函数，它的作用是美化（pretty-print）查询结果。
   • 当你调用 .pretty() 方法时，MongoDB会将查询结果格式化为更易于阅读的格式，包括缩进和换行，使得结果更加清晰和易于理解。

使用 $replaceRoot 和 $set 的 updateMany

创建一个 students2 示例集合（如果该集合当前不存在，插入操作则会创建该集合）：

db.students2.insertMany( [
   { "_id" : 1, quiz1: 8, test2: 100, quiz2: 9, modified: new Date("01/05/2020") },
   { "_id" : 2, quiz2: 5, test1: 80, test2: 89, modified: new Date("01/05/2020") },
] )

以下 db.collection.updateMany() 操作会使用某一聚合管道来标准化此文档的字段（即，集合中的文档应具有相同字段）并更新 modified 字段：

db.students2.updateMany( {},
  [
    { $replaceRoot: { newRoot:
       { $mergeObjects: [ { quiz1: 0, quiz2: 0, test1: 0, test2: 0 }, "$$ROOT" ] }
    } },
    { $set: { modified: "$$NOW"}  }
  ]
)

具体而言，管道包括：

• 附带 $mergeObjects 表达式的 $replaceRoot 阶段，以便为 quiz1、quiz2、test1 和 test2 字段设置默认值。聚合变量 ROOT 是指当前修改的文档。要访问此变量，请将 $ 用作前缀，并用引号括起来。当前文档字段将覆盖这些默认值。

• $set 阶段，以便将 modified 字段更新为当前日期时间。此操作会将聚合变量 NOW 用作当前日期时间。要访问此变量，请将 $ 用作前缀，并用引号括起来。

使用 $set 的 updateMany

创建一个 students3 示例集合（如果该集合当前不存在，插入操作则会创建该集合）：

db.students3.insertMany( [
   { "_id" : 1, "tests" : [ 95, 92, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 2, "tests" : [ 94, 88, 90 ], "modified" : ISODate("2019-01-01T00:00:00Z") },
   { "_id" : 3, "tests" : [ 70, 75, 82 ], "modified" : ISODate("2019-01-01T00:00:00Z") }
] );

以下 db.collection.updateMany() 操作使用某一聚合管道来更新具有计算得出的平均成绩和字母成绩的文档。

db.students3.updateMany(
   { },
   [
     { $set: { average : { $trunc: [ { $avg: "$tests" }, 0 ] }, modified: "$$NOW" } },
     { $set: { grade: { $switch: {
                           branches: [
                               { case: { $gte: [ "$average", 90 ] }, then: "A" },
                               { case: { $gte: [ "$average", 80 ] }, then: "B" },
                               { case: { $gte: [ "$average", 70 ] }, then: "C" },
                               { case: { $gte: [ "$average", 60 ] }, then: "D" }
                           ],
                           default: "F"
     } } } }
   ]
)

具体而言，管道包括：

• $set 阶段，以便计算 tests 数组元素的截断后的平均值并将 modified 字段更新为当前日期时间。为计算截断后的平均值，此阶段会使用 $avg 和 $trunc 表达式。该操作使用聚合变量 NOW 作为当前日期时间。 要访问变量，请使用 $ 作为前缀，并用引号括起来。

• $set 阶段，以便使用 $switch 表达式并根据 average 来添加 grade 字段。

使用 $set 的 updateOne

创建一个 students4 示例集合（如果该集合当前不存在，插入操作则会创建该集合）：

db.students4.insertMany( [
  { "_id" : 1, "quizzes" : [ 4, 6, 7 ] },
  { "_id" : 2, "quizzes" : [ 5 ] },
  { "_id" : 3, "quizzes" : [ 10, 10, 10 ] }
] )

以下 db.collection.updateOne() 操作使用聚合管道向具有 _id: 2 的文档添加测验分数：

db.students4.updateOne( { _id: 2 },
  [ { $set: { quizzes: { $concatArrays: [ "$quizzes", [ 8, 6 ]  ] } } } ]
)

使用 $addFields 的 updateMany

创建一个包含摄氏度温度的 temperatures 示例集合（如果该集合当前不存在，插入操作将创建该集合）：

db.temperatures.insertMany( [
  { "_id" : 1, "date" : ISODate("2019-06-23"), "tempsC" : [ 4, 12, 17 ] },
  { "_id" : 2, "date" : ISODate("2019-07-07"), "tempsC" : [ 14, 24, 11 ] },
  { "_id" : 3, "date" : ISODate("2019-10-30"), "tempsC" : [ 18, 6, 8 ] }
] )

以下 db.collection.updateMany() 操作使用聚合管道以相应的华氏度温度更新文档：

db.temperatures.updateMany( { },
  [
    { $addFields: { "tempsF": {
          $map: {
             input: "$tempsC",
             as: "celsius",
             in: { $add: [ { $multiply: ["$$celsius", 9/5 ] }, 32 ] }
          }
    } } }
  ]
)

具体来说，此管道包含 $addFields阶段，它可用于添加包含华氏温度的新数组字段 tempsF。要将 tempsC 数组中的每个摄氏温度转换为华氏温度，此阶段会使用 map、add 和 $multiply 表达式。

replaceOne

基于筛选器替换集合中的单个文档。

replaceOne()使用替换文档替换集合中与过滤器匹配的第一个匹配文档。

举例子

餐厅收藏包含以下文件:

{ "_id" : 1, "name" : "Central Perk Cafe", "Borough" : "Manhattan" },
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "Borough" : "Queens", "violations" : 2 },
{ "_id" : 3, "name" : "Empire State Pub", "Borough" : "Brooklyn", "violations" : 0 }

下面的操作替换名称为:"Central Perk Cafe"的单个文档:

try {
   db.restaurant.replaceOne(
      { "name" : "Central Perk Cafe" },
      { "name" : "Central Pork Cafe", "Borough" : "Manhattan" }
   );
} catch (e){
   print(e);
}

如果没有找到匹配项，则返回:

{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }

设置upsert: true将在没有找到匹配项时插入文档。参见"替换"

用Upsert代替

餐厅收藏包含以下文件:

{ "_id" : 1, "name" : "Central Perk Cafe", "Borough" : "Manhattan",  "violations" : 3 },
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "Borough" : "Queens", "violations" : 2 },
{ "_id" : 3, "name" : "Empire State Pub", "Borough" : "Brooklyn", "violations" : 0 }

下面的操作尝试用名称:"Pizza Rat's Pizzaria"替换文档，upsert: true:

try {
   db.restaurant.replaceOne(
      { "name" : "Pizza Rat's Pizzaria" },
      { "_id": 4, "name" : "Pizza Rat's Pizzaria", "Borough" : "Manhattan", "violations" : 8 },
      { upsert: true }
   );
} catch (e){
   print(e);
}

由于upsert: true，文档是基于替换文档插入的。

{
   "acknowledged" : true,
   "matchedCount" : 0,
   "modifiedCount" : 0,
   "upsertedId" : 4
}

该集合现在包含以下文档:

{ "_id" : 1, "name" : "Central Perk Cafe", "Borough" : "Manhattan", "violations" : 3 },
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "Borough" : "Queens", "violations" : 2 },
{ "_id" : 3, "name" : "Empire State Pub", "Borough" : "Brooklyn", "violations" : 0 },
{ "_id" : 4, "name" : "Pizza Rat's Pizzaria", "Borough" : "Manhattan", "violations" : 8 }

替换为写关注点

给定一个包含三个成员的副本集，下面的操作指定w为majority, wtimeout为100:

try {
   db.restaurant.replaceOne(
       { "name" : "Pizza Rat's Pizzaria" },
       { "name" : "Pizza Rat's Pub", "Borough" : "Manhattan", "violations" : 3 },
       { w: "majority", wtimeout: 100 }
   );
} catch (e) {
   print(e);
}

如果确认时间超过wtimeout限制，则抛出以下异常:

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})

删除

deleteOne

从集合中删除单个文档。

举例

删除单个文档

订单集合具有以下结构的文档:

db.orders.insertOne(
   {
      _id: ObjectId("563237a41a4d68582c2509da"),
      stock: "Brent Crude Futures",
      qty: 250,
      type: "buy-limit",
      limit: 48.90,
      creationts: ISODate("2015-11-01T12:30:15Z"),
      expiryts: ISODate("2015-11-01T12:35:15Z"),
      client: "Crude Traders Inc."
   }
)

删除id为ObjectId("563237a41a4d68582c2509da")的订单。

try {
   db.orders.deleteOne( { _id: ObjectId("563237a41a4d68582c2509da") } );
} catch (e) {
   print(e);
}

下面的操作删除第一个过期日期大于ISODate("2015-11-01T12:40:15Z")的文档

try {
   db.orders.deleteOne( { expiryts: { $lt: ISODate("2015-11-01T12:40:15Z") } } );
} catch (e) {
   print(e);
}

deleteMany

从集合中删除与筛选器匹配的所有文档。

举例

删除多个文档

订单集合具有以下结构的文档:

db.orders.insertOne(
   {
      _id: ObjectId("563237a41a4d68582c2509da"),
      stock: "Brent Crude Futures",
      qty: 250,
      type: "buy-limit",
      limit: 48.90,
      creationts: ISODate("2015-11-01T12:30:15Z"),
      expiryts: ISODate("2015-11-01T12:35:15Z"),
      client: "Crude Traders Inc."
   }
)

下面的操作删除客户:"Crude Traders Inc."的所有文档：

try {
   db.orders.deleteMany( { "client" : "Crude Traders Inc." } );
} catch (e) {
   print (e);
}

下面的操作删除所有文档: "Brent Crude Futures" 且极限值大于48.88;

try {
   db.orders.deleteMany( { "stock" : "Brent Crude Futures", "limit" : { $gt : 48.88 } } );
} catch (e) {
   print (e);
}

remove

从集合中删除文档。

以下是 remove() 方法的示例。

db.bios.remove( { } )

此操作不等同于 drop() 方法。

要从集合中删除所有文档，更高效的做法是使用 drop() 方法删除整个集合（包括索引），然后重新创建该集合并重建索引。

以下操作会删除集合 products 中 qty 大于 20 的所有文档：

db.products.remove( { qty: { $gt: 20 } } )

WriteResult

remove() 会返回一个包含操作状态的 WriteResult() 对象。成功后，WriteResult() 对象将包含被删除文档数量的信息。

WriteResult({ "nRemoved" : 4 })