本例中将以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 theupsert: true
option.db.collection.updateOne()
when used with theupsert: true
option.db.collection.updateMany()
when used with theupsert: true
option.db.collection.findAndModify()
when used with theupsert: true
option.db.collection.findOneAndUpdate()
when used with theupsert: true
option.db.collection.findOneAndReplace()
when used with theupsert: 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() | 即使多个文档可能与指定的筛选器匹配,但最多只更新与指定筛选器匹配的单个文档。 |
db.collection.updateMany() | 更新所有匹配指定筛选器的文档。 |
db.collection.replaceOne() | 即使多个文档可能与指定的筛选器匹配,也最多替换一个与指定筛选器匹配的文档。 |
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()
提供排序选项。该选项允许删除按指定顺序排序的第一个文档。
有关方法的更多信息和示例,请参见各个参考页面。