MongoDB CRUD基础操作

最新推荐文章于 2022-10-08 20:50:55 发布

木西爷

最新推荐文章于 2022-10-08 20:50:55 发布

阅读量605

点赞数

分类专栏： MongoDB 文章标签： mongodb

本文链接：https://blog.csdn.net/qq_33642970/article/details/104021754

版权

MongoDB 专栏收录该内容

16 篇文章 13 订阅

订阅专栏

本例中将以java语言为例，进行讲解。其它语言可以参考：https://docs.mongodb.com/manual/tutorial/insert-documents/

注：mongodb-java-driver 从3.0版本开始同时支持同步、异步方式（分别是不同的驱动应用）。本次介绍的插入是异步，其它均是同步。

为了方便平时mongodb库操作，我会在介绍相关的java方法时，提供mongo shell操作。

maven jar下载：https://mvnrepository.com/artifact/org.mongodb

一、插入文档

这个页面提供了在MongoDB中插入操作的例子。

提示：如果集合当前不存在，插入操作将创建集合。

1.插入单个文档

com.mongodb.reactivestreams.client.MongoCollection.insertOne使用Java反应性流驱动程序将单个文档插入到集合中：

{ item: "canvas", qty: 100, tags: ["cotton"], size: { h: 28, w: 35.5, uom: "cm" } }

mongo shell：

db.collection.insertOne()

示例

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

查找：
db.inventory.find( { item: "canvas" } )

下面的示例将上述文档插入库存集合。如果文档没有指定_id字段，则驱动程序将带有ObjectId值的_id字段添加到新文档。看到插入行为。

Document canvas = new Document("item", "canvas")
        .append("qty", 100)
        .append("tags", singletonList("cotton"));

Document size = new Document("h", 28)
        .append("w", 35.5)
        .append("uom", "cm");
canvas.put("size", size);

Publisher<Success> insertOnePublisher = collection.insertOne(canvas);

com.mongodb.reactivestreams.client.MongoCollection.insertOne返回一个Publisher对象。当订阅者请求数据时，发布者将文档插入到集合中。
要检索您刚才插入的文档，query the collection:

FindPublisher<Document> findPublisher = collection.find(eq("item", "canvas"));

2.批量插入多个文档

新版本3.2。
com.mongodb.reactivestreams.client.MongoCollection.html.insertMany使用Java反应性流驱动程序插入以下文档:

