NoSQL 之 MongoDB - 03 MongoDB CRUD

CURD 操作

官方文档：

• Query Documents
• MongoDB CRUD Operations
• mongosh Methods

请保证 MongoDB 服务是开启状态。

创建文档

Insert Documents — MongoDB Manual

创建或插入操作将新文档添加到集合中。如果集合当前不存在，则插入操作将创建集合。

常用方法：

方法	说明
db.collection.insertOne()	插入单个文档到集合中
db.collection.insertMany()	插入多个文档
db.collection.insert()	将1个或多个文档插入到集合中。与 insertOne 和 insertMany 不同的是，前面两个会返回插入数据的 _id，而 insert 不会。注意：官方不建议使用 insert。

collection 表示集合名称

插入单个文档

db.inventory.insertOne(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)

或者

db.inventory.insert(
   { item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }
)

插入多个文档

db.inventory.insertMany([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

或者

db.inventory.insert([
   { item: "journal", qty: 25, tags: ["blank", "red"], size: { h: 14, w: 21, uom: "cm" } },
   { item: "mat", qty: 85, tags: ["gray"], size: { h: 27.9, w: 35.5, uom: "cm" } },
   { item: "mousepad", qty: 25, tags: ["gel", "blue"], size: { h: 19, w: 22.85, uom: "cm" } }
])

插入行为

• 集合创建
  • 如果集合当前不存在，则插入操作将创建集合。
• _id 字段
  • 在 MongoDB 中，存储在集合中的每个文档都需要一个唯一的 _id 字段作为主键
  • 如果插入的文档省略了 _id 字段，MongoDB 驱动程序会自动为 _id 字段生成 ObjectId

查询文档

Query Documents — MongoDB Manual

读取操作从集合中检索文档，即查询集合中的文档。

常用方法：

方法	说明
db.collection.find(query, projection)	查询所有满足条件的文档 query：可选，使用查询操作符指定查询条件。若要返回集合中所有文档，请忽略此参数或传递空文档（{}） projection：可选，使用投影运算符指定要在与查询筛选器匹配的文档中返回的字段。若要返回匹配文档中所有字段，请忽略此参数。 更多详情查看 db.collection.find()
db.collection.findOne(query, projection)	查询符合条件的第一个文档，如果没有文档满足查询，则返回 null

有关查询运算符和投影运算符的详细信息参考：Query and Projection Operatorsl

基础查询

练习之前先生成一些测试数据：

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

查询所有文档

db.inventory.find({})

等价于下面的 SQL 语句

SELECT * FROM inventory

指定返回的文档字段

db.inventory.find({}, {
  // 1 or true 表示返回，0 or false 表示排除，两者不能同时存在
  item: 1, 
  qty: true
})

更多 projection 参数介绍请查看 db.collection.find() - projection

相等条件查询

要指定想等条件，请在 query 参数中使用 <field>: <value> 表达式：

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

等价于下面的 SQL 语句

SELECT * FROM inventory WHERE status = "D"

指定 AND 条件

复查查询可以为集合文档中的多个字段指定条件。默认会隐式的使用 AND 逻辑连接查询条件。

// $lt 表示小于
db.inventory.find( { status: "A", qty: { $lt: 30 } } )

等价于下面的 SQL 语句

SELECT * FROM inventory WHERE status = "A" AND qty < 30

指定 OR 条件

使用 $or 运算符，可以指定一个复合查询，该查询将每个子句与一个 OR 逻辑连接起来，以便查询选择集合中至少符合一个条件的文档。

// 数组中的查询条件使用 `OR` 逻辑连接
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

等价于下面的 SQL 语句

SELECT * FROM inventory WHERE status = "A" OR qty < 30

指定 AND 和 OR 条件

// item 和 $or 使用 `AND` 连接
// $or 指定的数组使用 `OR` 连接
db.inventory.find({
    // JS 正则表达式：匹配 `j` 开头
    item: /^j/,
    $or: [{ status: "A" }, { qty: { $lt: 30 } }]
})

等价于下面的 SQL 语句

SELECT * FROM inventory WHERE item LIKE "j%" AND (status = "A" OR qty < 30)

查询嵌入/嵌套文档

Query on Embedded/Nested Documents

匹配嵌入/嵌套文档

要在嵌入/嵌套文档的字段上指定想等条件，请使用 {<field>: <value>} 查询，其中 <value> 是要匹配的文档。

例如，以下查询条件会筛选 size 字段等于文档类型 { h: 14, w: 21, uom: "cm" } 的全部文档：

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

整个嵌入文档的相等匹配要求与指定的 <value> 文档（包括字段顺序）完全匹配。例如，以下查询条件与 inventory 集合中的任何文档都不匹配：

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

查询嵌套字段

要指定嵌入/嵌套文档中字段的查询条件，请使用点表示法（"field.nextedField"）。

注意：使用点表示法查询时，字段和嵌套字段必须位于引号内。

在嵌套字段上指定相等匹配

以下示例查询嵌套在 size 字段中的 uom 字段等于 "in" 的所有文档：

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

使用查询运算符指定匹配

查询筛选文档可以使用查询运算符以以下形式指定条件：

{ <field1>: { <operator1>: <value1> }, ... }

以下查询在 size 字段中嵌套的 h 字段上使用小于（less than）运算符（$lt）：

db.inventory.find( { "size.h": { $lt: 15 } } )

指定 AND 条件

以下示例查询嵌套字段 h 小于 15，嵌套字段 uom 等于 "in"，以及 status 字段等于 "D" 的全部文档：

db.inventory.find( { "size.h": { $lt: 15 }, "size.uom": "in", status: "D" } )

查询数组

Query an Array

插入测试数据：

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

匹配数组

要在数组上指定相等条件，请使用 {<field>: <value>} 查询，其中 <value> 是要匹配的精确数组，包括元素的顺序。

以下示例查询字段 tags 值为按指定顺序刚好包含两个元素 "red" 和 "blank" 的数组的所有文档：

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" } )

要在数组字段中的元素上指定条件，可以像查询顶级数据一样指定查询语句：

{ <array field>: { <operator1>: <value1>, ... } }

例如，以下操作查询数组 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 } } } )

