Delete Documents
您可以使用以下方法删除 MongoDB 中的文档：
您的编程语言的驱动程序。
MongoDB Atlas 用户界面。要了解更多信息，请参阅使用 MongoDB Atlas 删除文档。
➤ 使用右上角的 Select your language（选择语言）下拉菜单，设置以下示例的语言或选择 MongoDB Compass。
本页面使用以下 mongosh 方法：
此页面上的示例使用的是 inventory 集合。要填充 inventory 集合，请执行以下操作：
本页面使用 MongoDB Compass 删除文档。
使用以下文档填充 inventory 集合：
此页面使用以下 MongoDB C驱动程序 方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB C# 驱动程序方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB Go 驱动程序 函数：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面使用以下 Java Reactive Streams 驱动程序方法：
com.mongodb.reactivestreams.client.MongoCollection.deleteMany
com.mongodb.reactivestreams.client.MongoCollection.deleteOne
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 Java 同步驱动程序 方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下Kotlin协程驱动程序方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB Node.js 驱动程序 方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB Perl 驱动程序 方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面使用以下 MongoDB PHP 库方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面使用以下 PyMongo Python 驱动方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB Ruby 驱动程序方法：
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面使用以下 MongoDB Scala 驱动程序 方法：
此页面上的示例使用的是 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: "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": "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" } ]
有关在 MongoDB Compass 中插入文档的说明，请参阅插入文档。
注意
有关在 MongoDB Compass 中插入文档的完整参考信息，请参阅 Compass 文档。
mongoc_collection_t *collection; mongoc_bulk_operation_t *bulk; bson_t *doc; bool r; bson_error_t error; bson_t reply; collection = mongoc_database_get_collection (db, "inventory"); bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL); doc = BCON_NEW ( "item", BCON_UTF8 ("journal"), "qty", BCON_INT64 (25), "size", "{", "h", BCON_DOUBLE (14), "w", BCON_DOUBLE (21), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("notebook"), "qty", BCON_INT64 (50), "size", "{", "h", BCON_DOUBLE (8.5), "w", BCON_DOUBLE (11), "uom", BCON_UTF8 ("in"), "}", "status", BCON_UTF8 ("P")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("paper"), "qty", BCON_INT64 (100), "size", "{", "h", BCON_DOUBLE (8.5), "w", BCON_DOUBLE (11), "uom", BCON_UTF8 ("in"), "}", "status", BCON_UTF8 ("D")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("planner"), "qty", BCON_INT64 (75), "size", "{", "h", BCON_DOUBLE (22.85), "w", BCON_DOUBLE (30), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("D")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } doc = BCON_NEW ( "item", BCON_UTF8 ("postcard"), "qty", BCON_INT64 (45), "size", "{", "h", BCON_DOUBLE (10), "w", BCON_DOUBLE (15.25), "uom", BCON_UTF8 ("cm"), "}", "status", BCON_UTF8 ("A")); r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error); bson_destroy (doc); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; } /* "reply" is initialized on success or error */ r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error); if (!r) { MONGOC_ERROR ("%s\n", error.message); }
var documents = new[] { new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } }, { "status", "A" } }, new BsonDocument { { "item", "notebook" }, { "qty", 50 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } }, { "status", "P" } }, new BsonDocument { { "item", "paper" }, { "qty", 100 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } }, { "status", "D" } }, new BsonDocument { { "item", "planner" }, { "qty", 75 }, { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } }, { "status", "D" } }, new BsonDocument { { "item", "postcard" }, { "qty", 45 }, { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } }, { "status", "A" } } }; collection.InsertMany(documents);
docs := []interface{}{ bson.D{ {"item", "journal"}, {"qty", 25}, {"size", bson.D{ {"h", 14}, {"w", 21}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "notebook"}, {"qty", 50}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "P"}, }, bson.D{ {"item", "paper"}, {"qty", 100}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "D"}, }, bson.D{ {"item", "planner"}, {"qty", 75}, {"size", bson.D{ {"h", 22.85}, {"w", 30}, {"uom", "cm"}, }}, {"status", "D"}, }, bson.D{ {"item", "postcard"}, {"qty", 45}, {"size", bson.D{ {"h", 10}, {"w", 15.25}, {"uom", "cm"}, }}, {"status", "A"}, }, } result, err := coll.InsertMany(context.TODO(), docs)
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' }") ));
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' }") ));
collection.insertMany( listOf( Document("item", "journal") .append("qty", 25) .append("size", Document("h", 14).append("w", 21).append("uom", "cm")) .append("status", "A"), Document("item", "notebook") .append("qty", 50) .append("size", Document("h", 8.5).append("w", 11).append("uom", "in")) .append("status", "A"), Document("item", "paper") .append("qty", 100) .append("size", Document("h", 8.5).append("w", 11).append("uom", "in")) .append("status", "D"), Document("item", "planner") .append("qty", 75) .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm")) .append("status", "D"), Document("item", "postcard") .append("qty", 45) .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm")) .append("status", "A"), ) )
await db.inventory.insert_many( [ { "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", }, ] )
await db.collection('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' } ]);
$db->coll("inventory")->insert_many( [ { 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" } ] );
$insertManyResult = $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', ], ]);
db.inventory.insert_many( [ { "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", }, ] )
client[:inventory].insert_many([ { 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' }, ])
collection.insertMany(Seq( Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""), Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""), Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""), Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""), Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""") )).execute()
删除所有文档
要删除集合中的所有文档，请将空的过滤器文档 {} 传递给 db.collection.deleteMany() 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将 mongoc_collection_t 和一个 bson_t 将所有文档与 mongoc_collection_delete_many 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器 Builders<BsonDocument>.Filter.Empty 传递给 IMongoCollection.DeleteMany() 方法。
如下示例将删除 inventory 集合中的所有文档：
要从集合中删除所有文档，请将空过滤器文档传递给 Collection.DeleteMany 函数。
如下示例将删除 inventory 集合中的所有文档：
要从集合中删除所有文档，请将一个空的 org.bson.Document 对象作为过滤器传递给 com.mongodb.reactivestreams.client.MongoCollection.deleteMany 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的 org.bson.Document 对象作为过滤器传递给 com.mongodb.client.MongoCollection.deleteMany 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将空Bson 对象作为 过滤 传递给 MongoCollection.deleteMany()方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器文档 {} 传递给 motor.motor_asyncio.AsyncIOMotorCollection.delete_many 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器文档 {} 传递给 Collection.deleteMany() 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将空的过滤器文档 {} 传递给 MongoDB::Collection::delete_many() 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将空的过滤器文档 [] 传递给 MongoDB\\Collection::deleteMany() 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器文档 {} 传递给 pymongo.collection.Collection.delete_many 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器文档 {} 传递给 Mongo::Collection#delete_many() 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除集合中的所有文档，请将一个空的过滤器 Document() 传递给 collection.deleteMany()方法。
如下示例将删除 inventory 集合中的所有文档：
db.inventory.deleteMany({})
mongoc_collection_t *collection; bson_t *selector; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW (NULL); r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error); bson_destroy (selector); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
var filter = Builders<BsonDocument>.Filter.Empty; var result = collection.DeleteMany(filter);
result, err := coll.DeleteMany(context.TODO(), bson.D{})
Publisher<DeleteResult> deleteManyPublisher = collection.deleteMany(new Document());
collection.deleteMany(new Document());
collection.deleteMany(empty())
await db.inventory.delete_many({})
await db.collection('inventory').deleteMany({});
$db->coll("inventory")->delete_many( {} );
$deleteResult = $db->inventory->deleteMany([]);
db.inventory.delete_many({})
client[:inventory].delete_many({})
collection.deleteMany(Document()).execute()
该方法返回一个包含运算状态的文档。有关更多信息和示例，请参阅deleteMany()。
mongoc_collection_delete_many true如果成功，方法会返回false 如果参数无效或者出现服务器或网络错误，则返回 并设置错误。
执行成功后，IMongoCollection.DeleteMany() 方法会返回 DeleteResult 的一个实例，其 DeletedCount 属性包含与过滤器匹配的文档数量。
成功执行后，Collection.DeleteMany 函数会返回一个 DeleteResult 实例，其 DeletedCount 属性包含与过滤器匹配的文档数。
如果成功，com.mongodb.reactivestreams.client.MongoCollection.deleteMany 会返回一个类型为 com.mongodb.client.result.DeleteResult 的 Publisher 对象。如果不成功，则返回一个 com.mongodb.MongoException 实例。
MongoCollection.deleteMany() 方法返回 com.mongodb 的实例。 客户端.result.DeleteResult 描述操作状态和已删除文档的计数。
delete_many 协程会异步返回一个包含操作状态的 pymongo.results.DeleteResult 实例。
deleteMany() 会返回一个提供 result 的 Promise。result.deletedCount 属性包含与过滤器匹配的文档数。
成功执行后，delete _many() 方法会返回 MongoDB::DeleteResult 的一个实例，其 deleted_count 属性包含匹配过滤器的文档数。
成功执行后，deleteMany() 方法将返回 MongoDB\\DeleteResult 的实例，该实例的 getDeletedCount() 方法返回与过滤器匹配的文档数。
delete_many 方法会返回一个包含操作状态的 pymongo.results.DeleteResult 的实例。
成功执行后，delete_many() 方法会返回一个 Mongo::Operation::Result 实例，其 deleted_count 属性包含匹配过滤器的文档数量。
成功执行后，collection.deleteMany() 方法返回一个 Observable，其中带有 DeleteResult 类型参数或 com.mongodb.MongoException 的单元素。
删除符合条件的所有文档
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 deleteMany() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 mongoc_collection_t 和一个 bson_t 将要删除的文档与 mongoc_collection_delete_many 方法。
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 IMongoCollection.DeleteMany() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 Collection.DeleteMany 函数。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将过滤器参数传递给 com.mongodb.reactivestreams.client.MongoCollection.deleteMany 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请传递一个过滤器参数给 com.mongodb.client.mongoCollection.d eleteMany 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 过滤 参数传递给 MongoCollection.deleteMany()方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 delete_many 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 deleteMany() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将过滤器参数传递给 delete_many() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将过滤器参数传递给 deleteMany() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 delete_many 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除与删除条件匹配的所有文档，请将过滤器参数传递给 delete_many() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的事务语法。
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请使用 Filters.eq()创建查询过滤文档的方法：
and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
要删除所有符合删除条件的文档，请将 filter 参数传递给 deleteMany() 方法。
以下示例从 status 字段等于 "A" 的 inventory 集合中删除所有文档：
db.inventory.deleteMany({ status : "A" })
mongoc_collection_t *collection; bson_t *selector; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW ("status", BCON_UTF8 ("A")); r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error); bson_destroy (selector); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
var filter = Builders<BsonDocument>.Filter.Eq("status", "A"); var result = collection.DeleteMany(filter);
result, err := coll.DeleteMany( context.TODO(), bson.D{ {"status", "A"}, }, )
deleteManyPublisher = collection.deleteMany(eq("status", "A"));
collection.deleteMany(eq("status", "A"));
collection.deleteMany(eq("status", "A"));
await db.inventory.delete_many({"status": "A"})
await db.collection('inventory').deleteMany({ status: 'A' });
$db->coll("inventory")->delete_many( { status => "A" } );
$deleteResult = $db->inventory->deleteMany(['status' => 'A']);
db.inventory.delete_many({"status": "A"})
client[:inventory].delete_many(status: 'A')
collection.deleteMany(equal("status", "A")).execute()
该方法返回一个包含运算状态的文档。有关更多信息和示例，请参阅deleteMany()。
mongoc_collection_delete_many true如果成功，方法会返回false 如果参数无效或者出现服务器或网络错误，则返回 并设置错误。
执行成功后，IMongoCollection.DeleteMany() 方法会返回 DeleteResult 的一个实例，其 DeletedCount 属性包含与过滤器匹配的文档数量。
成功执行后，Collection.DeleteMany 函数会返回一个 DeleteResult 实例，其 DeletedCount 属性包含与过滤器匹配的文档数。
如果成功，com.mongodb.reactivestreams.client.MongoCollection.deleteMany 会返回一个类型为 com.mongodb.client.result.DeleteResult 的 Publisher 对象。如果不成功，则返回一个 com.mongodb.MongoException 实例。
MongoCollection.deleteMany() 方法返回 com.mongodb 的实例。 客户端.result.DeleteResult 描述操作状态和已删除文档的计数。
delete_many 协程会异步返回一个包含操作状态的 pymongo.results.DeleteResult 实例。
deleteMany() 会返回一个提供 result 的 Promise。result.deletedCount 属性包含与过滤器匹配的文档数。
成功执行后，delete _many() 方法会返回 MongoDB::DeleteResult 的一个实例，其 deleted_count 属性包含匹配过滤器的文档数。
成功执行后，deleteMany() 方法将返回 MongoDB\\DeleteResult 的实例，该实例的 getDeletedCount() 方法返回与过滤器匹配的文档数。
delete_many 方法会返回一个包含操作状态的 pymongo.results.DeleteResult 的实例。
成功执行后，delete_many() 方法会返回一个 Mongo::Operation::Result 实例，其 deleted_count 属性包含匹配过滤器的文档数量。
成功执行后，collection.deleteMany() 方法返回一个 Observable，其中带有 DeleteResult 类型参数或 com.mongodb.MongoException 的单元素。
仅删除一个符合条件的文档
要删除最多一个与指定的筛选器匹配的文档（即使指定的筛选器可能存在多个匹配的文档），请使用 db.collection.deleteOne() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
MongoDB Compass 提供了一种从集合中删除文档的简单方法。以下示例展示了如何从 inventory 集合中删除 item 等于 paper的文档：
注意
本示例使用 Compass 表格视图删除文档。使用 Compass 列表视图的删除过程遵循非常相似的方法。
有关 Compass 中表视图和列表视图之间区别的更多信息，请参阅Compass 文档。
要从集合中删除单个文档，请将 mongoc_collection_t 和一个 bson_t 将要删除的文档与 mongoc_collection_delete_one 方法。
如下示例将删除 inventory 集合中的所有文档：
要删除最多一个与指定过滤器匹配的文档（即使可能存在多个与指定过滤器匹配的文档），请使用 IMongoCollection.DeleteOne() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多一个与指定的过滤器匹配的文档（即使指定的过滤器可能存在多个匹配的文档），请使用 Collection.DeleteOne 函数。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 com.mongodb.reactivestreams.client.MongoCollection.deleteMany 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 com.mongodb.client.MongoCollection.deleteOne 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要最多删除与指定过滤匹配的单个文档，即使有多个文档与指定过滤匹配，也可以使用 MongoCollection.deleteOne()方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 motor.motor_asyncio.AsyncIOMotorCollection.delete_one 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多一个与指定的过滤器匹配的文档（即使指定的过滤器可能存在多个匹配的文档），请使用 Collection.deleteOne() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多一个与指定过滤器匹配的文档（即使可能存在多个与指定过滤器匹配的文档），请使用 MongoDB::Collection::delete_one() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除与指定过滤器匹配的最多单个文档（即使可能有多个文档与指定过滤器匹配），请使用 MongoDB\\Collection::deleteOne() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 pymongo.collection.Collection.delete_one 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 Mongo::Collection#delete_one() 方法。
如下示例将删除 status 为 "D" 的第一个文档：
要删除最多一个与指定的筛选器匹配的文档（即使指定的筛选器可能存在多个匹配的文档），请使用 Collection.deleteOne() 方法清空列表时）。
如下示例将删除 status 为 "D" 的第一个文档：
db.inventory.deleteOne( { status: "D" } )
mongoc_collection_t *collection; bson_t *selector; bool r; bson_error_t error; collection = mongoc_database_get_collection (db, "inventory"); selector = BCON_NEW ("status", BCON_UTF8 ("D")); r = mongoc_collection_delete_one (collection, selector, NULL, NULL, &error); bson_destroy (selector); if (!r) { MONGOC_ERROR ("%s\n", error.message); goto done; }
此外，请务必根据需要调用以下方法来清理所有打开的资源：
var filter = Builders<BsonDocument>.Filter.Eq("status", "D"); var result = collection.DeleteOne(filter);
result, err := coll.DeleteOne( context.TODO(), bson.D{ {"status", "D"}, }, )
Publisher<DeleteResult> deleteOnePublisher = collection.deleteOne(eq("status", "D"));
collection.deleteOne(eq("status", "D"));
await db.inventory.delete_one({"status": "D"})
await db.collection('inventory').deleteOne({ status: 'D' });
$db->coll("inventory")->delete_one( { status => "D" } );
$deleteResult = $db->inventory->deleteOne(['status' => 'D']);
db.inventory.delete_one({"status": "D"})
client[:inventory].delete_one(status: 'D')
collection.deleteOne(equal("status", "D")).execute()
使用 MongoDB Atlas 删除文档
注意
在 MongoDB Atlas 用户界面中，一次只能删除一个文档。要删除多个文档，请从 mongosh 或 MongoDB 驱动程序连接到您的 Atlas 部署，然后按照本页面上的示例选择您的首选方法。
本部分的示例使用的是示例电影数据集。要了解如何将示例数据集加载到您的 MongoDB Atlas 部署中，请参阅加载示例数据。
要删除 MongoDB Atlas 中的文档，请按以下步骤操作：
在MongoDB Atlas用户界面中，转到项目的Clusters 页面。
如果尚未显示，请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示，请从导航栏的 Projects 菜单中选择您的项目。
如果尚未显示，请单击侧边栏中的Clusters 。
会显示集群页面。
要了解更多信息，请参阅创建、查看、更新和删除文档。
删除行为
索引
即使从集合中删除所有文档，删除操作也不会删除索引。
原子性(Atomicity)
MongoDB 中的所有写入操作在单个文档级别上都是原子性的。有关 MongoDB 和原子性的更多信息，请参阅原子性和事务。
写确认
对于写关注，您可以指定 MongoDB 请求的写操作确认级别。有关详细信息，请参阅写关注。