{ 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字段，则驱动程序将带有ObjectId值的_id字段添加到每个文档。看到 Insert Behavior。

Document journal = new Document("item", "journal")
        .append("qty", 25)
        .append("tags", asList("blank", "red"));

Document journalSize = new Document("h", 14)
        .append("w", 21)
        .append("uom", "cm");
journal.put("size", journalSize);

Document mat = new Document("item", "mat")
        .append("qty", 85)
        .append("tags", singletonList("gray"));

Document matSize = new Document("h", 27.9)
        .append("w", 35.5)
        .append("uom", "cm");
mat.put("size", matSize);

Document mousePad = new Document("item", "mousePad")
        .append("qty", 25)
        .append("tags", asList("gel", "blue"));

Document mousePadSize = new Document("h", 19)
        .append("w", 22.85)
        .append("uom", "cm");
mousePad.put("size", mousePadSize);

Publisher<Success> insertManyPublisher = collection.insertMany(asList(journal, mat, mousePad));

mongo shell：

批量插入：
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.find( {} )
注：mongo shell 游标默认只显示前20个。

com.mongodb.reactivestreams.client.MongoCollection.html.insertMany返回一个Publisher对象。当订阅者请求数据时，发布者将文档插入到集合中。
要检索插入的文档，查询集合:

FindPublisher<Document> findPublisher = collection.find(new Document());

3.插入行为

3.1 创建集合

如果集合当前不存在，插入操作将创建集合。

3.2 _id域

在MongoDB中，存储在集合中的每个文档都需要一个惟一的_id字段作为主键。如果插入的文档省略了_id字段，MongoDB驱动程序将自动为_id字段生成ObjectId。

这也适用于通过upsert: true的更新操作插入的文档。

3.3 Atomicity

MongoDB中的所有写操作都是单个文档级别上的原子操作。有关MongoDB和原子性的更多信息，请参见 Atomicity and Transactions。

3.4 写确认

使用写关注点，您可以为写操作指定从MongoDB请求的确认级别。有关详细信息，请参见 Write Concern。

4.插入方法

MongoDB提供了以下方法将文档插入到集合中:

`db.collection.insertOne()`	将单个文档插入到集合中。
`db.collection.insertMany()`	`db.collection.insertMany()` 将多个文档插入到集合中。
`db.collection.insert()`	`db.collection.insert()` 将单个文档或多个文档插入到集合中。

4.1插入的其他方法

以下方法也可以将新文档添加到集合中:

db.collection.update() when used with the upsert: true option.
db.collection.updateOne() when used with the upsert: true option.
db.collection.updateMany() when used with the upsert: true option.
db.collection.findAndModify() when used with the upsert: true option.
db.collection.findOneAndUpdate() when used with the upsert: true option.
db.collection.findOneAndReplace() when used with the upsert: true option.
db.collection.save().
db.collection.bulkWrite().

二、查询文档

本页提供了使用com.mongodb.reactivestreams.client.MongoCollection.find进行查询操作的示例。在MongoDB Java反应流驱动程序中查找方法。

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

1.选择集合中的所有文档

要选择集合中的所有文档，请将一个空文档作为查询筛选器参数传递给find方法。查询过滤器参数决定选择条件:

FindPublisher<Document> findPublisher = collection.find(new Document());

mongo shell：

db.inventory.find( {} )

该操作对应于以下SQL语句:

SELECT * FROM inventory

有关该方法语法的更多信息，请参见com.mongodb.reactivestreams.client.MongoCollection.find。

2.指定查询条件

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq方法创建 query filter document:

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

以下示例从库存集合中选择状态为“D”的所有文档:

findPublisher = collection.find(eq("status", "D"));

mongo shell：

形式：{ <field1>: <value1>, ... }

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

该操作对应于以下SQL语句:

SELECT * FROM inventory WHERE status = "D"

3.使用查询操作符指定条件

除了相等条件之外，MongoDB还提供了各种查询操作符来指定过滤条件。使用com.mongodb.client.model.Filters帮助器方法，以促进过滤器文档的创建。例如:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

以下示例从inventory集合中检索状态为“A”或“D”的所有文档:

findIterable = collection.find(in("status", "A", "D"));

mongo shell：

形式：{ <field1>: { <operator1>: <value1> }, ... }

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

提示：虽然可以使用$or操作符来表示此查询，但在对同一字段执行相等性检查时，请使用$in操作符而不是$or操作符。

操作对应如下SQL语句:

SELECT * FROM inventory WHERE status in ("A", "D")

有关MongoDB查询操作符的完整列表，请参阅 Query and Projection Operators。

4.指定and条件

复合查询可以为集合文档中的多个字段指定条件。逻辑和连接将隐式地连接复合查询的子句，以便查询选择集合中匹配所有条件的文档。

以下示例检索库存集合中状态为“A”且数量小于($lt) 30的所有文档:

findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));

mongo shell：

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

操作对应如下SQL语句:

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

5.指定or条件

使用$or操作符，您可以指定一个复合查询，它用逻辑或连接连接每个子句，以便查询选择集合中至少匹配一个条件的文档。

以下示例检索集合中状态为“A”或qty小于($lt) 30的所有文档:

findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));

mongo shell：

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

操作对应如下SQL语句:

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

提示：使用比较运算符的查询受制于类型括号。

6.指定and以及or条件

在下面的示例中，复合查询文档选择集合中状态为“A”且qty小于($lt) 30或item以字符p开头的所有文档:

findIterable = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);

mongo shell：

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

操作对应如下SQL语句:

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

提示：MongoDB支持正则表达式$regex查询来执行字符串模式匹配。

7.Behavior

7.1 Cursor

The com.mongodb.client.MongoCollection.find方法返回一个 com.mongodb.client.FindIterable接口的实例.

7.2 Read Isolation（读隔离）

新版本3.2。
对于对复制集和复制集碎片的读取，read concern允许客户端为其读取选择一个隔离级别。有关更多信息，请参阅 Read Concern。

8.附加方法