按数组索引位置查询元素

使用点表示法，可以在数组的特定索引或位置为元素指定查询条件。初始索引为 0。

注意：使用点表示法查询时，字段和嵌套字段必须位于引号内。

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

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

按数组长度查询数组

使用 $size 运算符按元素数量查询数组。例如，下例查询数组 tags 有 3 个元素的文档。

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

查询嵌入文档的数组

Query an Array of Embedded Documents

插入测试数据：

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

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

使用点表示法，可以为文档中特定索引或数组位置的字段指定查询条件。初始索引为 0。

注意：使用点表示法进行查询时，字段和索引必须位于引号内。

以下示例查询 instock 数组的第一个元素为包含字段 qty（其值小于等于 20）的文档的所有文档：

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

为文档数组指定多个条件

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

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

使用 $elemMatch 运算符在嵌入文档数组上指定多个条件，匹配至少一个嵌入文档满足所有指定条件。

以下示例查询 instock 数组中至少有一个嵌入文档的全部文档，这些嵌入文档至少有一个同时包含字段 qty（等于 5） 和 字段 warehouse（等于 A）：

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

以下示例查询 instock 数组中至少有一个嵌入文档的全部文档，这些嵌入文档至少有一个包含字段 qty（大于 10 且小于等于 20）：

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 数组中至少包含一个嵌入文档的全部文档，这些嵌入文档至少有一个的 qty 字段等于 5，且至少有一个的 warehouse 字段等于 A：

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

指定从查询返回的投影字段

Project Fields to Return from Query

默认情况下，MongoDB 中的查询返回匹配文档中的所有字段。要限制 MongoDB 发送给应用程序的数据量，可以使用一个投影文档（projection document）来指定或限制要返回的字段。

插入测试数据：

