对于 AI 代理：可在 https://www.mongodb.com/zh-cn/docs/llms.txt 获取文档索引—通过在任何 URL 路径后添加 .md 可获取所有页面的 Markdown 版本。
Docs 菜单
Docs 主页
/
开发中
/
增删改查操作
Docs 主页
/
开发中
/
增删改查操作
Docs 主页
/
开发中
/
增删改查操作

Delete Documents

在 MongoDB 中，删除操作包括从集合中删除文档。此页面提供示例。

您可以使用以下方法删除 MongoDB 中的文档：

➤ 使用右上角的 Select your language（选择语言）下拉菜单，设置以下示例的语言或选择 MongoDB Compass。

This page uses the following mongosh methods:

此页面上的示例使用的是 inventory 集合。要填充 inventory 集合，请执行以下操作：

本页面使用 MongoDB Compass 删除文档。

使用以下文档填充 inventory 集合：

此页面使用以下MongoDB C驱动程序方法：

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

本页使用以下MongoDB .NET/ C#驱动程序方法：

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

此页面使用以下 MongoDB Go 驱动程序 函数：

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

本页面使用以下 Java Reactive Streams 驱动程序方法：

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

此页面使用以下 Java 同步驱动程序 方法：

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

此页面使用以下Kotlin协程驱动程序方法：

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

此页面使用以下 Motor 驱动程序方法：

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

This page uses the following MongoDB Node.js Driver methods:

此页面上的示例使用的是 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 := []any{
	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'
  }
]);
$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 集合中的所有文档：

要删除集合中的所有文档，请单击 Documents标签页下的 DELETE 按钮。

如下示例将删除 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 集合中的所有文档：

To delete all documents from a collection, pass an empty filter document {} to the Collection.deleteMany() method.

如下示例将删除 inventory 集合中的所有文档：

要删除集合中的所有文档，请将空过滤文档 []传递给MongoDB\\Collection::deleteMany() 方法。

如下示例将删除 inventory 集合中的所有文档：

要删除集合中的所有文档，请将空过滤文档 {}传递给pymongo.collection.Collection.delete_many 方法。

如下示例将删除 inventory 集合中的所有文档：

要删除集合中的所有文档，请将一个空的过滤器文档 {} 传递给 Mongo::Collection#delete_many() 方法。

如下示例将删除 inventory 集合中的所有文档：

要删除集合中的所有文档，请将一个空的过滤器 Document() 传递给 collection.deleteMany()方法清空列表时）。

如下示例将删除 inventory 集合中的所有文档：

db.inventory.deleteMany({})
MongoDB Compass显示“文档”标签页，其中突出显示“删除”按钮。
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({});
$deleteResult = $db->inventory->deleteMany([]);
db.inventory.delete_many({})
client[:inventory].delete_many({})
collection.deleteMany(Document()).execute()

该方法返回一个包含运算状态的文档。有关更多信息和示例，请参阅deleteMany()。

在单击 DELETE 出现的弹出窗口中确认删除时，MongoDB Compass将删除所有文档并显示一条消息，指示已删除的文档数量。

如果成功， mongoc_collection_delete_many 方法会返回true false；如果参数无效或者出现服务器或网络错误，则返回 并设置错误。

成功执行后，IMongoCollection.DeleteMany() 方法会返回一个 DeleteResult实例，该实例的 DeletedCount属性包含与过滤匹配的文档数。

Upon successful execution, the Collection.DeleteMany function returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

com.mongodb.reactivestreams。 客户端.MongoCollection.deleteMany 返回 com.mongodb 类型的 Publisher对象。 客户端（如果成功）。如果不成功，则返回com.mongodb.MongoException 的实例。

MongoCollection.deleteMany() 方法返回 com.mongodb 的实例。 客户端.result.DeleteResult ，用于描述操作状态和已删除文档的计数。

The delete_many coroutine asynchronously returns an instance of pymongo.results.DeleteResult with the status of the operation.

Collection.deleteMany() returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

成功执行后，deleteMany() 方法会返回一个MongoDB\\DeleteResult getDeletedCount()实例，而该实例的 方法会返回与过滤匹配的文档数。

delete_manypymongo.results.DeleteResult方法返回包含操作状态的 实例。

成功执行后，delete_many() 方法会返回 Mongo::Operation::Result 的一个实例，其deleted_count 属性包含与过滤匹配的文档数量。

成功执行后，集合.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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

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

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

要删除所有符合删除条件的文档，请在Compass查询栏中写入查询筛选条件，然后单击 Documents 标签页下的 DELETE 按钮。以下示例删除所有包含 { status: "A" } 的文档：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请使用 Eq 方法构建过滤器：

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the delete_many method.

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

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请使用 Eq 方法构建过滤器：

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the delete_many method.

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

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：

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

要指定相等条件，请使用 Eq 方法构建过滤器：

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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>);

要指定相等条件，请使用 bson.D 类型创建过滤器文档：

filter := bson.D{{"<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>, ... }

要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：

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

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

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

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

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

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

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

除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

除了相等过滤之外， MongoDB还提供各种查询运算符来指定过滤条件。使用BSON包为过滤文档创建查询操作符。 示例：

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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>))

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

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

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

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

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