以下方法也可以从一个集合中读取文档:

在聚合管道中，$match管道阶段提供对MongoDB查询的访问。参见Java同步驱动程序聚合示例。

9.查询嵌入/嵌套的文档

本页面提供了使用com.mongodb.client.MongoCollection.find对嵌入/嵌套文档进行查询操作的示例。在MongoDB Java Synchronous Driver中查找方法。

提示：驱动程序提供了com.mongodb.client.model.Filters帮助器方法，以促进过滤器文档的创建。此页上的示例使用这些方法创建筛选器文档。

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

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

9.1 匹配嵌入/嵌套的文档

要在嵌入/嵌套文档的字段上指定相等条件，请使用筛选器文档eq(<field1>， <value>)，其中<value>是要匹配的文档。
例如，下面的查询选择字段size等于文档{h: 14, w: 21, uom: "cm"}的所有文档:

FindIterable<Document> findIterable = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

mongo shell：

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

在整个嵌入式文档上的相等匹配要求精确匹配指定的<value>文档，包括字段顺序。例如，以下查询与库存收集中的任何文档不匹配:

findIterable = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

mongo shell：

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

9.2 嵌套字段查询

要在嵌入/嵌套文档的字段上指定查询条件，请使用点符号(“field.nestedField”)。

提示：使用点符号进行查询时，字段和嵌套字段必须放在引号内。

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

下面的例子选择了所有的文档，其中字段uom嵌套在size字段等于“in”:

findIterable = collection.find(eq("size.uom", "in"));

mongo shell：

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

9.2.2 使用查询操作符指定匹配

除了相等条件之外，MongoDB还提供了各种查询操作符来指定过滤条件。使用com.mongodb.client.model。过滤器帮助器方法，以促进过滤器文档的创建。例如:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

下面的查询使用了嵌入在size字段中的字段h上的小于操作符($lt):

findIterable = collection.find(lt("size.h", 15));

mongo shell：

形式：
{ <field1>: { <operator1>: <value1> }, ... }

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

9.2.3 指定and条件

下面的查询选择嵌套字段h小于15、嵌套字段uom等于“in”、状态字段等于“D”的所有文档:

findIterable = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

mongo shell：

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

10.查询一个数组

本页提供了使用com.mongodb.client.MongoCollection.find对数组字段进行查询操作的示例。在MongoDB Java同步驱动程序中查找方法。

提示：驱动程序提供了com.mongodb.client.model.Filters帮助器方法，以促进过滤器文档的创建。此页上的示例使用这些方法创建筛选器文档。

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

mongo shell：

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

10.1匹配一个数组

要指定数组上的相等条件，请使用查询文档eq(<field>， <value>)，其中<value>是要匹配的精确数组，包括元素的顺序。
以下示例查询所有文档，其中字段标记值是一个数组，其中有两个元素“red”和“blank”，按指定的顺序排列:

FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));

mongo shell：

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

相反，如果您希望找到一个同时包含元素“red”和“blank”的数组，而不考虑数组中的顺序或其他元素，请使用$all操作符:

findIterable = collection.find(all("tags", asList("red", "blank")));

mongo shell：

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

10.2 查询数组获取元素

要查询数组字段是否包含至少一个具有指定值的元素，可以使用 eq(<field>， <value>)过滤，其中<value>是元素值。
以下示例查询所有文档，其中标记是一个数组，其中包含字符串“red”作为其元素之一:

findIterable = collection.find(eq("tags", "red"));

要指定数组字段中元素的条件，请在查询筛选器文档中使用查询操作符。例如:

and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)

例如，下面的操作查询所有的文档，其中数组dim_cm至少包含一个值大于25的元素。

findIterable = collection.find(gt("dim_cm", 25));

mongo shell：

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

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

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

10.3 为数组元素指定多个条件

在数组元素上指定复合条件时，可以指定这样的查询:单个数组元素满足这些条件，或者数组元素的任何组合满足这些条件。

10.3.1 查询数组元素上具有复合筛选条件的数组

下面的示例查询文档，其中dim_cm数组包含在某些组合中满足查询条件的元素;例如，一个元素可以满足大于15的条件，另一个元素可以满足小于20的条件，或者单个元素可以同时满足:

findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));