db.inventory.insertMany( [
  { item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] },
  { item: "notebook", status: "A",  size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] },
  { item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] },
  { item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] },
  { item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" }, instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);

返回匹配文档中的所有字段

如果未指定投影文档，db.collection.find() 方法将返回匹配文档中的所有字段。

以下示例返回 inventory 集合中 status 为 "A" 的所有文档中的所有字段：

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

等价于下面的 SQL 语句

SELECT * from inventory WHERE status = "A"

仅返回指定字段和 _id 字段

通过在投影文档中将 <field> 设置为 1 显式的指定返回字段。

以下操作返回与查询匹配的所有文档。在结果中，匹配文档中仅返回 item、status 以及默认返回的 _id 字段。

db.inventory.find( { status: "A" }, { item: 1, status: 1 } )

等价于下面的 SQL 语句

SELECT _id, item, status FROM inventory WHERE status = "A"

排除 _id 字段

通过在投影中将 _id 字段设置为 0，可以从结果中删除该字段，如下例所示：

db.inventory.find( { status: "A" }, { item: 1, status: 1, _id: 0 } )

等价于下面的 SQL 语句

SELECT item, status FROM inventory WHERE status = "A"

注意：除了 _id 字段之外，您不能在投影文档中组合使用包含和排除语句。

返回除排除字段外的所有字段

您可以使用投影排除特定字段，而不是在匹配文档中列出要返回的字段。

以下示例返回匹配文档中除了 status 和 instock 字段外的所有字段：

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

注意：除了 _id 字段之外，您不能在投影文档中组合使用包含和排除语句。

返回嵌入文档中的特定字段

可以在嵌入文档中返回特定字段。使用点表示法引用嵌入字段，并在投影文档中设置为 1。

以下示例返回：

• _id 字段（默认情况下返回）
• item 字段
• status 字段
• size 文档中的 uom 字段

uom 字段仍嵌入在 size 文档中。

db.inventory.find(
   { status: "A" },
   { item: 1, status: 1, "size.uom": 1 }
)

从 MongoDB 4.4 开始，还可以使用嵌套形式指定嵌入字段，例如 { item: 1, status: 1, size: { uom: 1 } }。

排除嵌入文档中的特定字段

可以排除嵌入文档中的特定字段。使用点表示法引用投影文档中的嵌入字段，并设置为 0。

以下示例指定一个投影，以排除 size 文档中的 uom 字段。所有其他字段将在匹配文档中返回：

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

从 MongoDB 4.4 开始，还可以使用嵌套形式指定嵌入字段，例如 { size: { uom: 0 } }。

数组中嵌入文档的投影

使用点表示法在嵌入数组的文档中投影特定字段。

以下示例指定要返回的投影：

• _id 字段（默认情况下返回）
• item 字段
• status 字段
• instock 数组中嵌入的文档中的 qty 字段

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

返回数组中投影指定的数组元素

对于包含数组的字段，MongoDB 提供以下用于操作数组的投影运算符：$elemMatch，$slice 和 $。

以下示例使用 $slice 投影运算符返回 instock 数组中的最后一个元素：

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

$elemMatch，$slice 和 $ 是将特定元素投影到返回数组中的唯一方法。

例如，不能使用数组索引投影特定数组元素；就像 { "instock": 1 } 投影的不是仅包含第一个元素的数组。

查询字段或缺少字段

Query for Null or Missing Fields

MongoDB 中的不同查询运算符对 null 值的处理方式不同。

插入测试数据：

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

相等过滤器

{ item: null } 查询匹配包含值为 null 的 item 字段或不包含 item 字段的文档。

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

该查询返回集合中的两个文档。

类型检查

{ item: { $type: 10 } } 查询只匹配包含值为 null 的 item 字段的文档；即 item 字段的值为 BSON Type Null（类型标识符代码 10）：

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

该查询只返回测试数据中 _id 为 1 的数据。

存在性检查

以下示例查询不包含字段的文档。

{ item: { $exists: false } } 查询匹配不包含 item 字段的文档：

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

该查询只返回测试数据中 _id 为 2 的数据。

在 MongoDB 4.2 之前的版本，用户可以将 $type: 0 用作和 $exists: false 相同作用的过滤器。4.2 版本之后会报错 无效的类型标识符代码。

更新文档

Update Documents

更新操作会修改集合中的现有文档。

常用方法：

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

您可以指定用于标识要更新的文档的查询条件或过滤器。这些过滤器使用与读取操作相同的语法。

插入测试数据：

db.inventory.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）来修改字段的值。

要使用更新运算符，请向更新方法传递如下格式的更新文档（update document）：

{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

如果字段不存在，一些更新运算符（如 $set）将创建该字段。更多请参阅各个更新运算符的详细信息。

更新单个文档

以下示例在 inventory 集合上使用 db.collection.updateOne() 方法更新满足 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 将创建该字段。

更新多个文档

以下示例在 inventory 集合上使用 db.collection.updateMany() 方法更新满足 qty 小于 50 条件的全部文档：

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

替换文档

要替换 _id 字段以外的全部内容，请将一个全新的文档（替换文档 replace document）作为第二个参数传递个 db.collection.replaceOne()。

替换时，替换文档必须仅由 <field>: <value> 对组成；即不包含更新运算符表达式。

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

以下示例替换了 inventory 集合中 item 为 "paper" 的第一个文档：

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

行为

_id 字段

文档一旦设置，您无法更新 _id 字段的值，也无法使用具有不同 _id 字段值的替换文档替换现有文档。

字段顺序

对于写操作，MongoDB 保留文档字段的顺序，但以下情况除外：

• _id 字段始终是文档的第一个字段
• 包含重命名字段名（$rename）的更新操作可能会导致文档中字段的重新排序

删除文档

Delete Documents

删除操作从集合中删除文档。常用方法：

• db.collection.deleteOne
• db.collection.deleteManu

您可以指定用于标识要删除的文档的查询条件或过滤器。这些过滤器使用与读取操作相同的语法。

插入测试数据：

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

删除所有文档

要从集合中删除所有文档，请将空的过滤器文档（filter document） {} 传递给 db.collection.deleteMany() 方法。

以下示例从 inventory 集合中删除所有文档：

db.inventory.deleteMany({})

删除符合条件的所有文档

您可以指定用于标识要删除的文档的查询条件或过滤器。这些过滤器使用与读取操作相同的语法。

要指定相等条件，请在查询过滤文档（query filter document）中使用 <field>: <value> 表达式：

{ <field1>: <value1>, ... }

查询过滤文档可以使用查询运算符以以下形式指定条件：

{ <field1>: { <operator1>: <value1> }, ... }

要删除符合删除条件的所有文档，请将过滤器参数传递给 deleteMany() 方法。

以下示例从 inventory 集合中删除 status 字段等于 "A" 的所有文档：

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

仅删除一个符合条件的文档

要删除最多一个与指定过滤器匹配的文档（即使可以匹配多个文档），请使用 db.collection.deleteOne() 方法。

以下示例删除 status 为 "D" 的第一个文档：

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