[ <field1> => [ <operator1> => <value1> ], ... ]

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

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

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

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

除了相等条件外，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" })
MongoDB Compass 文档标签页，其中突出显示“删除”按钮。
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' });
$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()。

在单击 DELETE 出现的弹出窗口中确认删除时，MongoDB Compass将删除所有文档并显示一条消息，指示已删除的文档数量。

如果成功， mongoc_collection_delete_many 方法会返回true false；如果参数无效或者出现服务器或网络错误，则返回 并设置错误。

成功执行后，IMongoCollection.DeleteMany() 方法会返回一个 DeleteResult实例，该实例的 DeletedCount属性包含与过滤匹配的文档数。

Upon successful execution, the Collection.DeleteMany function returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

com.mongodb.reactivestreams。 客户端.MongoCollection.deleteMany 返回 com.mongodb 类型的 Publisher对象。 客户端（如果成功）。如果不成功，则返回com.mongodb.MongoException 的实例。

MongoCollection.deleteMany() 方法返回 com.mongodb 的实例。 客户端.result.DeleteResult ，用于描述操作状态和已删除文档的计数。

The delete_many coroutine asynchronously returns an instance of pymongo.results.DeleteResult with the status of the operation.

Collection.deleteMany() returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

成功执行后，deleteMany() 方法会返回一个MongoDB\\DeleteResult getDeletedCount()实例，而该实例的 方法会返回与过滤匹配的文档数。

delete_manypymongo.results.DeleteResult方法返回包含操作状态的 实例。

成功执行后，delete_many() 方法会返回 Mongo::Operation::Result 的一个实例，其deleted_count 属性包含与过滤匹配的文档数量。

成功执行后，集合.deleteMany() 方法将返回一个具有单个元素的 Observable，该元素具有DeleteResult 类型参数或具有com.mongodb.MongoException 。

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

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

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

要删除与指定过滤器匹配的单个文档：

  1. 在Compass查询栏中写入查询筛选条件，然后单击 Find。

  2. 将鼠标悬停在要删除的文档上。

  3. 单击文档右侧的 按钮。

以下示例从 inventory集合中删除一个带有 { status: "A" } 的文档：

要从集合中删除单个文档，请将 mongoc_collection_t 和与要删除的文档匹配的 bson_t 传递给 mongoc_collection_delete_one 方法。

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

要删除最多一个与指定过滤器匹配的文档（即使可能存在多个与指定过滤器匹配的文档），请使用 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()方法。

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the motor.motor_asyncio.AsyncIOMotorCollection.delete_one method.

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

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the Collection.deleteOne() method.

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

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the MongoDB\\Collection::deleteOne() method.

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

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the pymongo.collection.Collection.delete_one method.

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

要删除最多与指定过滤器匹配的单个文档（即使可能有多个文档与指定过滤器匹配），请使用 Mongo::Collection#delete_one() 方法。

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

要删除最多一个与指定的筛选器匹配的文档（即使指定的筛选器可能存在多个匹配的文档），请使用 Collection.deleteOne() 方法清空列表时）。

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

db.inventory.deleteOne( { status: "D" } )
MongoDB Compass删除与过滤器匹配的一个文档
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"));

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

await db.inventory.delete_one({"status": "D"})
await db.collection('inventory').deleteOne({ 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 中的文档，请按以下步骤操作：

1

在 MongoDB Atlas 用户界面中，转到您项目的 Clusters（集群）页面。

  1. 如果尚未显示，请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示，请从导航栏的 Projects 菜单中选择您的项目。

  3. 在侧边栏中，单击 Database 标题下的 Clusters。

    会显示集群页面。

2

导航至集合。

  1. 对于包含样本数据的集群，单击Browse Collections 。

  2. 在左侧导航窗格中，选择 sample_mflix 数据库。

  3. 选择 movies 集合。

3

指定查询筛选文档。

或者，您可以在 Filter 字段中指定查询过滤器文档。查询过滤器文档使用查询操作符来指定搜索条件。

将以下查询筛选器文档复制到 Filter 搜索栏，然后单击 Apply：

{ genres: "Action", rated: { $in: [ "PG", "PG-13" ] } }

此查询筛选器会返回 sample_mflix.movies 集合中所有符合以下条件的文档：genres 等于 Action ，且 rated 等于 PG 或 PG-13。

4

删除文档。

  1. 对于要删除的文档，将鼠标悬停在该文档上方，然后单击右侧显示的垃圾桶图标。

    单击“删除”按钮后，MongoDB Atlas 会标记此文档以便进行删除并要求您确认。

  2. 单击 Delete 以确认您的选择。

要了解更多信息，请参阅创建、查看、更新和删除文档。

删除行为

索引

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

注意

原子性和写入确认

MongoDB 写入操作在单个文档级别上是原子性的。有关更多信息，请参阅 原子性和事务。

您还可以使用写关注（write concern）来指定MongoDB为写入操作请求的确认级别。有关更多信息，请参阅写关注（write concern）。

后退
生命周期图
来年
SQL 至 MongoDB
获得技能徽章

免费掌握“CRUD 操作”！

了解详情
给本页内容打分

在此页面上