mongo shell：

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

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

使用$elemMatch操作符在数组的元素上指定多个条件，以便至少有一个数组元素满足所有指定的条件。
下面的示例查询的文档中，dim_cm数组包含至少一个元素，该元素大于($gt) 22，小于($lt) 30:

findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));

mongo shell：

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

10.3.3 根据数组索引位置查询元素

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

提示：使用点符号进行查询时，字段和嵌套字段必须放在引号内。

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

findIterable = collection.find(gt("dim_cm.1", 25));

mongo shell：

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

10.3.4 按数组长度查询数组

使用$size操作符按元素数量查询数组。例如，下面选择数组标记中有3个元素的文档。

findIterable = collection.find(size("tags", 3));

mongo shell：

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

11. 查询嵌入文档的数组

本页面提供了使用com.mongodb.client.MongoCollection.find方法对嵌套文档数组进行查询操作的示例。在MongoDB Java同步驱动程序中。

提示：驱动程序提供了 com.mongodb.client.model.Filters帮助器方法，以促进过滤器文档的创建。此页上的示例使用这些方法创建筛选器文档。

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

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

mongo shell：

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

13.1查询嵌套在数组中的文档

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

FindIterable<Document> findIterable = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));

mongo shell：

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

在整个嵌入/嵌套文档上的相等匹配要求与指定文档完全匹配，包括字段顺序。例如，以下查询与库存收集中的任何文档不匹配:

findIterable = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

mongo shell：

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

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

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

如果您不知道嵌套在数组中的文档的索引位置，请将数组字段的名称与嵌套文档中的点(.)和字段的名称连接起来。
以下示例选择instock数组中至少有一个嵌入文档的所有文档，该文档包含值小于或等于20的字段qty:

findIterable = collection.find(lte("instock.qty", 20));

mongo shell：

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

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

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

提示：使用点符号查询时，字段和索引必须在引号内。

下面的例子选择了instock数组中第一个元素为文档的所有文档，该文档包含的字段qty的值小于或等于20:

findIterable = collection.find(lte("instock.0.qty", 20));

mongo shell：

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

13.3为文档数组指定多个条件

当在文档数组中嵌套的多个字段上指定条件时，可以指定查询，使单个文档满足这些条件，或者数组中的任何文档组合(包括单个文档)满足这些条件。

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

使用$elemMatch操作符在嵌入文档数组上指定多个条件，以便至少有一个嵌入文档满足所有指定的条件。

以下示例查询instock数组中至少有一个嵌入文档的文档，其中包含字段qty等于5，字段仓库等于A:

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));

mongo shell：

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

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

findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));

mongo shell：

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

13.3.2 元素的组合满足条件

如果数组字段上的复合查询条件不使用$elemMatch操作符，则查询选择其数组包含满足条件的任何元素组合的文档。

例如，下面的查询匹配的文档中，嵌套在instock数组中的任何文档的qty字段都大于10，而数组中的任何文档(但不一定是相同的嵌入文档)的qty字段小于或等于20:

findIterable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));

mongo shell：

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

以下示例查询的文档中，instock数组至少有一个包含字段qty等于5的嵌入文档，并且至少有一个包含字段仓库等于A的嵌入文档(但不一定是相同的嵌入文档):

findIterable = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));

mongo shell：

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

14.要从查询返回的项目字段

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

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

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

mongo shell：

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

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

如果不指定投影，请使用com.mongodb.client.MongoCollection.find方法返回匹配文档中的所有字段。
下面的示例返回库存集合中状态为“A”的所有文档的所有字段:

FindIterable<Document> findIterable = collection.find(eq("status", "A"));

mongo shell：

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

操作对应如下SQL语句:

SELECT * from inventory WHERE status = "A"

14.2 只返回指定的字段和_id字段

通过在投影文档中将<字段>设置为1，投影可以显式地包含多个字段。下面的操作返回与查询匹配的所有文档。在结果集中，只有项、状态和默认情况下在匹配文档中返回的_id字段。

要指定投影文档，请链接com.mongodb.client.FindIterable.projection查找。该示例使用com.mongodb.client.model.Projections来创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status"));

mongo shell：

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

操作对应如下SQL语句:

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

14.3 抑制_id领域

可以在投影中将_id字段设置为0，从而从结果中删除它，如下面的示例所示:
要指定投影文档，请链接com.mongodb.client.FindIterable.projection到查找法。该示例使用com.mongodb.client.model.Projections类来创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));

mongo shell：

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

操作对应如下SQL语句:

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

提示：除了_id字段外，您不能在投影文档中组合包含和排除语句。

14.4 返回所有被排除的字段

可以使用投影来排除特定的字段，而不是在匹配的文档中列出要返回的字段。下面的示例返回匹配文档中除status和instock字段之外的所有字段:

findIterable = collection.find(eq("status", "A")).projection(exclude("item", "status"));

mongo shell：

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

提示：除了_id字段外，您不能在投影文档中组合包含和排除语句。

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

可以在嵌入的文档中返回特定的字段。使用点符号来引用嵌入的字段，并在投影文档中将其设置为1。

下面的例子返回:

_id字段(默认返回)，
item字段,
status字段,
size文档中的uom字段。

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

要指定投影文档，请链接com.mongodb.client.FindIterable.projection方法到find方法。该示例使用com.mongodb.client.model.Projections类来创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));

mongo shell：

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

14.6 禁止嵌入文档中的特定字段

可以在嵌入式文档中禁用特定字段。使用点符号来引用投影文档中的嵌入字段，并将其设置为0。

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

要指定投影文档，请链接com.mongodb.client.FindIterable.projection方法到find方法。该示例使用com.mongodb.client.model.Projections类来创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(exclude("size.uom"));

mongo shell：

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

14.7 在数组中嵌入文档上的投影

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

下面的例子指定了一个要返回的投影:

_id字段(默认返回)，
item字段,
status字段,
嵌入在instock数组中的文档中的qty字段。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));

mongo shell：

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

14.8 项目返回数组中的特定数组元素

对于包含数组的字段，MongoDB为操作数组提供了以下投影操作符:$elemMatch、$slice和$。

下面的例子使用$slice投影操作符来返回instock数组中的最后一个元素:

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

mongo shell：

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

$elemMatch、$slice和$是将特定元素投影到返回数组中的惟一方法。例如，您不能使用数组索引来投影特定的数组元素;例如，include(“instock.0”)投影将不会投影第一个元素的数组。

15.查询空字段或缺少字段

MongoDB中不同的查询操作符对空值的处理是不同的。

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

collection.insertMany(asList(
        Document.parse("{'_id': 1, 'item': null}"),
        Document.parse("{'_id': 2}")
));

15.1平等过滤器

eq(“item”，null)查询匹配的文档要么包含值为null的item字段，要么不包含item字段。

FindIterable<Document> findIterable = collection.find(eq("item", null));

mongo shell：

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

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

15.2 类型检查

type("item"， BsonType.NULL)查询只匹配包含值为null的item字段的文档;即项目字段的值为BSON类型Null(类型号为10):

findIterable = collection.find(type("item", BsonType.NULL));

mongo shell：

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

查询只返回项目字段值为null的文档。

15.3 存在检查

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

exists("item"， false)查询匹配不包含item字段的文档:

findIterable = collection.find(exists("item", false));

mongo shell：

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

查询只返回不包含项目字段的文档。

16.在mongo Shell中迭代游标

本节介绍：

手动遍历游标
迭代器指数
游标的行为
游标信息

db.collection.find()方法返回一个游标。要访问文档，需要迭代游标。但是，在mongo shell中，如果没有使用var关键字将返回的游标分配给变量，那么游标将自动迭代多达20次[1]来打印结果中的前20个文档。

以下示例描述手动迭代游标以访问文档或使用迭代器索引的方法。

16.1 手动遍历游标

在mongo shell中，当您使用var关键字将find()方法返回的游标分配给变量时，游标不会自动迭代。

可以在shell中调用游标变量，迭代多达20次，并打印匹配的文档，如下例所示:

var myCursor = db.users.find( { type: 2 } );

myCursor

mongo shell：

var myCursor = db.users.find( { type: 2 } );

myCursor

您还可以使用光标方法next()来访问文档，如下面的示例所示:

var myCursor = db.users.find( { type: 2 } );

while (myCursor.hasNext()) {
   print(tojson(myCursor.next()));
}

mongo shell：

var myCursor = db.users.find( { type: 2 } );

while (myCursor.hasNext()) {
   print(tojson(myCursor.next()));
}

作为另一种打印操作，可以考虑使用printjson()帮助方法来替代print(tojson()):

var myCursor = db.users.find( { type: 2 } );

while (myCursor.hasNext()) {
   printjson(myCursor.next());
}

mongo shell：

var myCursor = db.users.find( { type: 2 } );

while (myCursor.hasNext()) {
   printjson(myCursor.next());
}

您可以使用游标方法forEach()迭代游标并访问文档，如下面的示例所示:

var myCursor =  db.users.find( { type: 2 } );

myCursor.forEach(printjson);

mongo shell：

var myCursor =  db.users.find( { type: 2 } );

myCursor.forEach(printjson);

有关游标方法的更多信息，请参阅 JavaScript cursor methods和 driver程序文档。

提示：您可以使用DBQuery.shellBatchSize更改默认值20的迭代次数。有关更多信息，请参见Working with the mongo Shell 。

16.2 迭代器指数

在mongo shell中，可以使用toArray()方法迭代游标并返回数组中的文档，如下所示:

var myCursor = db.inventory.find( { type: 2 } );
var documentArray = myCursor.toArray();
var myDocument = documentArray[3];

toArray()方法将游标返回的所有文档加载到RAM中;toArray()方法将耗尽游标。

此外，一些驱动程序通过在游标上使用索引(即cursor[index])来提供对文档的访问。这是一个快捷方式，首先调用toArray()方法，然后在结果数组上使用索引。

考虑下面例子：

var myCursor = db.users.find( { type: 2 } );
var myDocument = myCursor[1];

myCursor[1]相当于下面的例子:

myCursor.toArray() [1];

16.3 游标的行为

16.3.1 关闭不活动的游标

默认情况下，服务器将在10分钟不活动后自动关闭游标，或者客户机已经耗尽游标。要在mongo shell中覆盖这种行为，可以使用cursor.noCursorTimeout()方法:

var myCursor = db.users.find().noCursorTimeout();

在设置noCursorTimeout选项之后，必须使用cursor.close()手动关闭游标，或者耗尽游标的结果。

有关设置noCursorTimeout选项的信息，请参阅驱动程序文档。

16.3.2 游标隔离

当游标返回文档时，其他操作可能与查询交织在一起。

16.3.3 游标批次

MongoDB服务器批量返回查询结果。批处理中的数据量不会超过最大BSON文档大小。要覆盖批处理的默认大小，请参见batchSize()和limit()。

新版本3.4:类型为find()、aggregate()、listIndexes和listCollections的操作每批最多返回16兆字节。batchSize()可以执行较小的限制，但不能执行较大的限制。

find()和aggregate()操作的初始批处理大小默认为101个文档。针对生成的游标发出的后续getMore操作没有默认的批处理大小，因此它们仅受16 mb消息大小的限制。

对于包含没有索引的排序操作的查询，服务器必须在返回任何结果之前加载内存中的所有文档来执行排序。

当您遍历游标并到达返回的批处理的末尾时，如果有更多的结果，cursor.next()将执行一个getMore操作来检索下一个批处理。要查看在迭代游标时批处理中还剩下多少文档，可以使用objsLeftInBatch()方法，如下面的示例所示:

var myCursor = db.inventory.find();

var myFirstDocument = myCursor.hasNext() ? myCursor.next() : null;

myCursor.objsLeftInBatch();

16.4 游标信息

db.serverStatus()方法返回一个包含metrics字段的文档。metrics字段包含一个 metrics.cursor字段，包含以下信息：

自上次服务器重新启动以来超时的游标数
使用选项DBQuery.Option.noTimeout打开游标的数量，以防止在一段时间不活动后超时
“pinned”打开游标的数目
打开游标的总数

考虑下面的示例，它调用db.serverStatus()方法并从结果中访问metrics字段，然后从metrics字段访问游标字段:

db.serverStatus().metrics.cursor

结果如下:

{
   "timedOut" : <number>
   "open" : {
      "noTimeout" : <number>,
      "pinned" : <number>,
      "total" : <number>
   }
}

三、更新文档

本页使用以下Java同步驱动程序方法:

com.mongodb.client.MongoCollection.updateOne
com.mongodb.client.MongoCollection.updateMany
com.mongodb.client.MongoCollection.replaceOne

mongo shell：

db.collection.updateOne(<filter>, <update>, <options>)
db.collection.updateMany(<filter>, <update>, <options>)
db.collection.replaceOne(<filter>, <update>, <options>)

本页中的示例使用库存收集。要创建和/或填充库存收集，运行以下命令:

collection.insertMany(asList(
        Document.parse("{ item: 'canvas', qty: 100, size: { h: 28, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mat', qty: 85, size: { h: 27.9, w: 35.5, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'mousepad', qty: 25, size: { h: 19, w: 22.85, uom: 'cm' }, status: 'P' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'P' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketchbook', qty: 80, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'sketch pad', qty: 95, size: { h: 22.85, w: 30.5, uom: 'cm' }, status: 'A' }")
));

mongo shell：

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

1.更新集合中的文档

要更新文档，MongoDB提供了诸如$set这样的更新操作符来修改字段值。
驱动程序提供了 com.mongodb.client.model.Updates类，以方便创建更新文档。例如:

combine(set( <field1>, <value1>), set(<field2>, <value2> ) )

mongo shell：

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

如果字段不存在，则一些更新操作符(如$set)将创建该字段。有关详细信息，请参阅单个更新操作符引用。

提示：从MongoDB 4.2开始，MongoDB可以接受聚合管道来指定要进行的修改，而不是更新文档。有关详细信息，请参阅方法参考页面。

2.更新单个文档

下面的示例使用 com.mongodb.client.MongoCollection.updateOne方法在库存收集更新第一个文件，其中item等于“paper”:

collection.updateOne(eq("item", "paper"),
        combine(set("size.uom", "cm"), set("status", "P"), currentDate("lastModified")));

mongo shell：

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

更新操作:

使用$set操作符更新大小的值。uom字段为“cm”，状态字段值为“P”，
使用$currentDate操作符将lastModified字段的值更新为当前日期。如果lastModified字段不存在，$currentDate将创建该字段。有关详细信息，请参见$currentDate。

3.更新多个文档

下面的示例使用com.mongodb.client.MongoCollection.updateMany方法库存收集上的，用于更新所有qty小于50的文档:

collection.updateMany(lt("qty", 50),
        combine(set("size.uom", "in"), set("status", "P"), currentDate("lastModified")));

mongo shell：

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

更新操作:

使用$set操作符更新大小的值。uom字段为“in”，状态字段值为“P”，
使用$currentDate操作符将lastModified字段的值更新为当前日期。如果lastModified字段不存在，$currentDate将创建该字段。有关详细信息，请参见$currentDate。

4. 替换一个文档

要替换除_id字段之外的整个文档内容，请将一个全新的文档作为第二个参数传递给com.mongodb.client.MongoCollection.replaceOne。

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

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

下面的例子替换了库存集合中的第一个文档，其中item:“paper”:

collection.replaceOne(eq("item", "paper"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 40 } ] }"));

mongo shell：

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

5.Behavior

5.1 原子性
MongoDB中的所有写操作都是单个文档级别上的原子操作。有关MongoDB和原子性的更多信息，请参见 Atomicity and Transactions。

5.2 _id 字段

一旦设置好，就不能更新_id字段的值，也不能用具有不同_id字段值的替换文档替换现有文档。

5.3 排序字段

除了以下情况外，MongoDB在写操作中保留了文档字段的顺序:

_id字段总是文档中的第一个字段。
包括重命名字段名的更新可能导致文档中字段的重新排序。

5.4 插入选项

如果更新和替换方法包含com.mongodb.client.model.UpdateOptions参数指定com.mongodb.client.model.UpdateOptions.upsert(true)，且没有文档匹配指定的过滤器，然后操作创建一个新文档并插入它。如果存在匹配的文档，则操作修改或替换匹配的文档。

有关创建的新文档的详细信息，请参阅方法的各个参考页面。

5.5 写确认

使用写关注点，您可以为写操作指定从MongoDB请求的确认级别。有关详细信息，请参见 Write Concern。

6. 更新方法

MongoDB提供了以下方法来更新集合中的文档:

`db.collection.updateOne()`	即使多个文档可能与指定的筛选器匹配，但最多只更新与指定筛选器匹配的单个文档。新版本3.2。
`db.collection.updateMany()`	更新所有匹配指定筛选器的文档。新版本3.2。
`db.collection.replaceOne()`	即使多个文档可能与指定的筛选器匹配，也最多替换一个与指定筛选器匹配的文档。新版本3.2。
`db.collection.update()`	更新或替换与指定筛选器匹配的单个文档，或更新与指定筛选器匹配的所有文档。默认情况下，db.collection.update()方法更新单个文档。若要更新多个文档，请使用multi选项。

其它附加方法：

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

四、删除文档

本页使用以下Java同步驱动程序方法:

com.mongodb.client.MongoCollection.deleteMany
com.mongodb.client.MongoCollection.deleteOne

mongo shell：

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

本页中的示例使用库存收集。要填充库存收集，运行以下命令:

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

mongo shell：

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

1.删除所有文档

若要从集合中删除所有文档，请传递一个空的org.bson.Document对象作为com.mongodb.client.MongoCollection.deleteMany方法的过滤器。

以下示例从库存收集中删除所有文档:

collection.deleteMany(new Document());

mongo shell：

db.inventory.deleteMany({})

com.mongodb.client.MongoCollection.deleteMany方法返回一个带有操作状态的com.mongodb.client.result.DeleteResult实例。

2.删除所有匹配条件的文档

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

要指定相等条件，请使用com.mongodb.client.model.Filters.eq_方法创建query filter document:

and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)

除了相等条件之外，MongoDB还提供了各种query operators来指定过滤条件。使用 com.mongodb.client.model.Filters帮助器方法，以促进过滤器文档的创建。例如:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

要删除符合删除条件的所有文档，需要向com.mongodb.client.MongoCollection.deleteMany方法传递一个过滤器参数。

以下示例从inventory集合中删除所有文档，其中状态字段等于“A”:

collection.deleteMany(eq("status", "A"));

mongo shell：

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

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

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

3.只删除一个匹配条件的文档

要删除最多一个匹配指定过滤器的文档(即使多个文档可能匹配指定过滤器)，请使用com.mongodb.client.MongoCollection.deleteOne方法。

以下示例删除状态为“D”的第一个文档:

collection.deleteOne(eq("status", "D"));

mongo shell：

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

4.删除的行为

4.1 索引

Delete操作不会删除索引，即使从集合中删除所有文档也是如此。

4.2 原子性

MongoDB中的所有写操作都是单个文档级别上的原子操作。有关MongoDB和原子性的更多信息，请参见Atomicity and Transactions。

4.3 写确认

使用写关注点，您可以为写操作指定从MongoDB请求的确认级别。有关详细信息，请参见 Write Concern。

五、删除方法

MongoDB提供了以下方法来删除一个集合的文档:

`db.collection.deleteOne()`	即使多个文档可能与指定的筛选器匹配，也最多删除与指定筛选器匹配的单个文档。新版本3.2。
`db.collection.deleteMany()`	删除所有匹配指定筛选器的文档。新版本3.2。
`db.collection.remove()`	删除与指定筛选器匹配的单个文档或所有文档。

1. 附加方法

以下方法也可以从一个集合中删除文档:

db.collection.findOneAndDelete().

findOneAndDelete()提供排序选项。该选项允许删除按指定顺序排序的第一个文档。
db.collection.findAndModify().

db.collection.findAndModify()提供排序选项。该选项允许删除按指定顺序排序的第一个文档。
db.collection.bulkWrite().

有关方法的更多信息和示例，请参见各个参考页面。

木西爷

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MongoDB CRUD基础操作

本例中将以java语言为例，进行讲解。其它语言可以参考：https://docs.mongodb.com/manual/tutorial/insert-documents/注：mongodb-java-driver 从3.0版本开始同时支持同步、异步方式（分别是不同的驱动应用）。本次介绍的插入是异步，其它均是同步。为了方便平时mongodb库操作，我会在介绍相关的java方法时，提供mon...
复制链接

扫一扫

专栏目录